fix: add multiaddr resolvers (#3200)

Use internal multiaddr resolvers so they can be removed from the
Multiaddr class to make it more lightweight.

Author: achingbrain

packages/interface/package.json

@@ -41,6 +41,7 @@
     "build": "aegir build"
   },
   "dependencies": {
+    "@multiformats/dns": "^1.0.6",
     "@multiformats/multiaddr": "^12.4.4",
     "it-pushable": "^3.2.3",
     "it-stream-types": "^2.0.2",

packages/interface/src/index.ts

@@ -26,6 +26,7 @@ import type { Startable } from './startable.js'
 import type { StreamHandler, StreamHandlerOptions } from './stream-handler.js'
 import type { Topology } from './topology.js'
 import type { Listener, OutboundConnectionUpgradeEvents } from './transport.js'
+import type { DNS } from '@multiformats/dns'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 import type { ProgressOptions, ProgressEvent } from 'progress-events'
@@ -173,6 +174,29 @@ export interface ComponentLogger {
   forComponent(name: string): Logger
 }
 
+export interface MultiaddrResolveOptions extends AbortOptions, LoggerOptions {
+  /**
+   * An optional DNS resolver
+   */
+  dns?: DNS
+}
+
+/**
+ * `MultiaddrResolver`s perform resolution of multiaddr components that require
+ * translation by external systems (for example DNSADDR to TXT records).
+ */
+export interface MultiaddrResolver {
+  /**
+   * Returns true if this resolver can resolve components of this multiaddr
+   */
+  canResolve (address: Multiaddr): boolean
+
+  /**
+   * Returns one or more multiaddrs with components resolved to other values
+   */
+  resolve (address: Multiaddr, options: MultiaddrResolveOptions): Promise<Multiaddr[]>
+}
+
 /**
  * Once you have a libp2p instance, you can listen to several events it emits,
  * so that you can be notified of relevant network events.

packages/libp2p/src/config.ts

@@ -1,6 +1,6 @@
 import { FaultTolerance, InvalidParametersError } from '@libp2p/interface'
 import { mergeOptions } from '@libp2p/utils/merge-options'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+import { dnsaddrResolver } from './connection-manager/resolvers/dnsaddr.ts'
 import type { Libp2pInit } from './index.js'
 import type { ServiceMap } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'

packages/libp2p/src/connection-manager/constants.defaults.ts

@@ -54,3 +54,8 @@ export const LAST_DIAL_SUCCESS_KEY = 'last-dial-success'
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxDialQueueLength
  */
 export const MAX_DIAL_QUEUE_LENGTH = 500
+
+/**
+ * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxRecursiveDepth
+ */
+export const MAX_RECURSIVE_DEPTH = 32

packages/libp2p/src/connection-manager/dial-queue.ts

@@ -2,8 +2,7 @@
 import { TimeoutError, DialError, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { PriorityQueue } from '@libp2p/utils/priority-queue'
-import { resolvers, multiaddr } from '@multiformats/multiaddr'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+import { multiaddr } from '@multiformats/multiaddr'
 import { Circuit } from '@multiformats/multiaddr-matcher'
 import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
@@ -20,13 +19,13 @@ import {
   MAX_DIAL_QUEUE_LENGTH,
   LAST_DIAL_SUCCESS_KEY
 } from './constants.js'
-import { resolveMultiaddrs } from './utils.js'
+import { resolveMultiaddr, dnsaddrResolver } from './resolvers/index.js'
 import { DEFAULT_DIAL_PRIORITY } from './index.js'
-import type { AddressSorter, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions, OpenConnectionProgressEvents } from '@libp2p/interface'
+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 { DNS } from '@multiformats/dns'
-import type { Multiaddr, Resolver } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
 
 export interface PendingDialTarget {
@@ -45,7 +44,7 @@ interface DialerInit {
   maxDialQueueLength?: number
   maxPeerAddrsToDial?: number
   dialTimeout?: number
-  resolvers?: Record<string, Resolver>
+  resolvers?: Record<string, MultiaddrResolver>
   connections?: PeerMap<Connection[]>
 }
 
@@ -80,6 +79,7 @@ export class DialQueue {
   private shutDownController: AbortController
   private readonly connections: PeerMap<Connection[]>
   private readonly log: Logger
+  private readonly resolvers: Record<string, MultiaddrResolver>
 
   constructor (components: DialQueueComponents, init: DialerInit = {}) {
     this.addressSorter = init.addressSorter
@@ -89,14 +89,11 @@ export class DialQueue {
     this.connections = init.connections ?? new PeerMap()
     this.log = components.logger.forComponent('libp2p:connection-manager:dial-queue')
     this.components = components
+    this.resolvers = init.resolvers ?? defaultOptions.resolvers
 
     this.shutDownController = new AbortController()
     setMaxListeners(Infinity, this.shutDownController.signal)
 
-    for (const [key, value] of Object.entries(init.resolvers ?? {})) {
-      resolvers.set(key, value)
-    }
-
     // controls dial concurrency
     this.queue = new PriorityQueue({
       concurrency: init.maxParallelDials ?? defaultOptions.maxParallelDials,
@@ -415,10 +412,10 @@ export class DialQueue {
     // dnsaddrs are resolved
     let resolvedAddresses = (await Promise.all(
       addrs.map(async addr => {
-        const result = await resolveMultiaddrs(addr.multiaddr, {
+        const result = await resolveMultiaddr(addr.multiaddr, this.resolvers, {
           dns: this.components.dns,
-          ...options,
-          log: this.log
+          log: this.log,
+          ...options
         })
 
         if (result.length === 1 && result[0].equals(addr.multiaddr)) {

packages/libp2p/src/connection-manager/index.ts

@@ -2,19 +2,19 @@ import { ConnectionClosedError, InvalidMultiaddrError, InvalidParametersError, I
 import { PeerMap } from '@libp2p/peer-collections'
 import { RateLimiter } from '@libp2p/utils/rate-limiter'
 import { multiaddr } from '@multiformats/multiaddr'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { CustomProgressEvent } from 'progress-events'
 import { getPeerAddress } from '../get-peer.js'
 import { ConnectionPruner } from './connection-pruner.js'
 import { DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL } from './constants.js'
 import { DialQueue } from './dial-queue.js'
 import { ReconnectQueue } from './reconnect-queue.js'
+import { dnsaddrResolver } from './resolvers/index.ts'
 import { multiaddrToIpNet } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { JobStatus } from '@libp2p/utils/queue'
-import type { Multiaddr, Resolver } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
 export const DEFAULT_DIAL_PRIORITY = 50
@@ -112,7 +112,7 @@ export interface ConnectionManagerInit {
   /**
    * Multiaddr resolvers to use when dialling
    */
-  resolvers?: Record<string, Resolver>
+  resolvers?: Record<string, MultiaddrResolver>
 
   /**
    * A list of multiaddrs that will always be allowed (except if they are in the

packages/libp2p/src/connection-manager/resolvers/dnsaddr.ts

@@ -0,0 +1,69 @@
+import { dns, RecordType } from '@multiformats/dns'
+import { multiaddr } from '@multiformats/multiaddr'
+import type { MultiaddrResolver, MultiaddrResolveOptions } from '@libp2p/interface'
+import type { DNS } from '@multiformats/dns'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+class DNSAddrResolver implements MultiaddrResolver {
+  private dns?: DNS
+
+  canResolve (ma: Multiaddr): boolean {
+    return ma.getComponents().some(({ name }) => name === 'dnsaddr')
+  }
+
+  async resolve (ma: Multiaddr, options: MultiaddrResolveOptions): Promise<Multiaddr[]> {
+    const hostname = ma.getComponents()
+      .find(component => component.name === 'dnsaddr')
+      ?.value
+
+    if (hostname == null) {
+      return [ma]
+    }
+
+    const resolver = this.getDNS(options)
+    const result = await resolver.query(`_dnsaddr.${hostname}`, {
+      signal: options?.signal,
+      types: [
+        RecordType.TXT
+      ]
+    })
+
+    const peerId = ma.getComponents()
+      .find(component => component.name === 'p2p')
+      ?.value
+    const output: Multiaddr[] = []
+
+    for (const answer of result.Answer) {
+      const addr = answer.data
+        .replace(/["']/g, '')
+        .trim()
+        .split('=')[1]
+
+      if (addr == null) {
+        continue
+      }
+
+      if (peerId != null && !addr.includes(peerId)) {
+        continue
+      }
+
+      output.push(multiaddr(addr))
+    }
+
+    return output
+  }
+
+  private getDNS (options: MultiaddrResolveOptions): DNS {
+    if (options.dns != null) {
+      return options.dns
+    }
+
+    if (this.dns == null) {
+      this.dns = dns()
+    }
+
+    return this.dns
+  }
+}
+
+export const dnsaddrResolver = new DNSAddrResolver()

packages/libp2p/src/connection-manager/resolvers/index.ts

@@ -0,0 +1,59 @@
+import { RecursionLimitError } from '../../errors.ts'
+import { MAX_RECURSIVE_DEPTH } from '../constants.defaults.ts'
+import type { MultiaddrResolveOptions, MultiaddrResolver } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface ResolveOptions extends MultiaddrResolveOptions {
+  /**
+   * When resolving DNSADDR Multiaddrs that resolve to other DNSADDR Multiaddrs,
+   * limit how many times we will recursively resolve them.
+   *
+   * @default 32
+   */
+  maxRecursiveDepth?: number
+
+  /**
+   * The current recursive depth
+   *
+   * @default 0
+   */
+  depth?: number
+}
+
+/**
+ * Recursively resolve multiaddrs
+ */
+export async function resolveMultiaddr (address: Multiaddr, resolvers: Record<string, MultiaddrResolver>, options: ResolveOptions): Promise<Multiaddr[]> {
+  const depth = options.depth ?? 0
+
+  if (depth > (options.maxRecursiveDepth ?? MAX_RECURSIVE_DEPTH)) {
+    throw new RecursionLimitError('Max recursive depth reached')
+  }
+
+  let resolved = false
+  const output: Multiaddr[] = []
+
+  for (const resolver of Object.values(resolvers)) {
+    if (resolver.canResolve(address)) {
+      resolved = true
+      const addresses = await resolver.resolve(address, options)
+
+      for (const address of addresses) {
+        output.push(
+          ...(await resolveMultiaddr(address, resolvers, {
+            ...options,
+            depth: depth + 1
+          }))
+        )
+      }
+    }
+  }
+
+  if (resolved === false) {
+    output.push(address)
+  }
+
+  return output
+}
+
+export { dnsaddrResolver } from './dnsaddr.js'

packages/libp2p/src/connection-manager/utils.ts

@@ -1,35 +1,7 @@
-import { multiaddr, resolvers } from '@multiformats/multiaddr'
+import { multiaddr } from '@multiformats/multiaddr'
 import { convertToIpNet } from '@multiformats/multiaddr/convert'
 import type { IpNet } from '@chainsafe/netmask'
-import type { LoggerOptions } from '@libp2p/interface'
-import type { Multiaddr, ResolveOptions } from '@multiformats/multiaddr'
-
-/**
- * Recursively resolve DNSADDR multiaddrs
- */
-export async function resolveMultiaddrs (ma: Multiaddr, options: ResolveOptions & LoggerOptions): Promise<Multiaddr[]> {
-  // check multiaddr resolvers
-  let resolvable = false
-
-  for (const key of resolvers.keys()) {
-    resolvable = ma.protoNames().includes(key)
-
-    if (resolvable) {
-      break
-    }
-  }
-
-  // return multiaddr if it is not resolvable
-  if (!resolvable) {
-    return [ma]
-  }
-
-  const output = await ma.resolve(options)
-
-  options.log('resolved %s to', ma, output.map(ma => ma.toString()))
-
-  return output
-}
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
  * Converts a multiaddr string or object to an IpNet object.
@@ -50,9 +22,11 @@ export function multiaddrToIpNet (ma: string | Multiaddr): IpNet {
       parsedMa = ma
     }
 
+    const protoNames = new Set([...parsedMa.getComponents().map(component => component.name)])
+
     // Check if /ipcidr is already present
-    if (!parsedMa.protoNames().includes('ipcidr')) {
-      const isIPv6 = parsedMa.protoNames().includes('ip6')
+    if (!protoNames.has('ipcidr')) {
+      const isIPv6 = protoNames.has('ip6')
       const cidr = isIPv6 ? '/ipcidr/128' : '/ipcidr/32'
       parsedMa = parsedMa.encapsulate(cidr)
     }

packages/libp2p/src/errors.ts

@@ -114,3 +114,10 @@ export class TransportUnavailableError extends Error {
     this.name = 'TransportUnavailableError'
   }
 }
+
+export class RecursionLimitError extends Error {
+  constructor (message = 'Max recursive depth reached') {
+    super(message)
+    this.name = 'RecursionLimitError'
+  }
+}