libp2p 0.37.3-e6f646e → 0.38.0

package/src/circuit/transport.ts

@@ -17,12 +17,23 @@ import type { AbortOptions } from '@libp2p/interfaces'
 import type { IncomingStreamData } from '@libp2p/interface-registrar'
 import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interface-transport'
 import type { Connection } from '@libp2p/interface-connection'
+import type { RelayConfig } from '../index.js'
+import { abortableDuplex } from 'abortable-iterator'
+import { TimeoutController } from 'timeout-abort-controller'
+import { setMaxListeners } from 'events'
+import type { Uint8ArrayList } from 'uint8arraylist'
+import type { Duplex } from 'it-stream-types'
 
 const log = logger('libp2p:circuit')
 
 export class Circuit implements Transport, Initializable {
   private handler?: ConnectionHandler
   private components: Components = new Components()
+  private readonly _init: RelayConfig
+
+  constructor (init: RelayConfig) {
+    this._init = init
+  }
 
   init (components: Components): void {
     this.components = components
@@ -54,49 +65,25 @@ export class Circuit implements Transport, Initializable {
 
   async _onProtocol (data: IncomingStreamData) {
     const { connection, stream } = data
-    const streamHandler = new StreamHandler({ stream })
-    const request = await streamHandler.read()
-
-    if (request == null) {
-      log('request was invalid, could not read from stream')
-      streamHandler.write({
-        type: CircuitPB.Type.STATUS,
-        code: CircuitPB.Status.MALFORMED_MESSAGE
-      })
-      streamHandler.close()
-      return
-    }
+    const controller = new TimeoutController(this._init.hop.timeout)
 
-    let virtualConnection
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, controller.signal)
+    } catch {}
 
-    switch (request.type) {
-      case CircuitPB.Type.CAN_HOP: {
-        log('received CAN_HOP request from %p', connection.remotePeer)
-        await handleCanHop({ circuit: this, connection, streamHandler })
-        break
-      }
-      case CircuitPB.Type.HOP: {
-        log('received HOP request from %p', connection.remotePeer)
-        virtualConnection = await handleHop({
-          connection,
-          request,
-          streamHandler,
-          circuit: this,
-          connectionManager: this.components.getConnectionManager()
-        })
-        break
-      }
-      case CircuitPB.Type.STOP: {
-        log('received STOP request from %p', connection.remotePeer)
-        virtualConnection = await handleStop({
-          connection,
-          request,
-          streamHandler
-        })
-        break
-      }
-      default: {
-        log('Request of type %s not supported', request.type)
+    try {
+      const source = abortableDuplex(stream, controller.signal)
+      const streamHandler = new StreamHandler({
+        stream: {
+          ...stream,
+          ...source
+        }
+      })
+      const request = await streamHandler.read()
+
+      if (request == null) {
+        log('request was invalid, could not read from stream')
         streamHandler.write({
           type: CircuitPB.Type.STATUS,
           code: CircuitPB.Status.MALFORMED_MESSAGE
@@ -104,27 +91,68 @@ export class Circuit implements Transport, Initializable {
         streamHandler.close()
         return
       }
-    }
 
-    if (virtualConnection != null) {
-      // @ts-expect-error dst peer will not be undefined
-      const remoteAddr = new Multiaddr(request.dstPeer.addrs[0])
-      // @ts-expect-error dst peer will not be undefined
-      const localAddr = new Multiaddr(request.srcPeer.addrs[0])
-      const maConn = streamToMaConnection({
-        stream: virtualConnection,
-        remoteAddr,
-        localAddr
-      })
-      const type = request.type === CircuitPB.Type.HOP ? 'relay' : 'inbound'
-      log('new %s connection %s', type, maConn.remoteAddr)
+      let virtualConnection: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array> | undefined
+
+      switch (request.type) {
+        case CircuitPB.Type.CAN_HOP: {
+          log('received CAN_HOP request from %p', connection.remotePeer)
+          await handleCanHop({ circuit: this, connection, streamHandler })
+          break
+        }
+        case CircuitPB.Type.HOP: {
+          log('received HOP request from %p', connection.remotePeer)
+          await handleHop({
+            connection,
+            request,
+            streamHandler,
+            circuit: this,
+            connectionManager: this.components.getConnectionManager()
+          })
+          break
+        }
+        case CircuitPB.Type.STOP: {
+          log('received STOP request from %p', connection.remotePeer)
+          virtualConnection = await handleStop({
+            connection,
+            request,
+            streamHandler
+          })
+          break
+        }
+        default: {
+          log('Request of type %s not supported', request.type)
+          streamHandler.write({
+            type: CircuitPB.Type.STATUS,
+            code: CircuitPB.Status.MALFORMED_MESSAGE
+          })
+          streamHandler.close()
+          return
+        }
+      }
 
-      const conn = await this.components.getUpgrader().upgradeInbound(maConn)
-      log('%s connection %s upgraded', type, maConn.remoteAddr)
+      if (virtualConnection != null) {
+        const remoteAddr = connection.remoteAddr
+          .encapsulate('/p2p-circuit')
+          .encapsulate(new Multiaddr(request.dstPeer?.addrs[0]))
+        const localAddr = new Multiaddr(request.srcPeer?.addrs[0])
+        const maConn = streamToMaConnection({
+          stream: virtualConnection,
+          remoteAddr,
+          localAddr
+        })
+        const type = request.type === CircuitPB.Type.HOP ? 'relay' : 'inbound'
+        log('new %s connection %s', type, maConn.remoteAddr)
+
+        const conn = await this.components.getUpgrader().upgradeInbound(maConn)
+        log('%s connection %s upgraded', type, maConn.remoteAddr)
 
-      if (this.handler != null) {
-        this.handler(conn)
+        if (this.handler != null) {
+          this.handler(conn)
+        }
       }
+    } finally {
+      controller.clear()
     }
   }
 
@@ -160,6 +188,7 @@ export class Circuit implements Transport, Initializable {
 
     try {
       const virtualConnection = await hop({
+        ...options,
         connection: relayConnection,
         request: {
           type: CircuitPB.Type.HOP,

package/src/config.ts

@@ -10,6 +10,7 @@ import type { Libp2pInit } from './index.js'
 import { codes, messages } from './errors.js'
 import errCode from 'err-code'
 import type { RecursivePartial } from '@libp2p/interfaces'
+import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isReactNative } from 'wherearewe'
 
 const DefaultConfig: Partial<Libp2pInit> = {
   addresses: {
@@ -26,6 +27,7 @@ const DefaultConfig: Partial<Libp2pInit> = {
     maxParallelDials: Constants.MAX_PARALLEL_DIALS,
     maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
     dialTimeout: Constants.DIAL_TIMEOUT,
+    inboundUpgradeTimeout: Constants.INBOUND_UPGRADE_TIMEOUT,
     resolvers: {
       dnsaddr: dnsaddrResolver
     },
@@ -67,7 +69,8 @@ const DefaultConfig: Partial<Libp2pInit> = {
     },
     hop: {
       enabled: false,
-      active: false
+      active: false,
+      timeout: 30000
     },
     autoRelay: {
       enabled: false,
@@ -79,7 +82,8 @@ const DefaultConfig: Partial<Libp2pInit> = {
     host: {
       agentVersion: AGENT_VERSION
     },
-    timeout: 30000,
+    // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L48
+    timeout: 60000,
     maxInboundStreams: 1,
     maxOutboundStreams: 1,
     maxPushIncomingStreams: 1,
@@ -88,12 +92,14 @@ const DefaultConfig: Partial<Libp2pInit> = {
   ping: {
     protocolPrefix: 'ipfs',
     maxInboundStreams: 1,
-    maxOutboundStreams: 1
+    maxOutboundStreams: 1,
+    timeout: 10000
   },
   fetch: {
     protocolPrefix: 'libp2p',
     maxInboundStreams: 1,
-    maxOutboundStreams: 1
+    maxOutboundStreams: 1,
+    timeout: 10000
   }
 }
 
@@ -112,5 +118,14 @@ export function validateConfig (opts: RecursivePartial<Libp2pInit>): Libp2pInit
     throw errCode(new Error(messages.ERR_PROTECTOR_REQUIRED), codes.ERR_PROTECTOR_REQUIRED)
   }
 
+  // Append user agent version to default AGENT_VERSION depending on the environment
+  if (resultingOptions.identify.host.agentVersion === AGENT_VERSION) {
+    if (isNode || isElectronMain) {
+      resultingOptions.identify.host.agentVersion += ` UserAgent=${globalThis.process.version}`
+    } else if (isBrowser || isWebWorker || isElectronRenderer || isReactNative) {
+      resultingOptions.identify.host.agentVersion += ` UserAgent=${globalThis.navigator.userAgent}`
+    }
+  }
+
   return resultingOptions
 }

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

@@ -2,6 +2,7 @@ import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { logger } from '@libp2p/logger'
 import type { Components } from '@libp2p/components'
 import { TimeoutController } from 'timeout-abort-controller'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:dialer:auto-dialer')
 
@@ -44,6 +45,11 @@ export class AutoDialer {
 
         const controller = new TimeoutController(this.dialTimeout)
 
+        try {
+          // fails on node < 15.4
+          setMaxListeners?.(Infinity, controller.signal)
+        } catch {}
+
         void this.components.getConnectionManager().openConnection(peer.id, {
           signal: controller.signal
         })

package/src/connection-manager/dialer/index.ts

@@ -177,7 +177,7 @@ export class Dialer implements Startable, Initializable {
 
     log('creating dial target for %p', id)
 
-    const dialTarget = await this._createCancellableDialTarget(id)
+    const dialTarget = await this._createCancellableDialTarget(id, options)
 
     if (dialTarget.addrs.length === 0) {
       throw errCode(new Error('The dial request has no valid addresses'), codes.ERR_NO_VALID_ADDRESSES)
@@ -207,7 +207,7 @@ export class Dialer implements Startable, Initializable {
    * The dial to the first address that is successfully able to upgrade a connection
    * will be used.
    */
-  async _createCancellableDialTarget (peer: PeerId): Promise<DialTarget> {
+  async _createCancellableDialTarget (peer: PeerId, options: AbortOptions): Promise<DialTarget> {
     // Make dial target promise cancellable
     const id = `${(parseInt(String(Math.random() * 1e9), 10)).toString()}${Date.now()}`
     const cancellablePromise = new Promise<DialTarget>((resolve, reject) => {
@@ -216,7 +216,7 @@ export class Dialer implements Startable, Initializable {
 
     try {
       const dialTarget = await Promise.race([
-        this._createDialTarget(peer),
+        this._createDialTarget(peer, options),
         cancellablePromise
       ])
 
@@ -232,7 +232,7 @@ export class Dialer implements Startable, Initializable {
    * If a multiaddr is received it should be the first address attempted.
    * Multiaddrs not supported by the available transports will be filtered out.
    */
-  async _createDialTarget (peer: PeerId): Promise<DialTarget> {
+  async _createDialTarget (peer: PeerId, options: AbortOptions): Promise<DialTarget> {
     const knownAddrs = await pipe(
       await this.components.getPeerStore().addressBook.get(peer),
       (source) => filter(source, async (address) => {
@@ -253,7 +253,7 @@ export class Dialer implements Startable, Initializable {
 
     const addrs: Multiaddr[] = []
     for (const a of knownAddrs) {
-      const resolvedAddrs = await this._resolve(a)
+      const resolvedAddrs = await this._resolve(a, options)
       resolvedAddrs.forEach(ra => addrs.push(ra))
     }
 
@@ -341,7 +341,7 @@ export class Dialer implements Startable, Initializable {
   /**
    * Resolve multiaddr recursively
    */
-  async _resolve (ma: Multiaddr): Promise<Multiaddr[]> {
+  async _resolve (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
     // TODO: recursive logic should live in multiaddr once dns4/dns6 support is in place
     // Now only supporting resolve for dnsaddr
     const resolvableProto = ma.protoNames().includes('dnsaddr')
@@ -351,9 +351,9 @@ export class Dialer implements Startable, Initializable {
       return [ma]
     }
 
-    const resolvedMultiaddrs = await this._resolveRecord(ma)
+    const resolvedMultiaddrs = await this._resolveRecord(ma, options)
     const recursiveMultiaddrs = await Promise.all(resolvedMultiaddrs.map(async (nm) => {
-      return await this._resolve(nm)
+      return await this._resolve(nm, options)
     }))
 
     const addrs = recursiveMultiaddrs.flat()
@@ -368,10 +368,10 @@ export class Dialer implements Startable, Initializable {
   /**
    * Resolve a given multiaddr. If this fails, an empty array will be returned
    */
-  async _resolveRecord (ma: Multiaddr): Promise<Multiaddr[]> {
+  async _resolveRecord (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
     try {
       ma = new Multiaddr(ma.toString()) // Use current multiaddr module
-      const multiaddrs = await ma.resolve()
+      const multiaddrs = await ma.resolve(options)
       return multiaddrs
     } catch (err) {
       log.error(`multiaddr ${ma.toString()} could not be resolved`, err)

package/src/connection-manager/index.ts

@@ -107,10 +107,17 @@ export interface ConnectionManagerInit {
   maxAddrsToDial?: number
 
   /**
-   * How long a dial attempt is allowed to take
+   * How long a dial attempt is allowed to take, including DNS resolution
+   * of the multiaddr, opening a socket and upgrading it to a Connection.
    */
   dialTimeout?: number
 
+  /**
+   * When a new inbound connection is opened, the upgrade process (e.g. protect,
+   * encrypt, multiplex etc) must complete within this number of ms.
+   */
+  inboundUpgradeTimeout: number
+
   /**
    * Number of max concurrent dials per peer
    */
@@ -146,6 +153,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   private readonly latencyMonitor: LatencyMonitor
   private readonly startupReconnectTimeout: number
   private connectOnStartupController?: TimeoutController
+  private readonly dialTimeout: number
 
   constructor (init: ConnectionManagerInit) {
     super()
@@ -182,6 +190,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.onDisconnect = this.onDisconnect.bind(this)
 
     this.startupReconnectTimeout = init.startupReconnectTimeout ?? STARTUP_RECONNECT_TIMEOUT
+    this.dialTimeout = init.dialTimeout ?? 30000
   }
 
   init (components: Components): void {
@@ -322,6 +331,11 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         this.connectOnStartupController?.clear()
         this.connectOnStartupController = new TimeoutController(this.startupReconnectTimeout)
 
+        try {
+          // fails on node < 15.4
+          setMaxListeners?.(Infinity, this.connectOnStartupController.signal)
+        } catch {}
+
         await Promise.all(
           keepAlivePeers.map(async peer => {
             await this.openConnection(peer, {
@@ -333,6 +347,9 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
           })
         )
       })
+      .catch(err => {
+        log.error(err)
+      })
       .finally(() => {
         this.connectOnStartupController?.clear()
       })
@@ -486,7 +503,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     return conns
   }
 
-  async openConnection (peerId: PeerId, options?: AbortOptions): Promise<Connection> {
+  async openConnection (peerId: PeerId, options: AbortOptions = {}): Promise<Connection> {
     log('dial to %p', peerId)
     const existingConnections = this.getConnections(peerId)
 
@@ -496,30 +513,48 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       return existingConnections[0]
     }
 
-    const connection = await this.dialer.dial(peerId, options)
-    let peerConnections = this.connections.get(peerId.toString())
+    let timeoutController: TimeoutController | undefined
 
-    if (peerConnections == null) {
-      peerConnections = []
-      this.connections.set(peerId.toString(), peerConnections)
+    if (options?.signal == null) {
+      timeoutController = new TimeoutController(this.dialTimeout)
+      options.signal = timeoutController.signal
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
     }
 
-    // we get notified of connections via the Upgrader emitting "connection"
-    // events, double check we aren't already tracking this connection before
-    // storing it
-    let trackedConnection = false
+    try {
+      const connection = await this.dialer.dial(peerId, options)
+      let peerConnections = this.connections.get(peerId.toString())
 
-    for (const conn of peerConnections) {
-      if (conn.id === connection.id) {
-        trackedConnection = true
+      if (peerConnections == null) {
+        peerConnections = []
+        this.connections.set(peerId.toString(), peerConnections)
       }
-    }
 
-    if (!trackedConnection) {
-      peerConnections.push(connection)
-    }
+      // we get notified of connections via the Upgrader emitting "connection"
+      // events, double check we aren't already tracking this connection before
+      // storing it
+      let trackedConnection = false
+
+      for (const conn of peerConnections) {
+        if (conn.id === connection.id) {
+          trackedConnection = true
+        }
+      }
+
+      if (!trackedConnection) {
+        peerConnections.push(connection)
+      }
 
-    return connection
+      return connection
+    } finally {
+      if (timeoutController != null) {
+        timeoutController.clear()
+      }
+    }
   }
 
   async closeConnections (peerId: PeerId): Promise<void> {

package/src/constants.ts

@@ -4,6 +4,11 @@
  */
 export const DIAL_TIMEOUT = 30e3
 
+/**
+ * How long in ms an inbound connection upgrade is allowed to take
+ */
+export const INBOUND_UPGRADE_TIMEOUT = 30e3
+
 /**
  * Maximum allowed concurrent dials
  */

package/src/fetch/index.ts

@@ -10,10 +10,11 @@ import type { Stream } from '@libp2p/interface-connection'
 import type { IncomingStreamData } from '@libp2p/interface-registrar'
 import type { Components } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { Duplex } from 'it-stream-types'
 import { abortableDuplex } from 'abortable-iterator'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
+import { TimeoutController } from 'timeout-abort-controller'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:fetch')
 
@@ -21,6 +22,11 @@ export interface FetchServiceInit {
   protocolPrefix: string
   maxInboundStreams: number
   maxOutboundStreams: number
+
+  /**
+   * How long we should wait for a remote peer to send any data
+   */
+  timeout: number
 }
 
 export interface HandleMessageOptions {
@@ -86,15 +92,29 @@ export class FetchService implements Startable {
     log('dialing %s to %p', this.protocol, peer)
 
     const connection = await this.components.getConnectionManager().openConnection(peer, options)
-    const stream = await connection.newStream([this.protocol], options)
-    let source: Duplex<Uint8Array> = stream
-
-    // make stream abortable if AbortSignal passed
-    if (options.signal != null) {
-      source = abortableDuplex(stream, options.signal)
+    let timeoutController
+    let signal = options.signal
+    let stream: Stream | undefined
+
+    // create a timeout if no abort signal passed
+    if (signal == null) {
+      timeoutController = new TimeoutController(this.init.timeout)
+      signal = timeoutController.signal
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
     }
 
     try {
+      stream = await connection.newStream([this.protocol], {
+        signal
+      })
+
+      // make stream abortable
+      const source = abortableDuplex(stream, signal)
+
       const result = await pipe(
         [FetchRequest.encode({ identifier: key })],
         lp.encode(),
@@ -129,7 +149,13 @@ export class FetchService implements Startable {
 
       return result ?? null
     } finally {
-      stream.close()
+      if (timeoutController != null) {
+        timeoutController.clear()
+      }
+
+      if (stream != null) {
+        stream.close()
+      }
     }
   }