libp2p 0.40.0 → 0.41.0

package/src/connection-manager/index.ts

@@ -2,8 +2,6 @@ import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
 import mergeOptions from 'merge-options'
 import { LatencyMonitor, SummaryObject } from './latency-monitor.js'
-// @ts-expect-error retimer does not have types
-import retimer from 'retimer'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
@@ -14,13 +12,14 @@ import type { Connection, MultiaddrConnection } from '@libp2p/interface-connecti
 import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
 import * as STATUS from '@libp2p/interface-connection/status'
 import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
-import { multiaddr, Multiaddr, Resolver } from '@multiformats/multiaddr'
+import { isMultiaddr, multiaddr, Multiaddr, Resolver } from '@multiformats/multiaddr'
 import { PeerMap } from '@libp2p/peer-collections'
 import { TimeoutController } from 'timeout-abort-controller'
 import { KEEP_ALIVE } from '@libp2p/interface-peer-store/tags'
 import { RateLimiterMemory } from 'rate-limiter-flexible'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { Upgrader } from '@libp2p/interface-transport'
+import { getPeer } from '../get-peer.js'
 
 const log = logger('libp2p:connection-manager')
 
@@ -38,8 +37,6 @@ const defaultOptions: Partial<ConnectionManagerInit> = {
   maxIncomingPendingConnections: 10
 }
 
-const METRICS_SYSTEM = 'libp2p'
-const METRICS_COMPONENT = 'connection-manager'
 const STARTUP_RECONNECT_TIMEOUT = 60000
 
 export interface ConnectionManagerInit {
@@ -183,7 +180,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   private readonly opts: Required<ConnectionManagerInit>
   private readonly connections: Map<string, Connection[]>
   private started: boolean
-  private timer?: ReturnType<retimer>
   private readonly latencyMonitor: LatencyMonitor
   private readonly startupReconnectTimeout: number
   private connectOnStartupController?: TimeoutController
@@ -212,7 +208,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.connections = new Map()
 
     this.started = false
-    this._checkMetrics = this._checkMetrics.bind(this)
 
     this.latencyMonitor = new LatencyMonitor({
       latencyCheckIntervalMs: init.pollInterval,
@@ -250,17 +245,9 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
    * only event loop and connection limits will be monitored.
    */
   async start () {
-    if (this.components.metrics != null) {
-      this.timer = this.timer ?? retimer(this._checkMetrics, this.opts.pollInterval)
-    }
-
     // track inbound/outbound connections
-    this.components.metrics?.updateComponentMetric({
-      system: METRICS_SYSTEM,
-      component: METRICS_COMPONENT,
-      metric: 'connections',
-      label: 'direction',
-      value: () => {
+    this.components.metrics?.registerMetricGroup('libp2p_connection_manager_connections', {
+      calculate: () => {
         const metric = {
           inbound: 0,
           outbound: 0
@@ -281,12 +268,9 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     })
 
     // track total number of streams per protocol
-    this.components.metrics?.updateComponentMetric({
-      system: METRICS_SYSTEM,
-      component: METRICS_COMPONENT,
-      metric: 'protocol-streams-total',
+    this.components.metrics?.registerMetricGroup('libp2p_protocol_streams_total', {
       label: 'protocol',
-      value: () => {
+      calculate: () => {
         const metric: Record<string, number> = {}
 
         for (const conns of this.connections.values()) {
@@ -304,12 +288,9 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     })
 
     // track 90th percentile of streams per protocol
-    this.components.metrics?.updateComponentMetric({
-      system: METRICS_SYSTEM,
-      component: METRICS_COMPONENT,
-      metric: 'protocol-streams-per-connection-90th-percentile',
+    this.components.metrics?.registerMetricGroup('libp2p_connection_manager_protocol_streams_per_connection_90th_percentile', {
       label: 'protocol',
-      value: () => {
+      calculate: () => {
         const allStreams: Record<string, number[]> = {}
 
         for (const conns of this.connections.values()) {
@@ -407,8 +388,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
    * Stops the Connection Manager
    */
   async stop () {
-    this.timer?.clear()
-
     this.latencyMonitor.removeEventListener('data', this._onLatencyMeasure)
     this.latencyMonitor.stop()
 
@@ -440,31 +419,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.connections.clear()
   }
 
-  /**
-   * Checks the libp2p metrics to determine if any values have exceeded
-   * the configured maximums.
-   *
-   * @private
-   */
-  async _checkMetrics () {
-    const metrics = this.components.metrics
-
-    if (metrics != null) {
-      try {
-        const movingAverages = metrics.getGlobal().getMovingAverages()
-        const received = movingAverages.dataReceived[this.opts.movingAverageInterval].movingAverage
-        await this._checkMaxLimit('maxReceivedData', received)
-        const sent = movingAverages.dataSent[this.opts.movingAverageInterval].movingAverage
-        await this._checkMaxLimit('maxSentData', sent)
-        const total = received + sent
-        await this._checkMaxLimit('maxData', total)
-        log.trace('metrics update', total)
-      } finally {
-        this.timer = retimer(this._checkMetrics, this.opts.pollInterval)
-      }
-    }
-  }
-
   onConnect (evt: CustomEvent<Connection>) {
     void this._onConnect(evt).catch(err => {
       log.error(err)
@@ -524,8 +478,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     } else if (storedConn != null) {
       this.connections.delete(peerId)
       this.dispatchEvent(new CustomEvent<Connection>('peer:disconnect', { detail: connection }))
-
-      this.components.metrics?.onPeerDisconnected(connection.remotePeer)
     }
   }
 
@@ -543,7 +495,18 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     return conns
   }
 
-  async openConnection (peerId: PeerId, options: AbortOptions = {}): Promise<Connection> {
+  async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr, options: AbortOptions = {}): Promise<Connection> {
+    let peerId: PeerId
+
+    if (isPeerId(peerIdOrMultiaddr)) {
+      peerId = peerIdOrMultiaddr
+    } else if (isMultiaddr(peerIdOrMultiaddr)) {
+      const info = getPeer(peerIdOrMultiaddr)
+      peerId = info.id
+    } else {
+      throw errCode(new TypeError('Can only open connections to PeerIds or Multiaddrs'), codes.ERR_INVALID_PARAMETERS)
+    }
+
     log('dial to %p', peerId)
     const existingConnections = this.getConnections(peerId)
 
@@ -566,7 +529,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     }
 
     try {
-      const connection = await this.components.dialer.dial(peerId, options)
+      const connection = await this.components.dialer.dial(peerIdOrMultiaddr, options)
       let peerConnections = this.connections.get(peerId.toString())
 
       if (peerConnections == null) {

package/src/fetch/index.ts

@@ -14,6 +14,8 @@ import { pipe } from 'it-pipe'
 import first from 'it-first'
 import { TimeoutController } from 'timeout-abort-controller'
 import { setMaxListeners } from 'events'
+import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8arrayToString } from 'uint8arrays/to-string'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 
 const log = logger('libp2p:fetch')
@@ -103,6 +105,7 @@ export class FetchService implements Startable {
 
     // create a timeout if no abort signal passed
     if (signal == null) {
+      log('using default timeout of %d ms', this.init.timeout)
       timeoutController = new TimeoutController(this.init.timeout)
       signal = timeoutController.signal
 
@@ -113,13 +116,15 @@ export class FetchService implements Startable {
     }
 
     try {
-      stream = await connection.newStream([this.protocol], {
+      stream = await connection.newStream(this.protocol, {
         signal
       })
 
       // make stream abortable
       const source = abortableDuplex(stream, signal)
 
+      log('fetch %s', key)
+
       const result = await pipe(
         [FetchRequest.encode({ identifier: key })],
         lp.encode(),
@@ -136,16 +141,20 @@ export class FetchService implements Startable {
 
           switch (response.status) {
             case (FetchResponse.StatusCode.OK): {
+              log('received status for %s ok', key)
               return response.data
             }
             case (FetchResponse.StatusCode.NOT_FOUND): {
+              log('received status for %s not found', key)
               return null
             }
             case (FetchResponse.StatusCode.ERROR): {
-              const errmsg = (new TextDecoder()).decode(response.data)
+              log('received status for %s error', key)
+              const errmsg = uint8arrayToString(response.data)
               throw errCode(new Error('Error in fetch protocol response: ' + errmsg), codes.ERR_INVALID_PARAMETERS)
             }
             default: {
+              log('received status for %s unknown', key)
               throw errCode(new Error('Unknown response status'), codes.ERR_INVALID_MESSAGE)
             }
           }
@@ -189,14 +198,18 @@ export class FetchService implements Startable {
         let response: FetchResponse
         const lookup = self._getLookupFunction(request.identifier)
         if (lookup != null) {
+          log('look up data with identifier %s', request.identifier)
           const data = await lookup(request.identifier)
           if (data != null) {
+            log('sending status for %s ok', request.identifier)
             response = { status: FetchResponse.StatusCode.OK, data }
           } else {
+            log('sending status for %s not found', request.identifier)
             response = { status: FetchResponse.StatusCode.NOT_FOUND, data: new Uint8Array(0) }
           }
         } else {
-          const errmsg = (new TextEncoder()).encode('No lookup function registered for key: ' + request.identifier)
+          log('sending status for %s error', request.identifier)
+          const errmsg = uint8arrayFromString(`No lookup function registered for key: ${request.identifier}`)
           response = { status: FetchResponse.StatusCode.ERROR, data: errmsg }
         }
 

package/src/get-peer.ts

@@ -1,6 +1,6 @@
 import { peerIdFromString } from '@libp2p/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import { multiaddr, isMultiaddr } from '@multiformats/multiaddr'
+import { isMultiaddr } from '@multiformats/multiaddr'
 import errCode from 'err-code'
 import { codes } from './errors.js'
 import { isPeerId } from '@libp2p/interface-peer-id'
@@ -28,9 +28,9 @@ function peerIdFromMultiaddr (ma: Multiaddr) {
 }
 
 /**
- * Converts the given `peer` to a `Peer` object.
+ * Converts the given `peer` to a `PeerInfo` object.
  */
-export function getPeer (peer: PeerId | Multiaddr | string): PeerInfo {
+export function getPeer (peer: PeerId | Multiaddr): PeerInfo {
   if (isPeerId(peer)) {
     return {
       id: peer,
@@ -39,10 +39,6 @@ export function getPeer (peer: PeerId | Multiaddr | string): PeerInfo {
     }
   }
 
-  if (typeof peer === 'string') {
-    peer = multiaddr(peer)
-  }
-
   let addr
 
   if (isMultiaddr(peer)) {

package/src/index.ts

@@ -20,7 +20,7 @@ import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { PubSub } from '@libp2p/interface-pubsub'
 import type { Registrar, StreamHandler, StreamHandlerOptions } from '@libp2p/interface-registrar'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Metrics, MetricsInit } from '@libp2p/interface-metrics'
+import type { Metrics } from '@libp2p/interface-metrics'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { KeyChain } from './keychain/index.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
@@ -104,7 +104,6 @@ export interface Libp2pInit {
   connectionGater: Partial<ConnectionGater>
   transportManager: TransportManagerConfig
   datastore: Datastore
-  metrics: MetricsInit
   peerStore: PeerStoreInit
   peerRouting: PeerRoutingConfig
   keychain: KeychainConfig
@@ -121,6 +120,7 @@ export interface Libp2pInit {
   peerRouters?: Array<(components: Components) => PeerRouting>
   contentRouters?: Array<(components: Components) => ContentRouting>
   dht?: (components: Components) => DualDHT
+  metrics?: (components: Components) => Metrics
   pubsub?: (components: Components) => PubSub
   connectionProtector?: (components: Components) => ConnectionProtector
 }
@@ -178,7 +178,7 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
   /**
    * Disconnects all connections to the given `peer`
    */
-  hangUp: (peer: PeerId | Multiaddr | string) => Promise<void>
+  hangUp: (peer: PeerId | Multiaddr) => Promise<void>
 
   /**
    * Registers the `handler` for each protocol
@@ -194,12 +194,12 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
   /**
    * Pings the given peer in order to obtain the operation latency
    */
-  ping: (peer: Multiaddr | PeerId, options?: AbortOptions) => Promise<number>
+  ping: (peer: PeerId | Multiaddr, options?: AbortOptions) => Promise<number>
 
   /**
    * Sends a request to fetch the value associated with the given key from the given peer.
    */
-  fetch: (peer: PeerId | Multiaddr | string, key: string, options?: AbortOptions) => Promise<Uint8Array | null>
+  fetch: (peer: PeerId | Multiaddr, key: string, options?: AbortOptions) => Promise<Uint8Array | null>
 
   /**
    * Returns the public key for the passed PeerId. If the PeerId is of the 'RSA' type
@@ -208,12 +208,20 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
   getPublicKey: (peer: PeerId, options?: AbortOptions) => Promise<Uint8Array>
 }
 
-export type Libp2pOptions = RecursivePartial<Libp2pInit>
+export type Libp2pOptions = RecursivePartial<Libp2pInit> & { start?: boolean }
 
 /**
  * Returns a new instance of the Libp2p interface, generating a new PeerId
  * if one is not passed as part of the options.
+ *
+ * The node will be started unless `start: false` is passed as an option.
  */
 export async function createLibp2p (options: Libp2pOptions): Promise<Libp2p> {
-  return await createLibp2pNode(options)
+  const node = await createLibp2pNode(options)
+
+  if (options.start !== false) {
+    await node.start()
+  }
+
+  return node
 }

package/src/keychain/index.ts

@@ -118,7 +118,7 @@ export interface KeyChainComponents {
  */
 export class KeyChain implements Startable {
   private readonly components: KeyChainComponents
-  private init: KeyChainInit
+  private readonly init: KeyChainInit
   private started: boolean
 
   /**

package/src/libp2p.ts

@@ -14,7 +14,6 @@ import { AutoDialler } from './connection-manager/auto-dialler.js'
 import { Circuit } from './circuit/transport.js'
 import { Relay } from './circuit/index.js'
 import { KeyChain } from './keychain/index.js'
-import { DefaultMetrics } from './metrics/index.js'
 import { DefaultTransportManager } from './transport-manager.js'
 import { DefaultUpgrader } from './upgrader.js'
 import { DefaultRegistrar } from './registrar.js'
@@ -103,8 +102,8 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     ]
 
     // Create Metrics
-    if (init.metrics.enabled) {
-      this.metrics = this.components.metrics = new DefaultMetrics(init.metrics)
+    if (init.metrics != null) {
+      this.metrics = this.components.metrics = this.configureComponent(init.metrics(this.components))
     }
 
     this.peerStore = this.components.peerStore
@@ -374,7 +373,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return this.components.addressManager.getAddresses()
   }
 
-  async hangUp (peer: PeerId | Multiaddr | string): Promise<void> {
+  async hangUp (peer: PeerId | Multiaddr): Promise<void> {
     const { id } = getPeer(peer)
 
     await this.components.connectionManager.closeConnections(id)
@@ -419,7 +418,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     throw errCode(new Error(`Node not responding with its public key: ${peer.toString()}`), codes.ERR_INVALID_RECORD)
   }
 
-  async fetch (peer: PeerId | Multiaddr | string, key: string, options: AbortOptions = {}): Promise<Uint8Array | null> {
+  async fetch (peer: PeerId | Multiaddr, key: string, options: AbortOptions = {}): Promise<Uint8Array | null> {
     const { id, multiaddrs } = getPeer(peer)
 
     if (multiaddrs != null) {
@@ -429,7 +428,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return await this.fetchService.fetch(id, key, options)
   }
 
-  async ping (peer: PeerId | Multiaddr | string, options: AbortOptions = {}): Promise<number> {
+  async ping (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<number> {
     const { id, multiaddrs } = getPeer(peer)
 
     if (multiaddrs.length > 0) {

package/src/registrar.ts

@@ -35,8 +35,10 @@ export class DefaultRegistrar implements Registrar {
 
     this._onDisconnect = this._onDisconnect.bind(this)
     this._onProtocolChange = this._onProtocolChange.bind(this)
+    this._onConnect = this._onConnect.bind(this)
 
     this.components.connectionManager.addEventListener('peer:disconnect', this._onDisconnect)
+    this.components.connectionManager.addEventListener('peer:connect', this._onConnect)
 
     // happens after identify
     this.components.peerStore.addEventListener('change:protocols', this._onProtocolChange)
@@ -176,12 +178,38 @@ export class DefaultRegistrar implements Registrar {
       })
   }
 
+  /**
+   * On peer connected if we already have their protocols. Usually used for reconnects
+   * as change:protocols event won't be emitted due to identical protocols.
+   */
+  _onConnect (evt: CustomEvent<Connection>) {
+    const connection = evt.detail
+
+    void this.components.peerStore.protoBook.get(connection.remotePeer)
+      .then(peerProtocols => {
+        for (const protocol of peerProtocols) {
+          const topologies = this.topologies.get(protocol)
+
+          if (topologies == null) {
+            // no topologies are interested in this protocol
+            continue
+          }
+
+          for (const topology of topologies.values()) {
+            topology.onConnect(connection.remotePeer, connection)
+          }
+        }
+      })
+      .catch(err => {
+        log.error(err)
+      })
+  }
+
   /**
    * Check if a new peer support the multicodecs for this topology
    */
   _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>) {
     const { peerId, protocols, oldProtocols } = evt.detail
-
     const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
     const added = protocols.filter(protocol => !oldProtocols.includes(protocol))
 
@@ -212,7 +240,6 @@ export class DefaultRegistrar implements Registrar {
         if (connection == null) {
           continue
         }
-
         topology.onConnect(peerId, connection)
       }
     }

package/src/transport-manager.ts

@@ -38,8 +38,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     this.started = false
     this.transports = new Map<string, Transport>()
     this.listeners = trackedMap({
-      component: 'transport-manager',
-      metric: 'listeners',
+      name: 'libp2p_transport_manager_listeners',
       metrics: this.components.metrics
     })
     this.faultTolerance = init.faultTolerance ?? FaultTolerance.FATAL_ALL