fix!: remove autodialer

doc/CONFIGURATION.md

@@ -626,8 +626,7 @@ const node = await createLibp2p({
     noise()
   ],
   connectionManager: {
-    maxConnections: Infinity,
-    minConnections: 0
+    maxConnections: Infinity
   }
 })
 ```

doc/LIMITS.md

@@ -38,12 +38,6 @@ const node = await createLibp2p({
      */
     maxConnections: 100,
 
-    /**
-     * If the number of open connections goes below this number, the node
-     * will try to connect to randomly selected peers from the peer store
-     */
-    minConnections: 50,
-
     /**
      * How many connections can be open but not yet upgraded
      */

interop/test/fixtures/get-libp2p.ts

@@ -25,9 +25,6 @@ const IP = process.env.ip ?? '0.0.0.0'
 export async function getLibp2p (): Promise<Libp2p<{ ping: PingService }>> {
   const options: Libp2pOptions<{ ping: PingService, identify: Identify }> = {
     start: true,
-    connectionManager: {
-      minConnections: 0
-    },
     connectionGater: {
       denyDialMultiaddr: async () => false
     },

packages/integration-tests/.aegir.js

@@ -24,8 +24,7 @@ export default {
       const peerId = await createEd25519PeerId()
       const libp2p = await createLibp2p({
         connectionManager: {
-          inboundConnectionThreshold: Infinity,
-          minConnections: 0
+          inboundConnectionThreshold: Infinity
         },
         addresses: {
           listen: [

packages/integration-tests/test/bootstrap.spec.ts

@@ -2,8 +2,11 @@
 
 import { bootstrap } from '@libp2p/bootstrap'
 import { TypedEventEmitter, peerDiscoverySymbol } from '@libp2p/interface'
+import { mplex } from '@libp2p/mplex'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { plaintext } from '@libp2p/plaintext'
 import { webSockets } from '@libp2p/websockets'
+import * as Filter from '@libp2p/websockets/filters'
 import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
 import { createLibp2p } from 'libp2p'
@@ -103,4 +106,52 @@ describe('bootstrap', () => {
 
     return deferred.promise
   })
+
+  it('bootstrap should dial all peers in the list', async () => {
+    const deferred = defer()
+
+    const bootstrappers = [
+      `${process.env.RELAY_MULTIADDR}`
+    ]
+
+    libp2p = await createLibp2p({
+      connectionEncryption: [
+        plaintext()
+      ],
+      transports: [
+        webSockets({
+          filter: Filter.all
+        })
+      ],
+      streamMuxers: [
+        mplex()
+      ],
+      peerDiscovery: [
+        bootstrap({
+          list: bootstrappers
+        })
+      ],
+      connectionGater: {
+        denyDialMultiaddr: () => false
+      }
+    })
+
+    const expectedPeers = new Set(
+      bootstrappers.map(ma => multiaddr(ma).getPeerId())
+    )
+
+    libp2p.addEventListener('connection:open', (evt) => {
+      const { remotePeer } = evt.detail
+
+      expectedPeers.delete(remotePeer.toString())
+      if (expectedPeers.size === 0) {
+        libp2p.removeEventListener('connection:open')
+        deferred.resolve()
+      }
+    })
+
+    await libp2p.start()
+
+    return deferred.promise
+  })
 })

packages/integration-tests/test/circuit-relay.node.ts

@@ -42,9 +42,6 @@ async function createClient (options: Libp2pOptions = {}): Promise<Libp2p> {
     connectionEncryption: [
       plaintext()
     ],
-    connectionManager: {
-      minConnections: 0
-    },
     services: {
       identify: identify()
     },

packages/integration-tests/test/fetch.spec.ts

@@ -11,9 +11,6 @@ async function createNode (): Promise<Libp2p<{ fetch: Fetch }>> {
   return createLibp2p(createBaseOptions({
     services: {
       fetch: fetch()
-    },
-    connectionManager: {
-      minConnections: 0
     }
   }))
 }

packages/integration-tests/test/interop.ts

@@ -134,10 +134,7 @@ async function createJsPeer (options: SpawnOptions): Promise<Daemon> {
     },
     transports: [tcp(), circuitRelayTransport()],
     streamMuxers: [],
-    connectionEncryption: [noise()],
-    connectionManager: {
-      minConnections: 0
-    }
+    connectionEncryption: [noise()]
   }
 
   if (options.noListen !== true) {

packages/integration-tests/test/peers.spec.ts

@@ -0,0 +1,59 @@
+/* eslint-env mocha */
+
+import { KEEP_ALIVE, type Libp2p } from '@libp2p/interface'
+import { expect } from 'aegir/chai'
+import { createLibp2p } from 'libp2p'
+import pWaitFor from 'p-wait-for'
+import { createBaseOptions } from './fixtures/base-options.js'
+
+describe('peers', () => {
+  let nodes: Libp2p[]
+
+  beforeEach(async () => {
+    nodes = await Promise.all([
+      createLibp2p(createBaseOptions()),
+      createLibp2p(createBaseOptions()),
+      createLibp2p(createBaseOptions())
+    ])
+  })
+
+  afterEach(async () => Promise.all(nodes.map(async n => { await n.stop() })))
+
+  it('should redial a peer tagged with KEEP_ALIVE', async () => {
+    await nodes[0].dial(nodes[1].getMultiaddrs())
+
+    expect(nodes[0].getConnections(nodes[1].peerId)).to.not.be.empty()
+
+    await nodes[0].peerStore.merge(nodes[1].peerId, {
+      tags: {
+        [KEEP_ALIVE]: {
+          value: 1
+        }
+      }
+    })
+
+    await Promise.all(
+      nodes[0].getConnections(nodes[1].peerId).map(async conn => conn.close())
+    )
+
+    await pWaitFor(async () => {
+      return nodes[0].getConnections(nodes[1].peerId).length > 0
+    }, {
+      interval: 100,
+      timeout: {
+        milliseconds: 5000,
+        message: 'Did not reconnect to peer tagged with KEEP_ALIVE'
+      }
+    })
+  })
+
+  it('should store the multiaddr for a peer after a successful dial', async () => {
+    await nodes[0].dial(nodes[1].getMultiaddrs())
+
+    expect(nodes[0].getConnections(nodes[1].peerId)).to.not.be.empty()
+
+    const peer = await nodes[0].peerStore.get(nodes[1].peerId)
+    expect(peer.addresses).to.not.be.empty()
+    expect(peer.metadata.get('last-dial-success')).to.be.ok()
+  })
+})

packages/libp2p/.aegir.js

@@ -20,8 +20,7 @@ export default {
       const peerId = await createEd25519PeerId()
       const libp2p = await createLibp2p({
         connectionManager: {
-          inboundConnectionThreshold: Infinity,
-          minConnections: 0
+          inboundConnectionThreshold: Infinity
         },
         addresses: {
           listen: [

packages/libp2p/package.json

@@ -107,6 +107,7 @@
     "merge-options": "^3.0.4",
     "multiformats": "^13.1.0",
     "p-defer": "^4.0.1",
+    "p-retry": "^6.2.0",
     "progress-events": "^1.0.0",
     "race-event": "^1.3.0",
     "race-signal": "^1.0.2",