libp2p 0.39.5 → 0.40.0

package/src/components.ts

@@ -0,0 +1,332 @@
+import errCode from 'err-code'
+import type { ConnectionGater, ConnectionProtector } from '@libp2p/interface-connection'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
+import type { AddressManager } from '@libp2p/interface-address-manager'
+import { isStartable, Startable } from '@libp2p/interfaces/startable'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { Registrar } from '@libp2p/interface-registrar'
+import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
+import type { Datastore } from 'interface-datastore'
+import type { PubSub } from '@libp2p/interface-pubsub'
+import type { DualDHT } from '@libp2p/interface-dht'
+import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
+
+export interface Components {
+  peerId: PeerId
+  addressManager: AddressManager
+  peerStore: PeerStore
+  upgrader: Upgrader
+  registrar: Registrar
+  connectionManager: ConnectionManager
+  transportManager: TransportManager
+  connectionGater: ConnectionGater
+  contentRouting: ContentRouting
+  peerRouting: PeerRouting
+  datastore: Datastore
+  connectionProtector?: ConnectionProtector
+  dialer: Dialer
+  metrics?: Metrics
+  dht?: DualDHT
+  pubsub?: PubSub
+}
+
+export interface ComponentsInit {
+  peerId?: PeerId
+  addressManager?: AddressManager
+  peerStore?: PeerStore
+  upgrader?: Upgrader
+  metrics?: Metrics
+  registrar?: Registrar
+  connectionManager?: ConnectionManager
+  transportManager?: TransportManager
+  connectionGater?: ConnectionGater
+  contentRouting?: ContentRouting
+  peerRouting?: PeerRouting
+  datastore?: Datastore
+  connectionProtector?: ConnectionProtector
+  dht?: DualDHT
+  pubsub?: PubSub
+  dialer?: Dialer
+}
+
+export class DefaultComponents implements Components, Startable {
+  private _peerId?: PeerId
+  private _addressManager?: AddressManager
+  private _peerStore?: PeerStore
+  private _upgrader?: Upgrader
+  private _metrics?: Metrics
+  private _registrar?: Registrar
+  private _connectionManager?: ConnectionManager
+  private _transportManager?: TransportManager
+  private _connectionGater?: ConnectionGater
+  private _contentRouting?: ContentRouting
+  private _peerRouting?: PeerRouting
+  private _datastore?: Datastore
+  private _connectionProtector?: ConnectionProtector
+  private _dht?: DualDHT
+  private _pubsub?: PubSub
+  private _dialer?: Dialer
+  private _started = false
+
+  constructor (init: ComponentsInit = {}) {
+    this._peerId = init.peerId
+    this._addressManager = init.addressManager
+    this._peerStore = init.peerStore
+    this._upgrader = init.upgrader
+    this._metrics = init.metrics
+    this._registrar = init.registrar
+    this._connectionManager = init.connectionManager
+    this._transportManager = init.transportManager
+    this._connectionGater = init.connectionGater
+    this._contentRouting = init.contentRouting
+    this._peerRouting = init.peerRouting
+    this._datastore = init.datastore
+    this._connectionProtector = init.connectionProtector
+    this._dht = init.dht
+    this._pubsub = init.pubsub
+    this._dialer = init.dialer
+  }
+
+  isStarted () {
+    return this._started
+  }
+
+  async beforeStart () {
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.beforeStart != null) {
+          await startable.beforeStart()
+        }
+      })
+    )
+  }
+
+  async start () {
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        await startable.start()
+      })
+    )
+
+    this._started = true
+  }
+
+  async afterStart () {
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.afterStart != null) {
+          await startable.afterStart()
+        }
+      })
+    )
+  }
+
+  async beforeStop () {
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.beforeStop != null) {
+          await startable.beforeStop()
+        }
+      })
+    )
+  }
+
+  async stop () {
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        await startable.stop()
+      })
+    )
+
+    this._started = false
+  }
+
+  async afterStop () {
+    await Promise.all(
+      Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
+        if (startable.afterStop != null) {
+          await startable.afterStop()
+        }
+      })
+    )
+  }
+
+  get peerId (): PeerId {
+    if (this._peerId == null) {
+      throw errCode(new Error('peerId not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._peerId
+  }
+
+  set peerId (peerId: PeerId) {
+    this._peerId = peerId
+  }
+
+  get addressManager (): AddressManager {
+    if (this._addressManager == null) {
+      throw errCode(new Error('addressManager not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._addressManager
+  }
+
+  set addressManager (addressManager: AddressManager) {
+    this._addressManager = addressManager
+  }
+
+  get peerStore (): PeerStore {
+    if (this._peerStore == null) {
+      throw errCode(new Error('peerStore not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._peerStore
+  }
+
+  set peerStore (peerStore: PeerStore) {
+    this._peerStore = peerStore
+  }
+
+  get upgrader (): Upgrader {
+    if (this._upgrader == null) {
+      throw errCode(new Error('upgrader not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._upgrader
+  }
+
+  set upgrader (upgrader: Upgrader) {
+    this._upgrader = upgrader
+  }
+
+  get registrar (): Registrar {
+    if (this._registrar == null) {
+      throw errCode(new Error('registrar not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._registrar
+  }
+
+  set registrar (registrar: Registrar) {
+    this._registrar = registrar
+  }
+
+  get connectionManager (): ConnectionManager {
+    if (this._connectionManager == null) {
+      throw errCode(new Error('connectionManager not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._connectionManager
+  }
+
+  set connectionManager (connectionManager: ConnectionManager) {
+    this._connectionManager = connectionManager
+  }
+
+  get transportManager (): TransportManager {
+    if (this._transportManager == null) {
+      throw errCode(new Error('transportManager not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._transportManager
+  }
+
+  set transportManager (transportManager: TransportManager) {
+    this._transportManager = transportManager
+  }
+
+  get connectionGater (): ConnectionGater {
+    if (this._connectionGater == null) {
+      throw errCode(new Error('connectionGater not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._connectionGater
+  }
+
+  set connectionGater (connectionGater: ConnectionGater) {
+    this._connectionGater = connectionGater
+  }
+
+  get contentRouting (): ContentRouting {
+    if (this._contentRouting == null) {
+      throw errCode(new Error('contentRouting not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._contentRouting
+  }
+
+  set contentRouting (contentRouting: ContentRouting) {
+    this._contentRouting = contentRouting
+  }
+
+  get peerRouting (): PeerRouting {
+    if (this._peerRouting == null) {
+      throw errCode(new Error('peerRouting not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._peerRouting
+  }
+
+  set peerRouting (peerRouting: PeerRouting) {
+    this._peerRouting = peerRouting
+  }
+
+  get datastore (): Datastore {
+    if (this._datastore == null) {
+      throw errCode(new Error('datastore not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._datastore
+  }
+
+  set datastore (datastore: Datastore) {
+    this._datastore = datastore
+  }
+
+  get connectionProtector (): ConnectionProtector | undefined {
+    return this._connectionProtector
+  }
+
+  set connectionProtector (connectionProtector: ConnectionProtector | undefined) {
+    this._connectionProtector = connectionProtector
+  }
+
+  get dialer (): Dialer {
+    if (this._dialer == null) {
+      throw errCode(new Error('dialer not set'), 'ERR_SERVICE_MISSING')
+    }
+
+    return this._dialer
+  }
+
+  set dialer (dialer: Dialer) {
+    this._dialer = dialer
+  }
+
+  get metrics (): Metrics | undefined {
+    return this._metrics
+  }
+
+  set metrics (metrics: Metrics | undefined) {
+    this._metrics = metrics
+  }
+
+  get dht (): DualDHT | undefined {
+    return this._dht
+  }
+
+  set dht (dht: DualDHT | undefined) {
+    this._dht = dht
+  }
+
+  get pubsub (): PubSub | undefined {
+    return this._pubsub
+  }
+
+  set pubsub (pubsub: PubSub | undefined) {
+    this._pubsub = pubsub
+  }
+}

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

@@ -7,7 +7,9 @@ import { pipe } from 'it-pipe'
 import filter from 'it-filter'
 import sort from 'it-sort'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 
 const log = logger('libp2p:connection-manager:auto-dialler')
 
@@ -28,6 +30,12 @@ export interface AutoDiallerInit {
   autoDialInterval?: number
 }
 
+export interface AutoDiallerComponents {
+  peerId: PeerId
+  connectionManager: ConnectionManager
+  peerStore: PeerStore
+}
+
 const defaultOptions: Partial<AutoDiallerInit> = {
   enabled: true,
   minConnections: 0,
@@ -35,7 +43,7 @@ const defaultOptions: Partial<AutoDiallerInit> = {
 }
 
 export class AutoDialler implements Startable {
-  private readonly components: Components
+  private readonly components: AutoDiallerComponents
   private readonly options: Required<AutoDiallerInit>
   private running: boolean
   private autoDialTimeout?: ReturnType<retimer>
@@ -45,7 +53,7 @@ export class AutoDialler implements Startable {
    * It will keep the number of connections below the upper limit and sort
    * the peers to connect based on wether we know their keys and protocols.
    */
-  constructor (components: Components, init: AutoDiallerInit) {
+  constructor (components: AutoDiallerComponents, init: AutoDiallerInit) {
     this.components = components
     this.options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, init)
     this.running = false
@@ -102,19 +110,19 @@ export class AutoDialler implements Startable {
     const minConnections = this.options.minConnections
 
     // Already has enough connections
-    if (this.components.getConnectionManager().getConnections().length >= minConnections) {
+    if (this.components.connectionManager.getConnections().length >= minConnections) {
       this.autoDialTimeout = retimer(this._autoDial, this.options.autoDialInterval)
 
       return
     }
 
     // Sort peers on whether we know protocols or public keys for them
-    const allPeers = await this.components.getPeerStore().all()
+    const allPeers = await this.components.peerStore.all()
 
     const peers = await pipe(
       // shuffle the peers
       allPeers.sort(() => Math.random() > 0.5 ? 1 : -1),
-      (source) => filter(source, (peer) => !peer.id.equals(this.components.getPeerId())),
+      (source) => filter(source, (peer) => !peer.id.equals(this.components.peerId)),
       (source) => sort(source, (a, b) => {
         if (b.protocols.length > a.protocols.length) {
           return 1
@@ -126,7 +134,7 @@ export class AutoDialler implements Startable {
       async (source) => await all(source)
     )
 
-    for (let i = 0; this.running && i < peers.length && this.components.getConnectionManager().getConnections().length < minConnections; i++) {
+    for (let i = 0; this.running && i < peers.length && this.components.connectionManager.getConnections().length < minConnections; i++) {
       // Connection Manager was stopped during async dial
       if (!this.running) {
         return
@@ -134,10 +142,10 @@ export class AutoDialler implements Startable {
 
       const peer = peers[i]
 
-      if (this.components.getConnectionManager().getConnections(peer.id).length === 0) {
+      if (this.components.connectionManager.getConnections(peer.id).length === 0) {
         log('connecting to a peerStore stored peer %p', peer.id)
         try {
-          await this.components.getConnectionManager().openConnection(peer.id)
+          await this.components.connectionManager.openConnection(peer.id)
         } catch (err: any) {
           log.error('could not connect to peerStore stored peer', err)
         }

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

@@ -19,17 +19,17 @@ import {
   MAX_PER_PEER_DIALS,
   MAX_ADDRS_TO_DIAL
 } from '../../constants.js'
-import type { Connection } from '@libp2p/interface-connection'
+import type { Connection, ConnectionGater } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import { getPeer } from '../../get-peer.js'
 import sort from 'it-sort'
-import type { Components } from '@libp2p/components'
 import map from 'it-map'
-import type { AddressSorter } from '@libp2p/interface-peer-store'
-import type { ComponentMetricsTracker } from '@libp2p/interface-metrics'
+import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
+import type { ComponentMetricsTracker, Metrics } from '@libp2p/interface-metrics'
 import type { Dialer } from '@libp2p/interface-connection-manager'
+import type { TransportManager } from '@libp2p/interface-transport'
 
 const log = logger('libp2p:dialer')
 
@@ -87,8 +87,16 @@ export interface DialerInit {
   metrics?: ComponentMetricsTracker
 }
 
+export interface DefaultDialerComponents {
+  peerId: PeerId
+  metrics?: Metrics
+  peerStore: PeerStore
+  transportManager: TransportManager
+  connectionGater: ConnectionGater
+}
+
 export class DefaultDialer implements Startable, Dialer {
-  private readonly components: Components
+  private readonly components: DefaultDialerComponents
   private readonly addressSorter: AddressSorter
   private readonly maxAddrsToDial: number
   private readonly timeout: number
@@ -98,7 +106,7 @@ export class DefaultDialer implements Startable, Dialer {
   public pendingDialTargets: Map<string, PendingDialTarget>
   private started: boolean
 
-  constructor (components: Components, init: DialerInit = {}) {
+  constructor (components: DefaultDialerComponents, init: DialerInit = {}) {
     this.started = false
     this.addressSorter = init.addressSorter ?? publicAddressesFirst
     this.maxAddrsToDial = init.maxAddrsToDial ?? MAX_ADDRS_TO_DIAL
@@ -114,7 +122,7 @@ export class DefaultDialer implements Startable, Dialer {
     this.pendingDialTargets = trackedMap({
       component: METRICS_COMPONENT,
       metric: METRICS_PENDING_DIAL_TARGETS,
-      metrics: components.getMetrics()
+      metrics: components.metrics
     })
 
     for (const [key, value] of Object.entries(init.resolvers ?? {})) {
@@ -159,7 +167,7 @@ export class DefaultDialer implements Startable, Dialer {
   async dial (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<Connection> {
     const { id, multiaddrs } = getPeer(peer)
 
-    if (this.components.getPeerId().equals(id)) {
+    if (this.components.peerId.equals(id)) {
       throw errCode(new Error('Tried to dial self'), codes.ERR_DIALED_SELF)
     }
 
@@ -167,10 +175,10 @@ export class DefaultDialer implements Startable, Dialer {
 
     if (multiaddrs != null && multiaddrs.length > 0) {
       log('storing multiaddrs %p', id, multiaddrs)
-      await this.components.getPeerStore().addressBook.add(id, multiaddrs)
+      await this.components.peerStore.addressBook.add(id, multiaddrs)
     }
 
-    if (await this.components.getConnectionGater().denyDialPeer(id)) {
+    if (await this.components.connectionGater.denyDialPeer(id)) {
       throw errCode(new Error('The dial request is blocked by gater.allowDialPeer'), codes.ERR_PEER_DIAL_INTERCEPTED)
     }
 
@@ -235,9 +243,9 @@ export class DefaultDialer implements Startable, Dialer {
     const _resolve = this._resolve.bind(this)
 
     const addrs = await pipe(
-      await this.components.getPeerStore().addressBook.get(peer),
+      await this.components.peerStore.addressBook.get(peer),
       (source) => filter(source, async (address) => {
-        return !(await this.components.getConnectionGater().denyDialMultiaddr(peer, address.multiaddr))
+        return !(await this.components.connectionGater.denyDialMultiaddr(peer, address.multiaddr))
       }),
       // Sort addresses so, for example, we try certified public address first
       (source) => sort(source, this.addressSorter),
@@ -247,7 +255,7 @@ export class DefaultDialer implements Startable, Dialer {
         }
       },
       // Multiaddrs not supported by the available transports will be filtered out.
-      (source) => filter(source, (ma) => Boolean(this.components.getTransportManager().transportForMultiaddr(ma))),
+      (source) => filter(source, (ma) => Boolean(this.components.transportManager.transportForMultiaddr(ma))),
       (source) => map(source, (ma) => {
         if (peer.toString() === ma.getPeerId()) {
           return ma
@@ -259,7 +267,7 @@ export class DefaultDialer implements Startable, Dialer {
     )
 
     if (addrs.length > this.maxAddrsToDial) {
-      await this.components.getPeerStore().delete(peer)
+      await this.components.peerStore.delete(peer)
       throw errCode(new Error('dial with more addresses than allowed'), codes.ERR_TOO_MANY_ADDRESSES)
     }
 
@@ -282,7 +290,7 @@ export class DefaultDialer implements Startable, Dialer {
         throw errCode(new Error('already aborted'), codes.ERR_ALREADY_ABORTED)
       }
 
-      return await this.components.getTransportManager().dial(addr, options).catch(err => {
+      return await this.components.transportManager.dial(addr, options).catch(err => {
         log.error('dial to %s failed', addr, err)
         throw err
       })