libp2p 2.8.8 → 2.8.9-6c42ea64a

package/src/address-manager/observed-addresses.ts

@@ -1,5 +1,6 @@
 import { isLinkLocal } from '@libp2p/utils/multiaddr/is-link-local'
 import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import { trackedMap } from '@libp2p/utils/tracked-map'
 import { multiaddr } from '@multiformats/multiaddr'
 import type { AddressManagerComponents, AddressManagerInit } from './index.js'
 import type { Logger } from '@libp2p/interface'
@@ -23,7 +24,10 @@ export class ObservedAddresses {
 
   constructor (components: AddressManagerComponents, init: AddressManagerInit = {}) {
     this.log = components.logger.forComponent('libp2p:address-manager:observed-addresses')
-    this.addresses = new Map()
+    this.addresses = trackedMap({
+      name: 'libp2p_address_manager_observed_addresses',
+      metrics: components.metrics
+    })
     this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses
   }
 

package/src/address-manager/transport-addresses.ts

@@ -1,5 +1,6 @@
 import { isNetworkAddress } from '@libp2p/utils/multiaddr/is-network-address'
 import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import { trackedMap } from '@libp2p/utils/tracked-map'
 import type { AddressManagerComponents, AddressManagerInit } from './index.js'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
@@ -22,7 +23,10 @@ export class TransportAddresses {
 
   constructor (components: AddressManagerComponents, init: AddressManagerInit = {}) {
     this.log = components.logger.forComponent('libp2p:address-manager:observed-addresses')
-    this.addresses = new Map()
+    this.addresses = trackedMap({
+      name: 'libp2p_address_manager_transport_addresses',
+      metrics: components.metrics
+    })
     this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses
   }
 

package/src/components.ts

@@ -1,10 +1,11 @@
 import { serviceCapabilities, serviceDependencies, isStartable } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { MissingServiceError, UnmetServiceDependenciesError } from './errors.js'
-import type { Startable, Libp2pEvents, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionGater, ContentRouting, TypedEventTarget, Metrics, PeerId, PeerRouting, PeerStore, PrivateKey, Upgrader } from '@libp2p/interface'
+import type { Startable, Libp2pEvents, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionGater, ContentRouting, Metrics, PeerId, PeerRouting, PeerStore, PrivateKey, Upgrader } from '@libp2p/interface'
 import type { AddressManager, ConnectionManager, RandomWalk, Registrar, TransportManager } from '@libp2p/interface-internal'
 import type { DNS } from '@multiformats/dns'
 import type { Datastore } from 'interface-datastore'
+import type { TypedEventTarget } from 'main-event'
 
 export interface Components extends Record<string, any>, Startable {
   peerId: PeerId

package/src/connection/index.ts

@@ -1,4 +1,5 @@
-import { connectionSymbol, setMaxListeners, LimitedConnectionError, ConnectionClosedError, ConnectionClosingError } from '@libp2p/interface'
+import { connectionSymbol, LimitedConnectionError, ConnectionClosedError, ConnectionClosingError } from '@libp2p/interface'
+import { setMaxListeners } from 'main-event'
 import type { AbortOptions, Logger, ComponentLogger, Direction, Connection, Stream, ConnectionTimeline, ConnectionStatus, NewStreamOptions, PeerId, ConnectionLimits } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 

package/src/connection-manager/connection-pruner.ts

@@ -1,14 +1,13 @@
 import { PeerMap } from '@libp2p/peer-collections'
 import { safelyCloseConnectionIfUnused } from '@libp2p/utils/close'
-import { MAX_CONNECTIONS } from './constants.js'
 import { multiaddrToIpNet } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
-import type { Libp2pEvents, Logger, ComponentLogger, TypedEventTarget, PeerStore, Connection } from '@libp2p/interface'
+import type { Libp2pEvents, Logger, ComponentLogger, PeerStore, Connection } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
+import type { TypedEventTarget } from 'main-event'
 
 interface ConnectionPrunerInit {
-  maxConnections?: number
   allow?: Multiaddr[]
 }
 
@@ -19,16 +18,10 @@ interface ConnectionPrunerComponents {
   logger: ComponentLogger
 }
 
-const defaultOptions = {
-  maxConnections: MAX_CONNECTIONS,
-  allow: []
-}
-
 /**
  * If we go over the max connections limit, choose some connections to close
  */
 export class ConnectionPruner {
-  private readonly maxConnections: number
   private readonly connectionManager: ConnectionManager
   private readonly peerStore: PeerStore
   private readonly allow: IpNet[]
@@ -36,7 +29,6 @@ export class ConnectionPruner {
   private readonly log: Logger
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
-    this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
     this.allow = (init.allow ?? []).map(ma => multiaddrToIpNet(ma))
     this.connectionManager = components.connectionManager
     this.peerStore = components.peerStore
@@ -67,10 +59,11 @@ export class ConnectionPruner {
   private async _maybePruneConnections (): Promise<void> {
     const connections = this.connectionManager.getConnections()
     const numConnections = connections.length
+    const maxConnections = this.connectionManager.getMaxConnections()
 
-    this.log('checking max connections limit %d/%d', numConnections, this.maxConnections)
+    this.log('checking max connections limit %d/%d', numConnections, maxConnections)
 
-    if (numConnections <= this.maxConnections) {
+    if (numConnections <= maxConnections) {
       return
     }
 
@@ -103,7 +96,7 @@ export class ConnectionPruner {
     const sortedConnections = this.sortConnections(connections, peerValues)
 
     // close some connections
-    const toPrune = Math.max(numConnections - this.maxConnections, 0)
+    const toPrune = Math.max(numConnections - maxConnections, 0)
     const toClose = []
 
     for (const connection of sortedConnections) {

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

@@ -1,11 +1,12 @@
 /* eslint-disable max-depth */
-import { TimeoutError, DialError, setMaxListeners, AbortError } from '@libp2p/interface'
+import { TimeoutError, DialError, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { PriorityQueue } from '@libp2p/utils/priority-queue'
 import { resolvers, multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { Circuit } from '@multiformats/multiaddr-matcher'
 import { anySignal } from 'any-signal'
+import { setMaxListeners } from 'main-event'
 import { CustomProgressEvent } from 'progress-events'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DialDeniedError, NoValidAddressesError } from '../errors.js'
@@ -436,15 +437,10 @@ export class DialQueue {
     if (peerId != null) {
       const peerIdMultiaddr = `/p2p/${peerId.toString()}`
       resolvedAddresses = resolvedAddresses.map(addr => {
-        const lastProto = addr.multiaddr.protos().pop()
-
-        // do not append peer id to path multiaddrs
-        if (lastProto?.path === true) {
-          return addr
-        }
+        const lastComponent = addr.multiaddr.getComponents().pop()
 
         // append peer id to multiaddr if it is not already present
-        if (addr.multiaddr.getPeerId() == null) {
+        if (lastComponent?.name !== 'p2p') {
           return {
             multiaddr: addr.multiaddr.encapsulate(peerIdMultiaddr),
             isCertified: addr.isCertified

package/src/connection-manager/index.ts

@@ -11,10 +11,11 @@ import { DialQueue } from './dial-queue.js'
 import { ReconnectQueue } from './reconnect-queue.js'
 import { multiaddrToIpNet } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { JobStatus } from '@libp2p/utils/queue'
 import type { Multiaddr, Resolver } from '@multiformats/multiaddr'
+import type { TypedEventTarget } from 'main-event'
 
 export const DEFAULT_DIAL_PRIORITY = 50
 
@@ -205,7 +206,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly maxIncomingPendingConnections: number
   private incomingPendingConnections: number
   private outboundPendingConnections: number
-  private readonly maxConnections: number
+  private maxConnections: number
 
   public readonly dialQueue: DialQueue
   public readonly reconnectQueue: ReconnectQueue
@@ -260,7 +261,6 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       events: components.events,
       logger: components.logger
     }, {
-      maxConnections: this.maxConnections,
       allow: init.allow?.map(a => multiaddr(a))
     })
 
@@ -423,6 +423,24 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     return this.maxConnections
   }
 
+  setMaxConnections (maxConnections: number): void {
+    if (this.maxConnections < 1) {
+      throw new InvalidParametersError('Connection Manager maxConnections must be greater than 0')
+    }
+
+    let needsPrune = false
+
+    if (maxConnections < this.maxConnections) {
+      needsPrune = true
+    }
+
+    this.maxConnections = maxConnections
+
+    if (needsPrune) {
+      this.connectionPruner.maybePruneConnections()
+    }
+  }
+
   onConnect (evt: CustomEvent<Connection>): void {
     void this._onConnect(evt).catch(err => {
       this.log.error(err)

package/src/connection-manager/reconnect-queue.ts

@@ -2,8 +2,9 @@ import { KEEP_ALIVE } from '@libp2p/interface'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import pRetry from 'p-retry'
 import { MAX_PARALLEL_RECONNECTS } from './constants.js'
-import type { ComponentLogger, Libp2pEvents, Logger, Metrics, Peer, PeerId, PeerStore, Startable, TypedEventTarget } from '@libp2p/interface'
+import type { ComponentLogger, Libp2pEvents, Logger, Metrics, Peer, PeerId, PeerStore, Startable } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
+import type { TypedEventTarget } from 'main-event'
 
 export interface ReconnectQueueComponents {
   connectionManager: ConnectionManager

package/src/connection-monitor.ts

@@ -1,7 +1,8 @@
 import { randomBytes } from '@libp2p/crypto'
-import { serviceCapabilities, setMaxListeners } from '@libp2p/interface'
+import { serviceCapabilities } from '@libp2p/interface'
 import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
 import { byteStream } from 'it-byte-stream'
+import { setMaxListeners } from 'main-event'
 import type { ComponentLogger, Logger, Metrics, Startable } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'

package/src/content-routing.ts

@@ -118,7 +118,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       if (peer.multiaddrs.length > 0) {
         await this.components.peerStore.merge(peer.id, {
           multiaddrs: peer.multiaddrs
-        })
+        }, options)
       }
 
       // deduplicate peers

package/src/libp2p.ts

@@ -1,11 +1,12 @@
 import { publicKeyFromProtobuf } from '@libp2p/crypto/keys'
-import { contentRoutingSymbol, TypedEventEmitter, setMaxListeners, peerDiscoverySymbol, peerRoutingSymbol, InvalidParametersError } from '@libp2p/interface'
+import { contentRoutingSymbol, peerDiscoverySymbol, peerRoutingSymbol, InvalidParametersError } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { persistentPeerStore } from '@libp2p/peer-store'
 import { isMultiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
+import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { AddressManager } from './address-manager/index.js'
@@ -86,16 +87,16 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       dns: init.dns
     })
 
-    this.peerStore = this.configureComponent('peerStore', persistentPeerStore(components, {
-      addressFilter: this.components.connectionGater.filterMultiaddrForPeer,
-      ...init.peerStore
-    }))
-
     // Create Metrics
     if (init.metrics != null) {
       this.metrics = this.configureComponent('metrics', init.metrics(this.components))
     }
 
+    this.peerStore = this.configureComponent('peerStore', persistentPeerStore(components, {
+      addressFilter: this.components.connectionGater.filterMultiaddrForPeer,
+      ...init.peerStore
+    }))
+
     components.events.addEventListener('peer:update', evt => {
       // if there was no peer previously in the peer store this is a new peer
       if (evt.detail.previous == null) {
@@ -340,7 +341,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     }
 
     try {
-      const peerInfo = await this.peerStore.get(peer)
+      const peerInfo = await this.peerStore.get(peer, options)
 
       if (peerInfo.id.publicKey != null) {
         return peerInfo.id.publicKey
@@ -364,7 +365,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
 
     await this.peerStore.patch(peer, {
       publicKey
-    })
+    }, options)
 
     return publicKey
   }
@@ -381,20 +382,20 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     )
   }
 
-  async unhandle (protocols: string[] | string): Promise<void> {
+  async unhandle (protocols: string[] | string, options?: AbortOptions): Promise<void> {
     if (!Array.isArray(protocols)) {
       protocols = [protocols]
     }
 
     await Promise.all(
       protocols.map(async protocol => {
-        await this.components.registrar.unhandle(protocol)
+        await this.components.registrar.unhandle(protocol, options)
       })
     )
   }
 
-  async register (protocol: string, topology: Topology): Promise<string> {
-    return this.components.registrar.register(protocol, topology)
+  async register (protocol: string, topology: Topology, options?: AbortOptions): Promise<string> {
+    return this.components.registrar.register(protocol, topology, options)
   }
 
   unregister (id: string): void {

package/src/peer-routing.ts

@@ -92,7 +92,7 @@ export class DefaultPeerRouting implements PeerRouting {
       if (peer.multiaddrs.length > 0) {
         await this.peerStore.merge(peer.id, {
           multiaddrs: peer.multiaddrs
-        })
+        }, options)
       }
 
       return peer
@@ -148,7 +148,7 @@ export class DefaultPeerRouting implements PeerRouting {
       if (peer.multiaddrs.length > 0) {
         await this.peerStore.merge(peer.id, {
           multiaddrs: peer.multiaddrs
-        })
+        }, options)
       }
 
       // deduplicate peers

package/src/random-walk.ts

@@ -1,6 +1,6 @@
 import { randomBytes } from '@libp2p/crypto'
-import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { anySignal } from 'any-signal'
+import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import pDefer from 'p-defer'
 import { raceEvent } from 'race-event'
 import { raceSignal } from 'race-signal'

package/src/registrar.ts

@@ -1,9 +1,11 @@
 import { InvalidParametersError } from '@libp2p/interface'
 import { mergeOptions } from '@libp2p/utils/merge-options'
+import { trackedMap } from '@libp2p/utils/tracked-map'
 import * as errorsJs from './errors.js'
-import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, TypedEventTarget, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions } from '@libp2p/interface'
+import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, PeerId, PeerStore, Topology, StreamHandler, StreamHandlerRecord, StreamHandlerOptions, AbortOptions, Metrics } from '@libp2p/interface'
 import type { Registrar as RegistrarInterface } from '@libp2p/interface-internal'
 import type { ComponentLogger } from '@libp2p/logger'
+import type { TypedEventTarget } from 'main-event'
 
 export const DEFAULT_MAX_INBOUND_STREAMS = 32
 export const DEFAULT_MAX_OUTBOUND_STREAMS = 64
@@ -13,6 +15,7 @@ export interface RegistrarComponents {
   peerStore: PeerStore
   events: TypedEventTarget<Libp2pEvents>
   logger: ComponentLogger
+  metrics?: Metrics
 }
 
 /**
@@ -25,10 +28,24 @@ export class Registrar implements RegistrarInterface {
   private readonly components: RegistrarComponents
 
   constructor (components: RegistrarComponents) {
+    this.components = components
     this.log = components.logger.forComponent('libp2p:registrar')
     this.topologies = new Map()
-    this.handlers = new Map()
-    this.components = components
+    components.metrics?.registerMetricGroup('libp2p_registrar_topologies', {
+      calculate: () => {
+        const output: Record<string, number> = {}
+
+        for (const [key, value] of this.topologies) {
+          output[key] = value.size
+        }
+
+        return output
+      }
+    })
+    this.handlers = trackedMap({
+      name: 'libp2p_registrar_protocol_handlers',
+      metrics: components.metrics
+    })
 
     this._onDisconnect = this._onDisconnect.bind(this)
     this._onPeerUpdate = this._onPeerUpdate.bind(this)
@@ -90,14 +107,14 @@ export class Registrar implements RegistrarInterface {
     // Add new protocol to self protocols in the peer store
     await this.components.peerStore.merge(this.components.peerId, {
       protocols: [protocol]
-    })
+    }, opts)
   }
 
   /**
    * Removes the handler for each protocol. The protocol
    * will no longer be supported on streams.
    */
-  async unhandle (protocols: string | string[]): Promise<void> {
+  async unhandle (protocols: string | string[], options?: AbortOptions): Promise<void> {
     const protocolList = Array.isArray(protocols) ? protocols : [protocols]
 
     protocolList.forEach(protocol => {
@@ -107,7 +124,7 @@ export class Registrar implements RegistrarInterface {
     // Update self protocols in the peer store
     await this.components.peerStore.patch(this.components.peerId, {
       protocols: this.getProtocols()
-    })
+    }, options)
   }
 
   /**
@@ -153,8 +170,11 @@ export class Registrar implements RegistrarInterface {
    */
   _onDisconnect (evt: CustomEvent<PeerId>): void {
     const remotePeer = evt.detail
+    const options = {
+      signal: AbortSignal.timeout(5_000)
+    }
 
-    void this.components.peerStore.get(remotePeer)
+    void this.components.peerStore.get(remotePeer, options)
       .then(peer => {
         for (const protocol of peer.protocols) {
           const topologies = this.topologies.get(protocol)

package/src/transport-manager.ts

@@ -3,9 +3,10 @@ import { trackedMap } from '@libp2p/utils/tracked-map'
 import { IP4, IP6 } from '@multiformats/multiaddr-matcher'
 import { CustomProgressEvent } from 'progress-events'
 import { TransportUnavailableError, UnsupportedListenAddressError, UnsupportedListenAddressesError } from './errors.js'
-import type { Libp2pEvents, ComponentLogger, Logger, Connection, TypedEventTarget, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
+import type { Libp2pEvents, ComponentLogger, Logger, Connection, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
 import type { AddressManager, TransportManager, TransportManagerDialOptions } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
+import type { TypedEventTarget } from 'main-event'
 
 export interface TransportManagerInit {
   faultTolerance?: FaultTolerance
@@ -42,7 +43,10 @@ export class DefaultTransportManager implements TransportManager, Startable {
     this.log = components.logger.forComponent('libp2p:transports')
     this.components = components
     this.started = false
-    this.transports = new Map<string, Transport>()
+    this.transports = trackedMap({
+      name: 'libp2p_transport_manager_transports',
+      metrics: this.components.metrics
+    })
     this.listeners = trackedMap({
       name: 'libp2p_transport_manager_listeners',
       metrics: this.components.metrics

package/src/upgrader.ts

@@ -1,14 +1,18 @@
-import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, setMaxListeners, InvalidPeerIdError } from '@libp2p/interface'
+import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, InvalidPeerIdError } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
+import { trackedMap } from '@libp2p/utils/tracked-map'
 import { anySignal } from 'any-signal'
+import { setMaxListeners } from 'main-event'
 import { CustomProgressEvent } from 'progress-events'
+import { raceSignal } from 'race-signal'
 import { createConnection } from './connection/index.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 as UpgraderInterface, UpgraderOptions, ConnectionLimits, SecureConnectionOptions, CounterGroup, ClearableSignal } from '@libp2p/interface'
+import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions, ConnectionEncrypter, SecuredConnection, ConnectionGater, Metrics, PeerId, PeerStore, StreamMuxer, StreamMuxerFactory, Upgrader as UpgraderInterface, UpgraderOptions, ConnectionLimits, SecureConnectionOptions, CounterGroup, ClearableSignal } from '@libp2p/interface'
 import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
+import type { TypedEventTarget } from 'main-event'
 
 interface CreateConnectionOptions {
   cryptoProtocol: string
@@ -125,17 +129,25 @@ export class Upgrader implements UpgraderInterface {
   private readonly metrics: {
     dials?: CounterGroup<'inbound' | 'outbound'>
     errors?: CounterGroup<'inbound' | 'outbound'>
+    inboundErrors?: CounterGroup
+    outboundErrors?: CounterGroup
   }
 
   constructor (components: UpgraderComponents, init: UpgraderInit) {
     this.components = components
-    this.connectionEncrypters = new Map()
+    this.connectionEncrypters = trackedMap({
+      name: 'libp2p_upgrader_connection_encrypters',
+      metrics: this.components.metrics
+    })
 
     init.connectionEncrypters.forEach(encrypter => {
       this.connectionEncrypters.set(encrypter.protocol, encrypter)
     })
 
-    this.streamMuxers = new Map()
+    this.streamMuxers = trackedMap({
+      name: 'libp2p_upgrader_stream_multiplexers',
+      metrics: this.components.metrics
+    })
 
     init.streamMuxers.forEach(muxer => {
       this.streamMuxers.set(muxer.protocol, muxer)
@@ -147,7 +159,9 @@ export class Upgrader implements UpgraderInterface {
     this.events = components.events
     this.metrics = {
       dials: components.metrics?.registerCounterGroup('libp2p_connection_manager_dials_total'),
-      errors: components.metrics?.registerCounterGroup('libp2p_connection_manager_dial_errors_total')
+      errors: components.metrics?.registerCounterGroup('libp2p_connection_manager_dial_errors_total'),
+      inboundErrors: components.metrics?.registerCounterGroup('libp2p_connection_manager_dials_inbound_errors_total'),
+      outboundErrors: components.metrics?.registerCounterGroup('libp2p_connection_manager_dials_outbound_errors_total')
     }
   }
 
@@ -193,22 +207,25 @@ export class Upgrader implements UpgraderInterface {
         inbound: true
       })
 
-      accepted = await this.components.connectionManager.acceptIncomingConnection(maConn)
+      accepted = await raceSignal(this.components.connectionManager.acceptIncomingConnection(maConn), signal)
 
       if (!accepted) {
         throw new ConnectionDeniedError('Connection denied')
       }
 
-      await this.shouldBlockConnection('denyInboundConnection', maConn)
+      await raceSignal(this.shouldBlockConnection('denyInboundConnection', maConn), signal)
 
       await this._performUpgrade(maConn, 'inbound', {
         ...opts,
         signal
       })
-    } catch (err) {
+    } catch (err: any) {
       this.metrics.errors?.increment({
         inbound: true
       })
+      this.metrics.inboundErrors?.increment({
+        [err.name ?? 'Error']: true
+      })
 
       throw err
     } finally {
@@ -234,7 +251,7 @@ export class Upgrader implements UpgraderInterface {
 
       if (idStr != null) {
         remotePeerId = peerIdFromString(idStr)
-        await this.shouldBlockConnection('denyOutboundConnection', remotePeerId, maConn)
+        await raceSignal(this.shouldBlockConnection('denyOutboundConnection', remotePeerId, maConn), opts.signal)
       }
 
       let direction: 'inbound' | 'outbound' = 'outbound'
@@ -245,10 +262,13 @@ export class Upgrader implements UpgraderInterface {
       }
 
       return await this._performUpgrade(maConn, direction, opts)
-    } catch (err) {
+    } catch (err: any) {
       this.metrics.errors?.increment({
         outbound: true
       })
+      this.metrics.outboundErrors?.increment({
+        [err.name ?? 'Error']: true
+      })
 
       throw err
     }
@@ -387,11 +407,12 @@ export class Upgrader implements UpgraderInterface {
             return
           }
 
+          const signal = AbortSignal.timeout(this.inboundStreamProtocolNegotiationTimeout)
+          setMaxListeners(Infinity, signal)
+
           void Promise.resolve()
             .then(async () => {
               const protocols = this.components.registrar.getProtocols()
-              const signal = AbortSignal.timeout(this.inboundStreamProtocolNegotiationTimeout)
-              setMaxListeners(Infinity, signal)
 
               const { stream, protocol } = await mss.handle(muxedStream, protocols, {
                 signal,
@@ -440,6 +461,8 @@ export class Upgrader implements UpgraderInterface {
               // the peer store should ensure that the peer is registered with that protocol
               await this.components.peerStore.merge(remotePeer, {
                 protocols: [protocol]
+              }, {
+                signal
               })
 
               this.components.metrics?.trackProtocolStream(muxedStream, connection)
@@ -450,7 +473,10 @@ export class Upgrader implements UpgraderInterface {
               connection.log.error('error handling incoming stream id %s - %e', muxedStream.id, err)
 
               if (muxedStream.timeline.close == null) {
-                await muxedStream.close()
+                await muxedStream.close({
+                  signal
+                })
+                  .catch(err => muxedStream.abort(err))
               }
             })
         }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.8.8'
+export const version = '2.8.9-6c42ea64a'
 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"
-}