libp2p 2.7.2 → 2.7.3-96f79bc11

package/src/transport-manager.ts

@@ -1,5 +1,6 @@
 import { FaultTolerance, InvalidParametersError, NotStartedError } from '@libp2p/interface'
 import { trackedMap } from '@libp2p/utils/tracked-map'
+import { IP4, IP6 } from '@multiformats/multiaddr-matcher'
 import { CustomProgressEvent } from 'progress-events'
 import { NoValidAddressesError, TransportUnavailableError } from './errors.js'
 import type { Libp2pEvents, ComponentLogger, Logger, Connection, TypedEventTarget, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
@@ -18,6 +19,17 @@ export interface DefaultTransportManagerComponents {
   logger: ComponentLogger
 }
 
+interface IPStats {
+  success: number
+  attempts: number
+}
+
+interface ListenStats {
+  unsupportedAddresses: Set<string>
+  ipv4: IPStats
+  ipv6: IPStats
+}
+
 export class DefaultTransportManager implements TransportManager, Startable {
   private readonly log: Logger
   private readonly components: DefaultTransportManagerComponents
@@ -192,11 +204,26 @@ export class DefaultTransportManager implements TransportManager, Startable {
       return
     }
 
-    const couldNotListen = []
+    // track IPv4/IPv6 results - if we succeed on IPv4 but all IPv6 attempts
+    // fail then we are probably on a network without IPv6 support
+    const listenStats: ListenStats = {
+      unsupportedAddresses: new Set(
+        addrs.map(ma => ma.toString())
+      ),
+      ipv4: {
+        success: 0,
+        attempts: 0
+      },
+      ipv6: {
+        success: 0,
+        attempts: 0
+      }
+    }
+
+    const tasks: Array<Promise<void>> = []
 
     for (const [key, transport] of this.transports.entries()) {
       const supportedAddrs = transport.listenFilter(addrs)
-      const tasks = []
 
       // For each supported multiaddr, create a listener
       for (const addr of supportedAddrs) {
@@ -231,36 +258,70 @@ export class DefaultTransportManager implements TransportManager, Startable {
           })
         })
 
+        // track IPv4/IPv6 support
+        if (IP4.matches(addr)) {
+          listenStats.ipv4.attempts++
+        } else if (IP6.matches(addr)) {
+          listenStats.ipv6.attempts++
+        }
+
         // We need to attempt to listen on everything
-        tasks.push(listener.listen(addr))
+        tasks.push(
+          listener.listen(addr)
+            .then(() => {
+              listenStats.unsupportedAddresses.delete(addr.toString())
+
+              if (IP4.matches(addr)) {
+                listenStats.ipv4.success++
+              }
+
+              if (IP6.matches(addr)) {
+                listenStats.ipv6.success++
+              }
+            }, (err) => {
+              this.log.error('transport %s could not listen on address %a - %e', key, addr, err)
+              throw err
+            })
+        )
       }
+    }
 
-      // Keep track of transports we had no addresses for
-      if (tasks.length === 0) {
-        couldNotListen.push(key)
-        continue
-      }
+    const results = await Promise.allSettled(tasks)
 
-      const results = await Promise.allSettled(tasks)
-      // If we are listening on at least 1 address, succeed.
-      // TODO: we should look at adding a retry (`p-retry`) here to better support
-      // listening on remote addresses as they may be offline. We could then potentially
-      // just wait for any (`p-any`) listener to succeed on each transport before returning
-      const isListening = results.find(r => r.status === 'fulfilled')
-      if ((isListening == null) && this.faultTolerance !== FaultTolerance.NO_FATAL) {
-        throw new NoValidAddressesError(`Transport (${key}) could not listen on any available address`)
-      }
+    // listening on all addresses, all good
+    if (results.length > 0 && results.every(res => res.status === 'fulfilled')) {
+      return
     }
 
-    // If no transports were able to listen, throw an error. This likely
-    // means we were given addresses we do not have transports for
-    if (couldNotListen.length === this.transports.size) {
-      const message = `no valid addresses were provided for transports [${couldNotListen.join(', ')}]`
-      if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
-        throw new NoValidAddressesError(message)
-      }
-      this.log(`libp2p in dial mode only: ${message}`)
+    // detect lack of IPv6 support on the current network - if we tried to
+    // listen on IPv4 and IPv6 addresses, and all IPv4 addresses succeeded but
+    // all IPv6 addresses fail, then we can assume there's no IPv6 here
+    if (this.ipv6Unsupported(listenStats)) {
+      this.log('all IPv4 addresses succeed but all IPv6 failed')
+      return
+    }
+
+    if (this.faultTolerance === FaultTolerance.NO_FATAL) {
+      // ok to be dial-only
+      this.log('failed to listen on any address but fault tolerance allows this')
+      return
     }
+
+    // if a configured address was not able to be listened on, throw an error
+    throw new NoValidAddressesError(`No configured transport could listen on these addresses, please remove them from your config: ${[
+      ...listenStats.unsupportedAddresses
+    ].join(', ')}`)
+  }
+
+  private ipv6Unsupported (listenStats: ListenStats): boolean {
+    if (listenStats.ipv4.attempts === 0 || listenStats.ipv6.attempts === 0) {
+      return false
+    }
+
+    const allIpv4Succeeded = listenStats.ipv4.attempts === listenStats.ipv4.success
+    const allIpv6Failed = listenStats.ipv6.success === 0
+
+    return allIpv4Succeeded && allIpv6Failed
   }
 
   /**

package/src/upgrader.ts

@@ -1,12 +1,13 @@
 import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, setMaxListeners, InvalidPeerIdError } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
+import { anySignal } from 'any-signal'
 import { CustomProgressEvent } from 'progress-events'
 import { createConnection } from './connection/index.js'
-import { PROTOCOL_NEGOTIATION_TIMEOUT, UPGRADE_TIMEOUT } from './connection-manager/constants.js'
+import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
 import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.js'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
-import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions, ConnectionEncrypter, SecuredConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, StreamMuxer, StreamMuxerFactory, Upgrader, UpgraderOptions, ConnectionLimits, SecureConnectionOptions, CounterGroup } from '@libp2p/interface'
+import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions, ConnectionEncrypter, SecuredConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, StreamMuxer, StreamMuxerFactory, Upgrader as UpgraderInterface, UpgraderOptions, ConnectionLimits, SecureConnectionOptions, CounterGroup, ClearableSignal } from '@libp2p/interface'
 import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
 
 interface CreateConnectionOptions {
@@ -40,13 +41,6 @@ export interface UpgraderInit {
    */
   inboundUpgradeTimeout?: number
 
-  /**
-   * An amount of ms by which an outbound connection upgrade must complete
-   *
-   * @default 3000
-   */
-  outboundUpgradeTimeout?: number
-
   /**
    * When a new incoming stream is opened on a multiplexed connection, protocol
    * negotiation on that stream must complete within this many ms
@@ -120,12 +114,11 @@ export interface DefaultUpgraderComponents {
 
 type ConnectionDeniedType = keyof Pick<ConnectionGater, 'denyOutboundConnection' | 'denyInboundEncryptedConnection' | 'denyOutboundEncryptedConnection' | 'denyInboundUpgradedConnection' | 'denyOutboundUpgradedConnection'>
 
-export class DefaultUpgrader implements Upgrader {
+export class Upgrader implements UpgraderInterface {
   private readonly components: DefaultUpgraderComponents
   private readonly connectionEncrypters: Map<string, ConnectionEncrypter>
   private readonly streamMuxers: Map<string, StreamMuxerFactory>
   private readonly inboundUpgradeTimeout: number
-  private readonly outboundUpgradeTimeout: number
   private readonly inboundStreamProtocolNegotiationTimeout: number
   private readonly outboundStreamProtocolNegotiationTimeout: number
   private readonly events: TypedEventTarget<Libp2pEvents>
@@ -148,8 +141,7 @@ export class DefaultUpgrader implements Upgrader {
       this.streamMuxers.set(muxer.protocol, muxer)
     })
 
-    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? UPGRADE_TIMEOUT
-    this.outboundUpgradeTimeout = init.outboundUpgradeTimeout ?? UPGRADE_TIMEOUT
+    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? INBOUND_UPGRADE_TIMEOUT
     this.inboundStreamProtocolNegotiationTimeout = init.inboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
     this.outboundStreamProtocolNegotiationTimeout = init.outboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
     this.events = components.events
@@ -177,12 +169,25 @@ export class DefaultUpgrader implements Upgrader {
     }
   }
 
+  createInboundAbortSignal (signal: AbortSignal): ClearableSignal {
+    const output = anySignal([
+      AbortSignal.timeout(this.inboundUpgradeTimeout),
+      signal
+    ])
+    setMaxListeners(Infinity, output)
+
+    return output
+  }
+
   /**
    * Upgrades an inbound connection
    */
-  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<void> {
+  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<void> {
     let accepted = false
 
+    // always apply upgrade timeout for incoming upgrades
+    const signal = this.createInboundAbortSignal(opts.signal)
+
     try {
       this.metrics.dials?.increment({
         inbound: true
@@ -196,7 +201,10 @@ export class DefaultUpgrader implements Upgrader {
 
       await this.shouldBlockConnection('denyInboundConnection', maConn)
 
-      await this._performUpgrade(maConn, 'inbound', opts)
+      await this._performUpgrade(maConn, 'inbound', {
+        ...opts,
+        signal
+      })
     } catch (err) {
       this.metrics.errors?.increment({
         inbound: true
@@ -204,6 +212,8 @@ export class DefaultUpgrader implements Upgrader {
 
       throw err
     } finally {
+      signal.clear()
+
       if (accepted) {
         this.components.connectionManager.afterUpgradeInbound()
       }
@@ -213,7 +223,7 @@ export class DefaultUpgrader implements Upgrader {
   /**
    * Upgrades an outbound connection
    */
-  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<Connection> {
+  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<Connection> {
     try {
       this.metrics.dials?.increment({
         outbound: true
@@ -251,14 +261,6 @@ export class DefaultUpgrader implements Upgrader {
     let muxerFactory: StreamMuxerFactory | undefined
     let cryptoProtocol
 
-    if (opts.signal == null) {
-      maConn.log('no abort signal was passed while trying to upgrade connection, falling back to default timeout')
-
-      const upgradeTimeoutSignal = AbortSignal.timeout(direction === 'inbound' ? this.inboundUpgradeTimeout : this.outboundUpgradeTimeout)
-      setMaxListeners(Infinity, upgradeTimeoutSignal)
-      opts.signal = upgradeTimeoutSignal
-    }
-
     this.components.metrics?.trackMultiaddrConnection(maConn)
 
     maConn.log.trace('starting the %s connection upgrade', direction)
@@ -413,7 +415,7 @@ export class DefaultUpgrader implements Upgrader {
               }
 
               // after the handshake the returned stream can have early data so override
-              // the souce/sink
+              // the source/sink
               muxedStream.source = stream.source
               muxedStream.sink = stream.sink
               muxedStream.protocol = protocol
@@ -434,7 +436,7 @@ export class DefaultUpgrader implements Upgrader {
               }
 
               // If a protocol stream has been successfully negotiated and is to be passed to the application,
-              // the peerstore should ensure that the peer is registered with that protocol
+              // the peer store should ensure that the peer is registered with that protocol
               await this.components.peerStore.merge(remotePeer, {
                 protocols: [protocol]
               })
@@ -499,13 +501,13 @@ export class DefaultUpgrader implements Upgrader {
           }
 
           // If a protocol stream has been successfully negotiated and is to be passed to the application,
-          // the peerstore should ensure that the peer is registered with that protocol
+          // the peer store should ensure that the peer is registered with that protocol
           await this.components.peerStore.merge(remotePeer, {
             protocols: [protocol]
           })
 
           // after the handshake the returned stream can have early data so override
-          // the souce/sink
+          // the source/sink
           muxedStream.source = stream.source
           muxedStream.sink = stream.sink
           muxedStream.protocol = protocol

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.7.2'
+export const version = '2.7.3-96f79bc11'
 export const name = 'js-libp2p'

package/dist/typedoc-urls.json

@@ -1,21 +0,0 @@
-{
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressFilter.html",
-  "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressManagerInit.html",
-  "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html",
-  "ConnectionMonitorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionMonitorInit.html",
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.TransportManagerInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  ".:Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  ".:ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  "userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user_agent.userAgent.html",
-  "./user-agent:userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user_agent.userAgent.html",
-  "name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "./version:name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html",
-  "./version:version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html"
-}