libp2p 0.36.2-64bfcee → 0.36.2-a15254f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.36.2-64bfcee",
+  "version": "0.36.2-a15254f",
   "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#readme",
@@ -76,38 +76,38 @@
     ]
   },
   "scripts": {
+    "clean": "aegir clean",
     "lint": "aegir lint",
-    "build": "tsc",
-    "postbuild": "mkdirp dist/src/circuit/pb dist/src/fetch/pb dist/src/identify/pb dist/src/insecure/pb && cp src/circuit/pb/*.js src/circuit/pb/*.d.ts dist/src/circuit/pb && cp src/fetch/pb/*.js src/fetch/pb/*.d.ts dist/src/fetch/pb && cp src/identify/pb/*.js src/identify/pb/*.d.ts dist/src/identify/pb && cp src/insecure/pb/*.js src/insecure/pb/*.d.ts dist/src/insecure/pb",
-    "generate": "run-s generate:proto:* generate:proto-types:*",
-    "generate:proto:circuit": "pbjs -t static-module -w es6 -r libp2p-circuit --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/circuit/protocol/index.js ./src/circuit/protocol/index.proto",
-    "generate:proto:fetch": "pbjs -t static-module -w es6 -r libp2p-fetch --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/fetch/proto.js ./src/fetch/proto.proto",
-    "generate:proto:identify": "pbjs -t static-module -w es6 -r libp2p-identify --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/identify/message.js ./src/identify/message.proto",
-    "generate:proto:plaintext": "pbjs -t static-module -w es6 -r libp2p-plaintext --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/insecure/proto.js ./src/insecure/proto.proto",
-    "generate:proto-types:circuit": "pbts -o src/circuit/protocol/index.d.ts src/circuit/protocol/index.js",
-    "generate:proto-types:fetch": "pbts -o src/fetch/proto.d.ts src/fetch/proto.js",
-    "generate:proto-types:identify": "pbts -o src/identify/message.d.ts src/identify/message.js",
-    "generate:proto-types:plaintext": "pbts -o src/insecure/proto.d.ts src/insecure/proto.js",
-    "pretest": "npm run build",
+    "dep-check": "aegir dep-check",
+    "build": "aegir build",
+    "generate": "run-s generate:proto:*",
+    "generate:proto:circuit": "protons ./src/circuit/pb/index.proto",
+    "generate:proto:fetch": "protons ./src/fetch/pb/proto.proto",
+    "generate:proto:identify": "protons ./src/identify/pb/message.proto",
+    "generate:proto:plaintext": "protons ./src/insecure/pb/proto.proto",
     "test": "aegir test",
-    "test:node": "npm run test -- -t node -f \"./dist/test/**/*.{node,spec}.js\" --cov",
-    "test:chrome": "npm run test -- -t browser -f \"./dist/test/**/*.spec.js\" --cov",
-    "test:chrome-webworker": "npm run test -- -t webworker -f \"./dist/test/**/*.spec.js\"",
-    "test:firefox": "npm run test -- -t browser -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
-    "test:firefox-webworker": "npm run test -- -t webworker -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
+    "test:node": "aegir test -t node -f \"./dist/test/**/*.{node,spec}.js\" --cov",
+    "test:chrome": "aegir test -t browser -f \"./dist/test/**/*.spec.js\" --cov",
+    "test:chrome-webworker": "aegir test -t webworker -f \"./dist/test/**/*.spec.js\"",
+    "test:firefox": "aegir test -t browser -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
     "test:examples": "cd examples && npm run test:all",
-    "test:interop": "npm run test -- -t node -f dist/test/interop.js"
+    "test:interop": "aegir test -t node -f dist/test/interop.js"
   },
   "dependencies": {
     "@achingbrain/nat-port-mapper": "^1.0.0",
-    "@libp2p/connection": "^1.1.4",
-    "@libp2p/crypto": "^0.22.9",
-    "@libp2p/interfaces": "^1.3.17",
-    "@libp2p/multistream-select": "^1.0.3",
-    "@libp2p/peer-id": "^1.1.8",
-    "@libp2p/peer-id-factory": "^1.0.8",
-    "@libp2p/peer-store": "^1.0.6",
-    "@libp2p/utils": "^1.0.9",
+    "@libp2p/connection": "^1.1.5",
+    "@libp2p/crypto": "^0.22.11",
+    "@libp2p/interfaces": "^1.3.30",
+    "@libp2p/logger": "^1.1.4",
+    "@libp2p/multistream-select": "^1.0.4",
+    "@libp2p/peer-collections": "^1.0.2",
+    "@libp2p/peer-id": "^1.1.10",
+    "@libp2p/peer-id-factory": "^1.0.9",
+    "@libp2p/peer-record": "^1.0.8",
+    "@libp2p/peer-store": "^1.0.10",
+    "@libp2p/tracked-map": "^1.0.5",
+    "@libp2p/utils": "^1.0.10",
     "@multiformats/mafmt": "^11.0.2",
     "@multiformats/multiaddr": "^10.1.8",
     "abortable-iterator": "^4.0.2",
@@ -130,6 +130,7 @@
     "it-length-prefixed": "^7.0.1",
     "it-map": "^1.0.6",
     "it-merge": "^1.0.3",
+    "it-pair": "^2.0.2",
     "it-pipe": "^2.0.3",
     "it-sort": "^1.0.1",
     "it-stream-types": "^1.0.4",
@@ -144,7 +145,7 @@
     "p-retry": "^5.0.0",
     "p-settle": "^5.0.0",
     "private-ip": "^2.3.3",
-    "protobufjs": "^6.11.2",
+    "protons-runtime": "^1.0.2",
     "retimer": "^3.0.0",
     "sanitize-filename": "^1.6.3",
     "set-delayed-interval": "^1.0.0",
@@ -156,37 +157,37 @@
     "xsalsa20": "^1.1.0"
   },
   "devDependencies": {
-    "@achingbrain/libp2p-gossipsub": "^0.13.5",
     "@chainsafe/libp2p-noise": "^6.0.1",
-    "@libp2p/bootstrap": "^1.0.2",
-    "@libp2p/daemon-client": "^1.0.0",
-    "@libp2p/daemon-server": "^1.0.0",
+    "@libp2p/bootstrap": "^1.0.3",
+    "@libp2p/daemon-client": "^1.0.2",
+    "@libp2p/daemon-server": "^1.0.2",
     "@libp2p/delegated-content-routing": "^1.0.2",
     "@libp2p/delegated-peer-routing": "^1.0.2",
-    "@libp2p/floodsub": "^1.0.2",
-    "@libp2p/interface-compliance-tests": "^1.1.20",
-    "@libp2p/interop": "^1.0.0",
-    "@libp2p/kad-dht": "^1.0.3",
-    "@libp2p/mdns": "^1.0.3",
-    "@libp2p/mplex": "^1.0.1",
-    "@libp2p/tcp": "^1.0.6",
-    "@libp2p/tracked-map": "^1.0.4",
-    "@libp2p/webrtc-star": "^1.0.3",
-    "@libp2p/websockets": "^1.0.3",
+    "@libp2p/floodsub": "^1.0.6",
+    "@libp2p/interface-compliance-tests": "^1.1.31",
+    "@libp2p/interop": "^1.0.3",
+    "@libp2p/kad-dht": "^1.0.8",
+    "@libp2p/mdns": "^1.0.4",
+    "@libp2p/mplex": "^1.0.3",
+    "@libp2p/pubsub": "^1.2.18",
+    "@libp2p/tcp": "^1.0.8",
+    "@libp2p/topology": "^1.1.7",
+    "@libp2p/webrtc-star": "^1.0.7",
+    "@libp2p/websockets": "^1.0.6",
     "@nodeutils/defaults-deep": "^1.1.0",
     "@types/node": "^16.11.26",
     "@types/node-forge": "^1.0.0",
     "@types/p-fifo": "^1.0.0",
     "@types/varint": "^6.0.0",
     "@types/xsalsa20": "^1.1.0",
-    "aegir": "^36.1.3",
+    "aegir": "^37.0.9",
     "buffer": "^6.0.3",
     "cborg": "^1.8.1",
     "delay": "^5.0.0",
+    "execa": "^6.1.0",
     "go-libp2p": "^0.0.6",
     "into-stream": "^7.0.0",
     "ipfs-http-client": "^56.0.1",
-    "it-pair": "^2.0.2",
     "it-pushable": "^2.0.1",
     "nock": "^13.0.3",
     "npm-run-all": "^4.1.5",
@@ -194,6 +195,7 @@
     "p-event": "^5.0.1",
     "p-times": "^4.0.0",
     "p-wait-for": "^4.1.0",
+    "protons": "^3.0.2",
     "rimraf": "^3.0.2",
     "sinon": "^13.0.1",
     "ts-sinon": "^2.0.2"

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

@@ -2,7 +2,7 @@ import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
 import { validateAddrs } from './utils.js'
 import { StreamHandler } from './stream-handler.js'
-import { CircuitRelay as CircuitPB, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay as CircuitPB } from '../pb/index.js'
 import { pipe } from 'it-pipe'
 import { codes as Errors } from '../../errors.js'
 import { stop } from './stop.js'
@@ -11,13 +11,13 @@ 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')
 
 export interface HopRequest {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
   streamHandler: StreamHandler
   circuit: Circuit
   connectionManager: ConnectionManager
@@ -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
     })
 
@@ -120,7 +120,7 @@ export async function handleHop (hopRequest: HopRequest) {
 
 export interface HopConfig {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
 }
 
 /**
@@ -153,7 +153,7 @@ export async function hop (options: HopConfig): Promise<Duplex<Uint8Array>> {
   log('hop request failed with code %d, closing stream', response.code)
   streamHandler.close()
 
-  throw errCode(new Error(`HOP request failed with code ${response.code}`), Errors.ERR_HOP_REQUEST_FAILED)
+  throw errCode(new Error(`HOP request failed with code "${response.code ?? 'unknown'}"`), Errors.ERR_HOP_REQUEST_FAILED)
 }
 
 export interface CanHopOptions {

package/src/circuit/circuit/stop.ts

@@ -1,5 +1,5 @@
 import { logger } from '@libp2p/logger'
-import { CircuitRelay as CircuitPB, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay as CircuitPB } from '../pb/index.js'
 import { RELAY_CODEC } from '../multicodec.js'
 import { StreamHandler } from './stream-handler.js'
 import { validateAddrs } from './utils.js'
@@ -10,7 +10,7 @@ const log = logger('libp2p:circuit:stop')
 
 export interface HandleStopOptions {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
   streamHandler: StreamHandler
 }
 
@@ -44,7 +44,7 @@ export function handleStop (options: HandleStopOptions): Duplex<Uint8Array> | un
 
 export interface StopOptions {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
 }
 
 /**

package/src/circuit/circuit/stream-handler.ts

@@ -1,7 +1,7 @@
 import { logger } from '@libp2p/logger'
 import * as lp from 'it-length-prefixed'
 import { Handshake, handshake } from 'it-handshake'
-import { CircuitRelay, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay } from '../pb/index.js'
 import type { Stream } from '@libp2p/interfaces/connection'
 import type { Source } from 'it-stream-types'
 
@@ -53,10 +53,9 @@ export class StreamHandler {
   /**
    * Encode and write array of buffers
    */
-  write (msg: ICircuitRelay) {
+  write (msg: CircuitRelay) {
     log('write message type %s', msg.type)
-    // @ts-expect-error lp.encode expects type type 'Buffer | BufferList', not 'Uint8Array'
-    this.shake.write(lp.encode.single(CircuitRelay.encode(msg).finish()))
+    this.shake.write(lp.encode.single(CircuitRelay.encode(msg)).slice())
   }
 
   /**
@@ -68,9 +67,9 @@ export class StreamHandler {
   }
 
   /**
-   * @param {ICircuitRelay} msg - An unencoded CircuitRelay protobuf message
+   * @param {CircuitRelay} msg - An unencoded CircuitRelay protobuf message
    */
-  end (msg: ICircuitRelay) {
+  end (msg: CircuitRelay) {
     this.write(msg)
     this.close()
   }

package/src/circuit/circuit/utils.ts

@@ -1,5 +1,5 @@
 import { Multiaddr } from '@multiformats/multiaddr'
-import { CircuitRelay, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay } from '../pb/index.js'
 import type { StreamHandler } from './stream-handler.js'
 
 /**
@@ -15,7 +15,7 @@ function writeResponse (streamHandler: StreamHandler, status: CircuitRelay.Statu
 /**
  * Validate incomming HOP/STOP message
  */
-export function validateAddrs (msg: ICircuitRelay, streamHandler: StreamHandler) {
+export function validateAddrs (msg: CircuitRelay, streamHandler: StreamHandler) {
   try {
     if (msg.dstPeer?.addrs != null) {
       msg.dstPeer.addrs.forEach((addr) => {

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 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.proto

@@ -1,4 +1,4 @@
-syntax = "proto2";
+syntax = "proto3";
 
 message CircuitRelay {
 

package/src/circuit/pb/index.ts

@@ -0,0 +1,88 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { enumeration, encodeMessage, decodeMessage, message, bytes } from 'protons-runtime'
+
+export interface CircuitRelay {
+  type?: CircuitRelay.Type
+  srcPeer?: CircuitRelay.Peer
+  dstPeer?: CircuitRelay.Peer
+  code?: CircuitRelay.Status
+}
+
+export namespace CircuitRelay {
+  export enum Status {
+    SUCCESS = 'SUCCESS',
+    HOP_SRC_ADDR_TOO_LONG = 'HOP_SRC_ADDR_TOO_LONG',
+    HOP_DST_ADDR_TOO_LONG = 'HOP_DST_ADDR_TOO_LONG',
+    HOP_SRC_MULTIADDR_INVALID = 'HOP_SRC_MULTIADDR_INVALID',
+    HOP_DST_MULTIADDR_INVALID = 'HOP_DST_MULTIADDR_INVALID',
+    HOP_NO_CONN_TO_DST = 'HOP_NO_CONN_TO_DST',
+    HOP_CANT_DIAL_DST = 'HOP_CANT_DIAL_DST',
+    HOP_CANT_OPEN_DST_STREAM = 'HOP_CANT_OPEN_DST_STREAM',
+    HOP_CANT_SPEAK_RELAY = 'HOP_CANT_SPEAK_RELAY',
+    HOP_CANT_RELAY_TO_SELF = 'HOP_CANT_RELAY_TO_SELF',
+    STOP_SRC_ADDR_TOO_LONG = 'STOP_SRC_ADDR_TOO_LONG',
+    STOP_DST_ADDR_TOO_LONG = 'STOP_DST_ADDR_TOO_LONG',
+    STOP_SRC_MULTIADDR_INVALID = 'STOP_SRC_MULTIADDR_INVALID',
+    STOP_DST_MULTIADDR_INVALID = 'STOP_DST_MULTIADDR_INVALID',
+    STOP_RELAY_REFUSED = 'STOP_RELAY_REFUSED',
+    MALFORMED_MESSAGE = 'MALFORMED_MESSAGE'
+  }
+
+  export namespace Status {
+    export const codec = () => {
+      return enumeration<typeof Status>(Status)
+    }
+  }
+  export enum Type {
+    HOP = 'HOP',
+    STOP = 'STOP',
+    STATUS = 'STATUS',
+    CAN_HOP = 'CAN_HOP'
+  }
+
+  export namespace Type {
+    export const codec = () => {
+      return enumeration<typeof Type>(Type)
+    }
+  }
+  export interface Peer {
+    id: Uint8Array
+    addrs: Uint8Array[]
+  }
+
+  export namespace Peer {
+    export const codec = () => {
+      return message<Peer>({
+        1: { name: 'id', codec: bytes },
+        2: { name: 'addrs', codec: bytes, repeats: true }
+      })
+    }
+
+    export const encode = (obj: Peer): Uint8Array => {
+      return encodeMessage(obj, Peer.codec())
+    }
+
+    export const decode = (buf: Uint8Array): Peer => {
+      return decodeMessage(buf, Peer.codec())
+    }
+  }
+
+  export const codec = () => {
+    return message<CircuitRelay>({
+      1: { name: 'type', codec: CircuitRelay.Type.codec(), optional: true },
+      2: { name: 'srcPeer', codec: CircuitRelay.Peer.codec(), optional: true },
+      3: { name: 'dstPeer', codec: CircuitRelay.Peer.codec(), optional: true },
+      4: { name: 'code', codec: CircuitRelay.Status.codec(), optional: true }
+    })
+  }
+
+  export const encode = (obj: CircuitRelay): Uint8Array => {
+    return encodeMessage(obj, CircuitRelay.codec())
+  }
+
+  export const decode = (buf: Uint8Array): CircuitRelay => {
+    return decodeMessage(buf, CircuitRelay.codec())
+  }
+}

package/src/circuit/transport.ts

@@ -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

@@ -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
 
   /**