fix: use getThinWaistAddresss function (#3047)

Instead of every tcp/udp transport calculating thin waist addresses,
use the function in `@libp2p/utils` instead.

Author: achingbrain

packages/transport-tcp/package.json

@@ -62,8 +62,8 @@
   "dependencies": {
     "@libp2p/interface": "^2.7.0",
     "@libp2p/utils": "^6.5.8",
-    "@multiformats/mafmt": "^12.1.6",
     "@multiformats/multiaddr": "^12.3.3",
+    "@multiformats/multiaddr-matcher": "^1.6.0",
     "@types/sinon": "^17.0.3",
     "p-defer": "^4.0.1",
     "p-event": "^6.0.1",

packages/transport-tcp/src/constants.ts

@@ -1,10 +1,5 @@
-// p2p multi-address code
-export const CODE_P2P = 421
-export const CODE_CIRCUIT = 290
-export const CODE_UNIX = 400
-
 // Time to wait for a connection to close gracefully before destroying it manually
 export const CLOSE_TIMEOUT = 500
 
 // Close the socket if there is no activity after this long in ms
-export const SOCKET_TIMEOUT = 2 * 60000 // 2 mins
+export const SOCKET_TIMEOUT = 2 * 60_000 // 2 mins

packages/transport-tcp/src/listener.ts

@@ -1,14 +1,12 @@
 import net from 'net'
 import { AlreadyStartedError, InvalidParametersError, NotStartedError, TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
+import { multiaddr } from '@multiformats/multiaddr'
 import { pEvent } from 'p-event'
-import { CODE_P2P } from './constants.js'
 import { toMultiaddrConnection } from './socket-to-conn.js'
-import {
-  getMultiaddrs,
-  multiaddrToNetConfig,
-  type NetConfig
-} from './utils.js'
+import { multiaddrToNetConfig } from './utils.js'
 import type { TCPCreateListenerOptions } from './index.js'
+import type { NetConfig } from './utils.js'
 import type { ComponentLogger, Logger, MultiaddrConnection, CounterGroup, MetricGroup, Metrics, Listener, ListenerEvents, Upgrader } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -61,7 +59,6 @@ enum TCPListenerStatusCode {
 type Status = { code: TCPListenerStatusCode.INACTIVE } | {
   code: Exclude<TCPListenerStatusCode, TCPListenerStatusCode.INACTIVE>
   listeningAddr: Multiaddr
-  peerId: string | null
   netConfig: NetConfig
 }
 
@@ -247,31 +244,20 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
       return []
     }
 
-    let addrs: Multiaddr[] = []
     const address = this.server.address()
-    const { listeningAddr, peerId } = this.status
 
     if (address == null) {
       return []
     }
 
     if (typeof address === 'string') {
-      addrs = [listeningAddr]
-    } else {
-      try {
-        // Because TCP will only return the IPv6 version
-        // we need to capture from the passed multiaddr
-        if (listeningAddr.toString().startsWith('/ip4')) {
-          addrs = addrs.concat(getMultiaddrs('ip4', address.address, address.port))
-        } else if (address.family === 'IPv6') {
-          addrs = addrs.concat(getMultiaddrs('ip6', address.address, address.port))
-        }
-      } catch (err) {
-        this.log.error('could not turn %s:%s into multiaddr', address.address, address.port, err)
-      }
+      return [
+        // TODO: wrap with encodeURIComponent https://github.com/multiformats/multiaddr/pull/174
+        multiaddr(`/unix/${address}`)
+      ]
     }
 
-    return addrs.map(ma => peerId != null ? ma.encapsulate(`/p2p/${peerId}`) : ma)
+    return getThinWaistAddresses(this.status.listeningAddr, address.port)
   }
 
   updateAnnounceAddrs (): void {
@@ -283,16 +269,11 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
       throw new AlreadyStartedError('server is already listening')
     }
 
-    const peerId = ma.getPeerId()
-    const listeningAddr = peerId == null ? ma.decapsulateCode(CODE_P2P) : ma
-    const { backlog } = this.context
-
     try {
       this.status = {
         code: TCPListenerStatusCode.ACTIVE,
-        listeningAddr,
-        peerId,
-        netConfig: multiaddrToNetConfig(listeningAddr, { backlog })
+        listeningAddr: ma,
+        netConfig: multiaddrToNetConfig(ma, this.context)
       }
 
       await this.resume()

packages/transport-tcp/src/tcp.ts

@@ -29,9 +29,8 @@
 
 import net from 'net'
 import { AbortError, TimeoutError, serviceCapabilities, transportSymbol } from '@libp2p/interface'
-import * as mafmt from '@multiformats/mafmt'
+import { TCP as TCPMatcher } from '@multiformats/multiaddr-matcher'
 import { CustomProgressEvent } from 'progress-events'
-import { CODE_CIRCUIT, CODE_P2P, CODE_UNIX } from './constants.js'
 import { TCPListener } from './listener.js'
 import { toMultiaddrConnection } from './socket-to-conn.js'
 import { multiaddrToNetConfig } from './utils.js'
@@ -204,19 +203,7 @@ export class TCP implements Transport<TCPDialEvents> {
    * Takes a list of `Multiaddr`s and returns only valid TCP addresses
    */
   listenFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
-    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
-
-    return multiaddrs.filter(ma => {
-      if (ma.protoCodes().includes(CODE_CIRCUIT)) {
-        return false
-      }
-
-      if (ma.protoCodes().includes(CODE_UNIX)) {
-        return true
-      }
-
-      return mafmt.TCP.matches(ma.decapsulateCode(CODE_P2P))
-    })
+    return multiaddrs.filter(ma => TCPMatcher.exactMatch(ma) || ma.toString().startsWith('/unix/'))
   }
 
   /**

packages/transport-tcp/src/utils.ts

@@ -1,11 +1,8 @@
 import os from 'os'
 import path from 'path'
-import { multiaddr } from '@multiformats/multiaddr'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ListenOptions, IpcSocketConnectOpts, TcpSocketConnectOpts } from 'net'
 
-const ProtoFamily = { ip4: 'IPv4', ip6: 'IPv6' }
-
 export type NetConfig = ListenOptions | (IpcSocketConnectOpts & TcpSocketConnectOpts)
 
 export function multiaddrToNetConfig (addr: Multiaddr, config: NetConfig = {}): NetConfig {
@@ -30,30 +27,3 @@ export function multiaddrToNetConfig (addr: Multiaddr, config: NetConfig = {}):
     ipv6Only: options.family === 6
   }
 }
-
-export function getMultiaddrs (proto: 'ip4' | 'ip6', ip: string, port: number): Multiaddr[] {
-  const toMa = (ip: string): Multiaddr => multiaddr(`/${proto}/${ip}/tcp/${port}`)
-  return (isAnyAddr(ip) ? getNetworkAddrs(ProtoFamily[proto]) : [ip]).map(toMa)
-}
-
-export function isAnyAddr (ip: string): boolean {
-  return ['0.0.0.0', '::'].includes(ip)
-}
-
-const networks = os.networkInterfaces()
-
-function getNetworkAddrs (family: string): string[] {
-  const addresses: string[] = []
-
-  for (const [, netAddrs] of Object.entries(networks)) {
-    if (netAddrs != null) {
-      for (const netAddr of netAddrs) {
-        if (netAddr.family === family) {
-          addresses.push(netAddr.address)
-        }
-      }
-    }
-  }
-
-  return addresses
-}

packages/transport-tcp/test/filter.spec.ts

@@ -32,6 +32,8 @@ describe('filter addrs', () => {
     expect(valid.length).to.equal(5)
     expect(valid[0]).to.deep.equal(ma1)
     expect(valid[1]).to.deep.equal(ma4)
+    expect(valid[2]).to.deep.equal(ma7)
+    expect(valid[3]).to.deep.equal(ma8)
     expect(valid[4]).to.deep.equal(ma9)
   })
 

packages/transport-tcp/test/listen-dial.spec.ts

@@ -150,18 +150,6 @@ describe('listen', () => {
     expect(multiaddrs.length > 0).to.equal(true)
     expect(multiaddrs[0].toOptions().host).to.not.equal('::')
   })
-
-  it('getAddrs preserves IPFS Id', async () => {
-    const mh = multiaddr('/ip4/127.0.0.1/tcp/9090/ipfs/Qmb6owHp6eaWArVbcJJbQSyifyJBttMMjYV76N2hMbf5Vw')
-    listener = transport.createListener({
-      upgrader
-    })
-    await listener.listen(mh)
-
-    const multiaddrs = listener.getAddrs()
-    expect(multiaddrs.length).to.equal(1)
-    expect(multiaddrs[0]).to.deep.equal(mh)
-  })
 })
 
 describe('dial', () => {

packages/transport-webrtc/src/private-to-public/listener.ts

@@ -1,8 +1,8 @@
-import { networkInterfaces } from 'node:os'
 import { isIPv4, isIPv6 } from '@chainsafe/is-ip'
 import { InvalidPeerIdError, TypedEventEmitter } from '@libp2p/interface'
-import { multiaddr, protocols, fromStringTuples } from '@multiformats/multiaddr'
-import { IP4, WebRTCDirect } from '@multiformats/multiaddr-matcher'
+import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
+import { multiaddr, fromStringTuples } from '@multiformats/multiaddr'
+import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { Crypto } from '@peculiar/webcrypto'
 import getPort from 'get-port'
 import pWaitFor from 'p-wait-for'
@@ -40,10 +40,6 @@ export interface WebRTCListenerMetrics {
   listenerEvents: CounterGroup
 }
 
-const UDP_PROTOCOL = protocols('udp')
-const IP4_PROTOCOL = protocols('ip4')
-const IP6_PROTOCOL = protocols('ip6')
-
 interface UDPMuxServer {
   server: Promise<StunServer>
   isIPv4: boolean
@@ -56,8 +52,9 @@ interface UDPMuxServer {
 let UDP_MUX_LISTENERS: UDPMuxServer[] = []
 
 export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> implements Listener {
-  private readonly multiaddrs: Multiaddr[]
+  private listeningMultiaddr?: Multiaddr
   private certificate?: TransportCertificate
+  private stunServer?: StunServer
   private readonly connections: Map<string, DirectRTCPeerConnection>
   private readonly log: Logger
   private readonly init: WebRTCDirectListenerInit
@@ -70,7 +67,6 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
 
     this.init = init
     this.components = components
-    this.multiaddrs = []
     this.connections = new Map()
     this.log = components.logger.forComponent('libp2p:webrtc-direct:listener')
     this.certificate = init.certificates?.[0]
@@ -87,24 +83,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
   }
 
   async listen (ma: Multiaddr): Promise<void> {
-    const parts = ma.stringTuples()
-    const ipVersion = IP4.matches(ma) ? 4 : 6
-    const host = parts
-      .filter(([code]) => code === IP4_PROTOCOL.code)
-      .pop()?.[1] ?? parts
-      .filter(([code]) => code === IP6_PROTOCOL.code)
-      .pop()?.[1]
-
-    if (host == null) {
-      throw new Error('IP4/6 host must be specified in webrtc-direct multiaddr')
-    }
-    const port = parseInt(parts
-      .filter(([code, value]) => code === UDP_PROTOCOL.code)
-      .pop()?.[1] ?? '')
-
-    if (isNaN(port)) {
-      throw new Error('UDP port must be specified in webrtc-direct multiaddr')
-    }
+    const { host, port } = ma.toOptions()
 
     // have to do this before any async work happens so starting two listeners
     // for the same port concurrently (e.g. ipv4/ipv6 both port 0) results in a
@@ -133,17 +112,14 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       throw new InvalidPeerIdError(`Another peer is already performing UDP mux on ${host}:${existingServer.port}`)
     }
 
-    const server = await existingServer.server
-    const address = server.address()
+    this.stunServer = await existingServer.server
+    const address = this.stunServer.address()
 
     if (!createdMuxServer) {
       this.log('reused existing UDP mux server on %s:%p', host, address.port)
     }
 
-    getNetworkAddresses(host, address.port, ipVersion).forEach((ma) => {
-      this.multiaddrs.push(multiaddr(`${ma}/webrtc-direct/certhash/${this.certificate?.certhash}`))
-    })
-
+    this.listeningMultiaddr = ma
     this.safeDispatchEvent('listening')
   }
 
@@ -247,7 +223,15 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
   }
 
   getAddrs (): Multiaddr[] {
-    return this.multiaddrs
+    if (this.stunServer == null) {
+      return []
+    }
+
+    const address = this.stunServer.address()
+
+    return getThinWaistAddresses(this.listeningMultiaddr, address.port).map(ma => {
+      return ma.encapsulate(`/webrtc-direct/certhash/${this.certificate?.certhash}`)
+    })
   }
 
   updateAnnounceAddrs (multiaddrs: Multiaddr[]): void {
@@ -309,32 +293,3 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     this.safeDispatchEvent('close')
   }
 }
-
-function getNetworkAddresses (host: string, port: number, version: 4 | 6): string[] {
-  if (host === '0.0.0.0' || host === '::') {
-    // return all ip4 interfaces
-    return Object.entries(networkInterfaces())
-      .flatMap(([_, addresses]) => addresses)
-      .map(address => address?.address)
-      .filter(address => {
-        if (address == null) {
-          return false
-        }
-
-        if (version === 4) {
-          return isIPv4(address)
-        }
-
-        if (version === 6) {
-          return isIPv6(address)
-        }
-
-        return false
-      })
-      .map(address => `/ip${version}/${address}/udp/${port}`)
-  }
-
-  return [
-    `/ip${version}/${host}/udp/${port}`
-  ]
-}