libp2p 0.46.8 → 0.46.9

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

@@ -2,7 +2,7 @@ import { logger } from '@libp2p/logger'
 import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { PeerJobQueue } from '../utils/peer-job-queue.js'
-import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PEER_RETRY_THRESHOLD, AUTO_DIAL_PRIORITY, LAST_DIAL_FAILURE_KEY, MIN_CONNECTIONS } from './constants.js'
+import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE, AUTO_DIAL_INTERVAL, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PEER_RETRY_THRESHOLD, AUTO_DIAL_PRIORITY, LAST_DIAL_FAILURE_KEY, MIN_CONNECTIONS } from './constants.js'
 import type { Libp2pEvents } from '@libp2p/interface'
 import type { EventEmitter } from '@libp2p/interface/events'
 import type { PeerStore } from '@libp2p/interface/peer-store'
@@ -18,6 +18,7 @@ interface AutoDialInit {
   autoDialPriority?: number
   autoDialInterval?: number
   autoDialPeerRetryThreshold?: number
+  autoDialDiscoveredPeersDebounce?: number
 }
 
 interface AutoDialComponents {
@@ -32,7 +33,8 @@ const defaultOptions = {
   autoDialConcurrency: AUTO_DIAL_CONCURRENCY,
   autoDialPriority: AUTO_DIAL_PRIORITY,
   autoDialInterval: AUTO_DIAL_INTERVAL,
-  autoDialPeerRetryThreshold: AUTO_DIAL_PEER_RETRY_THRESHOLD
+  autoDialPeerRetryThreshold: AUTO_DIAL_PEER_RETRY_THRESHOLD,
+  autoDialDiscoveredPeersDebounce: AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE
 }
 
 export class AutoDial implements Startable {
@@ -44,6 +46,7 @@ export class AutoDial implements Startable {
   private readonly autoDialIntervalMs: number
   private readonly autoDialMaxQueueLength: number
   private readonly autoDialPeerRetryThresholdMs: number
+  private readonly autoDialDiscoveredPeersDebounce: number
   private autoDialInterval?: ReturnType<typeof setInterval>
   private started: boolean
   private running: boolean
@@ -61,6 +64,7 @@ export class AutoDial implements Startable {
     this.autoDialIntervalMs = init.autoDialInterval ?? defaultOptions.autoDialInterval
     this.autoDialMaxQueueLength = init.maxQueueLength ?? defaultOptions.maxQueueLength
     this.autoDialPeerRetryThresholdMs = init.autoDialPeerRetryThreshold ?? defaultOptions.autoDialPeerRetryThreshold
+    this.autoDialDiscoveredPeersDebounce = init.autoDialDiscoveredPeersDebounce ?? defaultOptions.autoDialDiscoveredPeersDebounce
     this.started = false
     this.running = false
     this.queue = new PeerJobQueue({
@@ -77,6 +81,22 @@ export class AutoDial implements Startable {
           log.error(err)
         })
     })
+
+    // sometimes peers are discovered in quick succession so add a small
+    // debounce to ensure all eligible peers are autodialed
+    let debounce: ReturnType<typeof setTimeout>
+
+    // when new peers are discovered, dial them if we don't have
+    // enough connections
+    components.events.addEventListener('peer:discovery', () => {
+      clearTimeout(debounce)
+      debounce = setTimeout(() => {
+        this.autoDial()
+          .catch(err => {
+            log.error(err)
+          })
+      }, this.autoDialDiscoveredPeersDebounce)
+    })
   }
 
   isStarted (): boolean {

package/src/connection-manager/constants.defaults.ts

@@ -38,6 +38,11 @@ export const AUTO_DIAL_MAX_QUEUE_LENGTH = 100
  */
 export const AUTO_DIAL_PEER_RETRY_THRESHOLD = 1000 * 60
 
+/**
+ * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.unknown.ConnectionManagerInit.html#autoDialDiscoveredPeersDebounce
+ */
+export const AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE = 10
+
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#inboundConnectionThreshold
  */

package/src/connection-manager/index.ts

@@ -72,6 +72,14 @@ export interface ConnectionManagerInit {
    */
   autoDialPeerRetryThreshold?: number
 
+  /**
+   * Newly discovered peers may be auto-dialed to increase the number of open
+   * connections, but they can be discovered in quick succession so add a small
+   * delay before attempting to dial them in case more peers have been
+   * discovered. (default: 10ms)
+   */
+  autoDialDiscoveredPeersDebounce?: number
+
   /**
    * Sort the known addresses of a peer before trying to dial, By default public
    * addresses will be dialled before private (e.g. loopback or LAN) addresses.

package/src/fetch/index.ts

@@ -1,7 +1,6 @@
 import { setMaxListeners } from 'events'
 import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
-import { abortableDuplex } from 'abortable-iterator'
 import first from 'it-first'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
@@ -140,6 +139,7 @@ class DefaultFetchService implements Startable, FetchService {
     const connection = await this.components.connectionManager.openConnection(peer, options)
     let signal = options.signal
     let stream: Stream | undefined
+    let onAbort = (): void => {}
 
     // create a timeout if no abort signal passed
     if (signal == null) {
@@ -157,15 +157,19 @@ class DefaultFetchService implements Startable, FetchService {
         signal
       })
 
+      onAbort = () => {
+        stream?.abort(new CodeError('fetch timeout', codes.ERR_TIMEOUT))
+      }
+
       // make stream abortable
-      const source = abortableDuplex(stream, signal)
+      signal.addEventListener('abort', onAbort, { once: true })
 
       log('fetch %s', key)
 
       const result = await pipe(
         [FetchRequest.encode({ identifier: key })],
         (source) => lp.encode(source),
-        source,
+        stream,
         (source) => lp.decode(source),
         async function (source) {
           const buf = await first(source)
@@ -200,6 +204,7 @@ class DefaultFetchService implements Startable, FetchService {
 
       return result ?? null
     } finally {
+      signal.removeEventListener('abort', onAbort)
       if (stream != null) {
         await stream.close()
       }

package/src/libp2p.ts

@@ -105,7 +105,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
           protocols: evt.detail.peer.protocols
         }
 
-        this.safeDispatchEvent('peer:discovery', { detail: peerInfo })
+        components.events.safeDispatchEvent('peer:discovery', { detail: peerInfo })
       }
     })
 

package/src/ping/index.ts

@@ -1,7 +1,6 @@
 import { randomBytes } from '@libp2p/crypto'
 import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
-import { abortableDuplex } from 'abortable-iterator'
 import first from 'it-first'
 import { pipe } from 'it-pipe'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
@@ -108,6 +107,7 @@ class DefaultPingService implements Startable, PingService {
     const data = randomBytes(PING_LENGTH)
     const connection = await this.components.connectionManager.openConnection(peer, options)
     let stream: Stream | undefined
+    let onAbort = (): void => {}
 
     options.signal = options.signal ?? AbortSignal.timeout(this.timeout)
 
@@ -117,12 +117,16 @@ class DefaultPingService implements Startable, PingService {
         runOnTransientConnection: this.runOnTransientConnection
       })
 
+      onAbort = () => {
+        stream?.abort(new CodeError('ping timeout', codes.ERR_TIMEOUT))
+      }
+
       // make stream abortable
-      const source = abortableDuplex(stream, options.signal)
+      options.signal.addEventListener('abort', onAbort, { once: true })
 
       const result = await pipe(
         [data],
-        source,
+        stream,
         async (source) => first(source)
       )
 
@@ -146,6 +150,7 @@ class DefaultPingService implements Startable, PingService {
 
       throw err
     } finally {
+      options.signal.removeEventListener('abort', onAbort)
       if (stream != null) {
         await stream.close()
       }

package/src/upgrader.ts

@@ -3,7 +3,6 @@ import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { abortableDuplex } from 'abortable-iterator'
 import { createConnection } from './connection/index.js'
 import { INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
 import { codes } from './errors.js'
@@ -165,16 +164,18 @@ export class DefaultUpgrader implements Upgrader {
 
     const signal = AbortSignal.timeout(this.inboundUpgradeTimeout)
 
+    const onAbort = (): void => {
+      maConn.abort(new CodeError('inbound upgrade timeout', codes.ERR_TIMEOUT))
+    }
+
+    signal.addEventListener('abort', onAbort, { once: true })
+
     try {
       // fails on node < 15.4
       setMaxListeners?.(Infinity, signal)
     } catch { }
 
     try {
-      const abortableStream = abortableDuplex(maConn, signal)
-      maConn.source = abortableStream.source
-      maConn.sink = abortableStream.sink
-
       if ((await this.components.connectionGater.denyInboundConnection?.(maConn)) === true) {
         throw new CodeError('The multiaddr connection is blocked by gater.acceptConnection', codes.ERR_CONNECTION_INTERCEPTED)
       }
@@ -255,6 +256,8 @@ export class DefaultUpgrader implements Upgrader {
         transient: opts?.transient
       })
     } finally {
+      signal.removeEventListener('abort', onAbort)
+
       this.components.connectionManager.afterUpgradeInbound()
     }
   }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.46.8'
+export const version = '0.46.9'
 export const name = 'libp2p'