libp2p 0.36.2-fab4f13 → 0.37.0-d5386df

package/src/circuit/auto-relay.ts

@@ -85,12 +85,14 @@ export class AutoRelay {
 
     // If protocol, check if can hop, store info in the metadataBook and listen on it
     try {
-      const connection = this.components.getConnectionManager().getConnection(peerId)
+      const connections = this.components.getConnectionManager().getConnections(peerId)
 
-      if (connection == null) {
+      if (connections.length === 0) {
         return
       }
 
+      const connection = connections[0]
+
       // Do not hop on a relayed connection
       if (connection.remoteAddr.protoCodes().includes(CIRCUIT_PROTO_CODE)) {
         log(`relayed connection to ${id} will not be used to hop on`)
@@ -223,15 +225,15 @@ export class AutoRelay {
         continue
       }
 
-      const connection = this.components.getConnectionManager().getConnection(id)
+      const connections = this.components.getConnectionManager().getConnections(id)
 
       // If not connected, store for possible later use.
-      if (connection == null) {
+      if (connections.length === 0) {
         knownHopsToDial.push(id)
         continue
       }
 
-      await this._addListenRelay(connection, idStr)
+      await this._addListenRelay(connections[0], idStr)
 
       // Check if already listening on enough relays
       if (this.listenRelays.size >= this.maxListeners) {
@@ -274,7 +276,7 @@ export class AutoRelay {
 
   async _tryToListenOnRelay (peerId: PeerId) {
     try {
-      const connection = await this.components.getDialer().dial(peerId)
+      const connection = await this.components.getConnectionManager().openConnection(peerId)
       await this._addListenRelay(connection, peerId.toString())
     } catch (err: any) {
       log.error('Could not use %p as relay', peerId, err)

package/src/circuit/circuit/hop.ts

@@ -11,7 +11,7 @@ import type { Connection } from '@libp2p/interfaces/connection'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import type { Duplex } from 'it-stream-types'
 import type { Circuit } from '../transport.js'
-import type { ConnectionManager } from '@libp2p/interfaces/registrar'
+import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
 
 const log = logger('libp2p:circuit:hop')
 
@@ -58,8 +58,8 @@ export async function handleHop (hopRequest: HopRequest) {
   // Get the connection to the destination (stop) peer
   const destinationPeer = peerIdFromBytes(request.dstPeer.id)
 
-  const destinationConnection = connectionManager.getConnection(destinationPeer)
-  if (destinationConnection == null && !circuit.hopActive()) {
+  const destinationConnections = connectionManager.getConnections(destinationPeer)
+  if (destinationConnections.length === 0 && !circuit.hopActive()) {
     log('HOP request received but we are not connected to the destination peer')
     return streamHandler.end({
       type: CircuitPB.Type.STATUS,
@@ -68,7 +68,7 @@ export async function handleHop (hopRequest: HopRequest) {
   }
 
   // TODO: Handle being an active relay
-  if (destinationConnection == null) {
+  if (destinationConnections.length === 0) {
     log('did not have connection to remote peer')
     return streamHandler.end({
       type: CircuitPB.Type.STATUS,
@@ -87,7 +87,7 @@ export async function handleHop (hopRequest: HopRequest) {
   try {
     log('performing STOP request')
     const result = await stop({
-      connection: destinationConnection,
+      connection: destinationConnections[0],
       request: stopRequest
     })
 

package/src/circuit/index.ts

@@ -11,7 +11,7 @@ import {
   RELAY_RENDEZVOUS_NS
 } from './constants.js'
 import type { AddressSorter } from '@libp2p/interfaces/peer-store'
-import type { Startable } from '@libp2p/interfaces'
+import type { Startable } from '@libp2p/interfaces/startable'
 import type { Components } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:relay')

package/src/circuit/listener.ts

@@ -1,11 +1,12 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces'
-import type { ConnectionManager } from '@libp2p/interfaces/registrar'
-import type { Dialer } from '@libp2p/interfaces/dialer'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+import type { PeerStore } from '@libp2p/interfaces/peer-store'
 import type { Listener } from '@libp2p/interfaces/transport'
+import { peerIdFromString } from '@libp2p/peer-id'
 import { Multiaddr } from '@multiformats/multiaddr'
 
 export interface ListenerOptions {
-  dialer: Dialer
+  peerStore: PeerStore
   connectionManager: ConnectionManager
 }
 
@@ -17,7 +18,19 @@ export function createListener (options: ListenerOptions): Listener {
    */
   async function listen (addr: Multiaddr): Promise<void> {
     const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
-    const relayConn = await options.dialer.dial(new Multiaddr(addrString))
+    const ma = new Multiaddr(addrString)
+
+    const relayPeerStr = ma.getPeerId()
+
+    if (relayPeerStr == null) {
+      throw new Error('Could not determine relay peer from multiaddr')
+    }
+
+    const relayPeerId = peerIdFromString(relayPeerStr)
+
+    await options.peerStore.addressBook.add(relayPeerId, [ma])
+
+    const relayConn = await options.connectionManager.openConnection(relayPeerId)
     const relayedAddr = relayConn.remoteAddr.encapsulate('/p2p-circuit')
 
     listeningAddrs.set(relayConn.remotePeer.toString(), relayedAddr)

package/src/circuit/pb/index.ts

@@ -2,6 +2,7 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 
 import { enumeration, encodeMessage, decodeMessage, message, bytes } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
 
 export interface CircuitRelay {
   type?: CircuitRelay.Type
@@ -30,11 +31,31 @@ export namespace CircuitRelay {
     MALFORMED_MESSAGE = 'MALFORMED_MESSAGE'
   }
 
+  enum __StatusValues {
+    SUCCESS = 100,
+    HOP_SRC_ADDR_TOO_LONG = 220,
+    HOP_DST_ADDR_TOO_LONG = 221,
+    HOP_SRC_MULTIADDR_INVALID = 250,
+    HOP_DST_MULTIADDR_INVALID = 251,
+    HOP_NO_CONN_TO_DST = 260,
+    HOP_CANT_DIAL_DST = 261,
+    HOP_CANT_OPEN_DST_STREAM = 262,
+    HOP_CANT_SPEAK_RELAY = 270,
+    HOP_CANT_RELAY_TO_SELF = 280,
+    STOP_SRC_ADDR_TOO_LONG = 320,
+    STOP_DST_ADDR_TOO_LONG = 321,
+    STOP_SRC_MULTIADDR_INVALID = 350,
+    STOP_DST_MULTIADDR_INVALID = 351,
+    STOP_RELAY_REFUSED = 390,
+    MALFORMED_MESSAGE = 400
+  }
+
   export namespace Status {
     export const codec = () => {
-      return enumeration<typeof Status>(Status)
+      return enumeration<typeof Status>(__StatusValues)
     }
   }
+
   export enum Type {
     HOP = 'HOP',
     STOP = 'STOP',
@@ -42,18 +63,26 @@ export namespace CircuitRelay {
     CAN_HOP = 'CAN_HOP'
   }
 
+  enum __TypeValues {
+    HOP = 1,
+    STOP = 2,
+    STATUS = 3,
+    CAN_HOP = 4
+  }
+
   export namespace Type {
     export const codec = () => {
-      return enumeration<typeof Type>(Type)
+      return enumeration<typeof Type>(__TypeValues)
     }
   }
+
   export interface Peer {
     id: Uint8Array
     addrs: Uint8Array[]
   }
 
   export namespace Peer {
-    export const codec = () => {
+    export const codec = (): Codec<Peer> => {
       return message<Peer>({
         1: { name: 'id', codec: bytes },
         2: { name: 'addrs', codec: bytes, repeats: true }
@@ -69,7 +98,7 @@ export namespace CircuitRelay {
     }
   }
 
-  export const codec = () => {
+  export const codec = (): Codec<CircuitRelay> => {
     return message<CircuitRelay>({
       1: { name: 'type', codec: CircuitRelay.Type.codec(), optional: true },
       2: { name: 'srcPeer', codec: CircuitRelay.Peer.codec(), optional: true },

package/src/circuit/transport.ts

@@ -49,7 +49,7 @@ export class Circuit implements Transport, Initializable {
   }
 
   get [Symbol.toStringTag] () {
-    return this.constructor.name
+    return 'libp2p/circuit-relay-v1'
   }
 
   async _onProtocol (data: IncomingStreamData) {
@@ -149,9 +149,12 @@ export class Circuit implements Transport, Initializable {
     const destinationPeer = peerIdFromString(destinationId)
 
     let disconnectOnFailure = false
-    let relayConnection = this.components.getConnectionManager().getConnection(relayPeer)
+    const relayConnections = this.components.getConnectionManager().getConnections(relayPeer)
+    let relayConnection = relayConnections[0]
+
     if (relayConnection == null) {
-      relayConnection = await this.components.getDialer().dial(relayAddr, options)
+      await this.components.getPeerStore().addressBook.add(relayPeer, [relayAddr])
+      relayConnection = await this.components.getConnectionManager().openConnection(relayPeer, options)
       disconnectOnFailure = true
     }
 
@@ -195,8 +198,8 @@ export class Circuit implements Transport, Initializable {
     this.handler = options.handler
 
     return createListener({
-      dialer: this.components.getDialer(),
-      connectionManager: this.components.getConnectionManager()
+      connectionManager: this.components.getConnectionManager(),
+      peerStore: this.components.getPeerStore()
     })
   }
 

package/src/config.ts

@@ -21,14 +21,8 @@ const DefaultConfig: Partial<Libp2pInit> = {
   connectionManager: {
     maxConnections: 300,
     minConnections: 50,
+    autoDial: true,
     autoDialInterval: 10000,
-    autoDial: true
-  },
-  connectionGater: {},
-  transportManager: {
-    faultTolerance: FaultTolerance.FATAL_ALL
-  },
-  dialer: {
     maxParallelDials: Constants.MAX_PARALLEL_DIALS,
     maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
     dialTimeout: Constants.DIAL_TIMEOUT,
@@ -37,6 +31,10 @@ const DefaultConfig: Partial<Libp2pInit> = {
     },
     addressSorter: publicAddressesFirst
   },
+  connectionGater: {},
+  transportManager: {
+    faultTolerance: FaultTolerance.FATAL_ALL
+  },
   host: {
     agentVersion: AGENT_VERSION
   },

package/src/connection-manager/auto-dialler.ts

@@ -6,7 +6,7 @@ import all from 'it-all'
 import { pipe } from 'it-pipe'
 import filter from 'it-filter'
 import sort from 'it-sort'
-import type { Startable } from '@libp2p/interfaces'
+import type { Startable } from '@libp2p/interfaces/startable'
 import type { Components } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:connection-manager:auto-dialler')
@@ -102,7 +102,7 @@ export class AutoDialler implements Startable {
     const minConnections = this.options.minConnections
 
     // Already has enough connections
-    if (this.components.getConnectionManager().getConnectionList().length >= minConnections) {
+    if (this.components.getConnectionManager().getConnections().length >= minConnections) {
       this.autoDialTimeout = retimer(this._autoDial, this.options.autoDialInterval)
 
       return
@@ -126,7 +126,7 @@ export class AutoDialler implements Startable {
       async (source) => await all(source)
     )
 
-    for (let i = 0; this.running && i < peers.length && this.components.getConnectionManager().getConnectionList().length < minConnections; i++) {
+    for (let i = 0; this.running && i < peers.length && this.components.getConnectionManager().getConnections().length < minConnections; i++) {
       // Connection Manager was stopped during async dial
       if (!this.running) {
         return
@@ -134,10 +134,10 @@ export class AutoDialler implements Startable {
 
       const peer = peers[i]
 
-      if (this.components.getConnectionManager().getConnection(peer.id) == null) {
+      if (this.components.getConnectionManager().getConnections(peer.id).length === 0) {
         log('connecting to a peerStore stored peer %p', peer.id)
         try {
-          await this.components.getDialer().dial(peer.id)
+          await this.components.getConnectionManager().openConnection(peer.id)
         } catch (err: any) {
           log.error('could not connect to peerStore stored peer', err)
         }

package/src/{dialer → connection-manager/dialer}/auto-dialer.ts

@@ -1,39 +1,58 @@
 import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 import { logger } from '@libp2p/logger'
 import type { Components } from '@libp2p/interfaces/components'
+import { TimeoutController } from 'timeout-abort-controller'
 
 const log = logger('libp2p:dialer:auto-dialer')
 
 export interface AutoDialerInit {
   enabled: boolean
   minConnections: number
+  dialTimeout: number
 }
 
 export class AutoDialer {
   private readonly components: Components
   private readonly enabled: boolean
   private readonly minConnections: number
+  private readonly dialTimeout: number
 
   constructor (components: Components, init: AutoDialerInit) {
     this.components = components
     this.enabled = init.enabled
     this.minConnections = init.minConnections
+    this.dialTimeout = init.dialTimeout
   }
 
   public handle (evt: CustomEvent<PeerInfo>) {
     const { detail: peer } = evt
 
+    if (!this.enabled) {
+      return
+    }
+
+    const connections = this.components.getConnectionManager().getConnections(peer.id)
+
     // If auto dialing is on and we have no connection to the peer, check if we should dial
-    if (this.enabled && this.components.getConnectionManager().getConnection(peer.id) == null) {
+    if (connections.length === 0) {
       const minConnections = this.minConnections ?? 0
 
-      if (minConnections > this.components.getConnectionManager().getConnectionList().length) {
-        log('auto-dialing discovered peer %p', peer.id)
+      const allConnections = this.components.getConnectionManager().getConnections()
 
-        void this.components.getDialer().dial(peer.id)
+      if (minConnections > allConnections.length) {
+        log('auto-dialing discovered peer %p with timeout %d', peer.id, this.dialTimeout)
+
+        const controller = new TimeoutController(this.dialTimeout)
+
+        void this.components.getConnectionManager().openConnection(peer.id, {
+          signal: controller.signal
+        })
           .catch(err => {
             log.error('could not connect to discovered peer %p with %o', peer.id, err)
           })
+          .finally(() => {
+            controller.clear()
+          })
       }
     }
   }

package/src/{dialer → connection-manager/dialer}/dial-request.ts

@@ -3,12 +3,12 @@ import { anySignal } from 'any-signal'
 import FIFO from 'p-fifo'
 // @ts-expect-error setMaxListeners is missing from the node 16 types
 import { setMaxListeners } from 'events'
-import { codes } from '../errors.js'
+import { codes } from '../../errors.js'
 import { logger } from '@libp2p/logger'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Connection } from '@libp2p/interfaces/connection'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { DefaultDialer } from './index.js'
+import type { Dialer } from './index.js'
 
 const log = logger('libp2p:dialer:dial-request')
 
@@ -19,12 +19,12 @@ export interface DialAction {
 export interface DialRequestOptions {
   addrs: Multiaddr[]
   dialAction: DialAction
-  dialer: DefaultDialer
+  dialer: Dialer
 }
 
 export class DialRequest {
   private readonly addrs: Multiaddr[]
-  private readonly dialer: DefaultDialer
+  private readonly dialer: Dialer
   private readonly dialAction: DialAction
 
   /**

package/src/{dialer → connection-manager/dialer}/index.ts

@@ -3,7 +3,7 @@ import all from 'it-all'
 import filter from 'it-filter'
 import { pipe } from 'it-pipe'
 import errCode from 'err-code'
-import { Multiaddr } from '@multiformats/multiaddr'
+import { Multiaddr, Resolver } from '@multiformats/multiaddr'
 import { TimeoutController } from 'timeout-abort-controller'
 import { AbortError } from '@libp2p/interfaces/errors'
 import { anySignal } from 'any-signal'
@@ -12,22 +12,23 @@ import { setMaxListeners } from 'events'
 import { DialAction, DialRequest } from './dial-request.js'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { trackedMap } from '@libp2p/tracked-map'
-import { codes } from '../errors.js'
+import { codes } from '../../errors.js'
 import {
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS,
   MAX_PER_PEER_DIALS,
   MAX_ADDRS_TO_DIAL
-} from '../constants.js'
+} from '../../constants.js'
 import type { Connection } from '@libp2p/interfaces/connection'
-import type { AbortOptions, Startable } from '@libp2p/interfaces'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { Startable } from '@libp2p/interfaces/startable'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
-import { getPeer } from '../get-peer.js'
+import { getPeer } from '../../get-peer.js'
 import sort from 'it-sort'
-import type { Components } from '@libp2p/interfaces/components'
-import type { Dialer, DialerInit } from '@libp2p/interfaces/dialer'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 import map from 'it-map'
 import type { AddressSorter } from '@libp2p/interfaces/peer-store'
+import type { ComponentMetricsTracker } from '@libp2p/interfaces/metrics'
 
 const log = logger('libp2p:dialer')
 
@@ -52,8 +53,41 @@ export interface PendingDialTarget {
   reject: (err: Error) => void
 }
 
-export class DefaultDialer implements Dialer, Startable {
-  private readonly components: Components
+export interface DialerInit {
+  /**
+   * Sort the known addresses of a peer before trying to dial
+   */
+  addressSorter?: AddressSorter
+
+  /**
+   * Number of max concurrent dials
+   */
+  maxParallelDials?: number
+
+  /**
+   * Number of max addresses to dial for a given peer
+   */
+  maxAddrsToDial?: number
+
+  /**
+   * How long a dial attempt is allowed to take
+   */
+  dialTimeout?: number
+
+  /**
+   * Number of max concurrent dials per peer
+   */
+  maxDialsPerPeer?: number
+
+  /**
+   * Multiaddr resolvers to use when dialing
+   */
+  resolvers?: Record<string, Resolver>
+  metrics?: ComponentMetricsTracker
+}
+
+export class Dialer implements Startable, Initializable {
+  private components: Components = new Components()
   private readonly addressSorter: AddressSorter
   private readonly maxAddrsToDial: number
   private readonly timeout: number
@@ -63,8 +97,7 @@ export class DefaultDialer implements Dialer, Startable {
   public pendingDialTargets: Map<string, PendingDialTarget>
   private started: boolean
 
-  constructor (components: Components, init: DialerInit = {}) {
-    this.components = components
+  constructor (init: DialerInit = {}) {
     this.started = false
     this.addressSorter = init.addressSorter ?? publicAddressesFirst
     this.maxAddrsToDial = init.maxAddrsToDial ?? MAX_ADDRS_TO_DIAL
@@ -87,6 +120,10 @@ export class DefaultDialer implements Dialer, Startable {
     }
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   isStarted () {
     return this.started
   }
@@ -139,16 +176,6 @@ export class DefaultDialer implements Dialer, Startable {
       throw errCode(new Error('The dial request is blocked by gater.allowDialPeer'), codes.ERR_PEER_DIAL_INTERCEPTED)
     }
 
-    log('dial to %p', id)
-
-    const existingConnection = this.components.getConnectionManager().getConnection(id)
-
-    if (existingConnection != null) {
-      log('had an existing connection to %p', id)
-
-      return existingConnection
-    }
-
     log('creating dial target for %p', id)
 
     const dialTarget = await this._createCancellableDialTarget(id)
@@ -176,22 +203,6 @@ export class DefaultDialer implements Dialer, Startable {
     }
   }
 
-  async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}) {
-    if (protocols == null) {
-      throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
-    }
-
-    protocols = Array.isArray(protocols) ? protocols : [protocols]
-
-    if (protocols.length === 0) {
-      throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
-    }
-
-    const connection = await this.dial(peer, options)
-
-    return await connection.newStream(protocols)
-  }
-
   /**
    * Connects to a given `peer` by dialing all of its known addresses.
    * The dial to the first address that is successfully able to upgrade a connection