libp2p 2.8.8 → 2.8.9

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'
 export const name = 'js-libp2p'