libp2p 0.43.4 → 0.44.0-0d46c78f

package/src/libp2p.ts

@@ -1,7 +1,6 @@
 import { logger } from '@libp2p/logger'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
-import { Startable, isStartable } from '@libp2p/interfaces/startable'
 import { isMultiaddr, Multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { DefaultPeerRouting } from './peer-routing.js'
@@ -9,256 +8,199 @@ import { CompoundContentRouting } from './content-routing/index.js'
 import { codes } from './errors.js'
 import { DefaultAddressManager } from './address-manager/index.js'
 import { DefaultConnectionManager } from './connection-manager/index.js'
-import { AutoDialler } from './connection-manager/auto-dialler.js'
 import { DefaultKeyChain } from '@libp2p/keychain'
 import { DefaultTransportManager } from './transport-manager.js'
 import { DefaultUpgrader } from './upgrader.js'
 import { DefaultRegistrar } from './registrar.js'
-import { IdentifyService } from './identify/index.js'
-import { FetchService } from './fetch/index.js'
-import { PingService } from './ping/index.js'
-import { NatManager } from './nat-manager.js'
-import { PeerRecordUpdater } from './peer-record-updater.js'
-import { DHTPeerRouting } from './dht/dht-peer-routing.js'
 import { PersistentPeerStore } from '@libp2p/peer-store'
-import { DHTContentRouting } from './dht/dht-content-routing.js'
-import { AutonatService } from './autonat/index.js'
-import { DefaultComponents } from './components.js'
+import { defaultComponents } from './components.js'
 import type { Components } from './components.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { PubSub } from '@libp2p/interface-pubsub'
-import type { Registrar, StreamHandler, StreamHandlerOptions, Topology } from '@libp2p/interface-registrar'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { StreamHandler, StreamHandlerOptions, Topology } from '@libp2p/interface-registrar'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { Libp2p, Libp2pEvents, Libp2pInit, Libp2pOptions } from './index.js'
-import { validateConfig } from './config.js'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import type { Libp2p, Libp2pInit, Libp2pOptions } from './index.js'
 import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { DualDHT } from '@libp2p/interface-dht'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { CodeError } from '@libp2p/interfaces/errors'
-import { unmarshalPublicKey } from '@libp2p/crypto/keys'
 import type { Metrics } from '@libp2p/interface-metrics'
-import { DummyDHT } from './dht/dummy-dht.js'
-import { DummyPubSub } from './pubsub/dummy-pubsub.js'
 import { PeerSet } from '@libp2p/peer-collections'
-import { DefaultDialer } from './connection-manager/dialer/index.js'
+import type { KeyChain } from '@libp2p/interface-keychain'
+import type { Libp2pEvents, PendingDial, ServiceMap } from '@libp2p/interface-libp2p'
+import { setMaxListeners } from 'events'
+import { unmarshalPublicKey } from '@libp2p/crypto/keys'
 import { peerIdFromString } from '@libp2p/peer-id'
 import type { Datastore } from 'interface-datastore'
-import type { KeyChain } from '@libp2p/interface-keychain'
 import mergeOptions from 'merge-options'
-import type { CircuitRelayService } from './circuit-relay/index.js'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { validateConfig } from './config.js'
+import { ContentRouting, contentRouting } from '@libp2p/interface-content-routing'
+import { PeerRouting, peerRouting } from '@libp2p/interface-peer-routing'
+import { peerDiscovery } from '@libp2p/interface-peer-discovery'
+import { connectionGater } from './config/connection-gater.js'
 
 const log = logger('libp2p')
 
-export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
+export class Libp2pNode<T extends ServiceMap = {}> extends EventEmitter<Libp2pEvents> implements Libp2p<T> {
   public peerId: PeerId
-  public dht: DualDHT
-  public pubsub: PubSub
-  public identifyService: IdentifyService
-  public circuitService?: CircuitRelayService
-  public fetchService: FetchService
-  public pingService: PingService
-  public autonatService: AutonatService
-  public components: Components
   public peerStore: PeerStore
   public contentRouting: ContentRouting
   public peerRouting: PeerRouting
   public keychain: KeyChain
-  public connectionManager: ConnectionManager
-  public registrar: Registrar
   public metrics?: Metrics
+  public services: T
 
-  private started: boolean
-  private readonly services: Startable[]
+  public components: Components
+  #started: boolean
 
-  constructor (init: Libp2pInit) {
+  constructor (init: Libp2pInit<T>) {
     super()
 
-    this.started = false
+    // event bus - components can listen to this emitter to be notified of system events
+    // and also cause them to be emitted
+    const events = new EventEmitter<Libp2pEvents>()
+    const originalDispatch = events.dispatchEvent.bind(events)
+    events.dispatchEvent = (evt: any) => {
+      const internalResult = originalDispatch(evt)
+      const externalResult = this.dispatchEvent(
+        new CustomEvent(evt.type, { detail: evt.detail })
+      )
+
+      return internalResult || externalResult
+    }
+
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, events)
+    } catch {}
+
+    this.#started = false
     this.peerId = init.peerId
-    const components = this.components = new DefaultComponents({
+    // @ts-expect-error {} may not be of type T
+    this.services = {}
+    const components = this.components = defaultComponents({
       peerId: init.peerId,
+      events,
       datastore: init.datastore ?? new MemoryDatastore(),
-      connectionGater: {
-        denyDialPeer: async () => await Promise.resolve(false),
-        denyDialMultiaddr: async () => await Promise.resolve(false),
-        denyInboundConnection: async () => await Promise.resolve(false),
-        denyOutboundConnection: async () => await Promise.resolve(false),
-        denyInboundEncryptedConnection: async () => await Promise.resolve(false),
-        denyOutboundEncryptedConnection: async () => await Promise.resolve(false),
-        denyInboundUpgradedConnection: async () => await Promise.resolve(false),
-        denyOutboundUpgradedConnection: async () => await Promise.resolve(false),
-        filterMultiaddrForPeer: async () => await Promise.resolve(true),
-        ...init.connectionGater
-      }
+      connectionGater: connectionGater(init.connectionGater)
     })
-    components.peerStore = new PersistentPeerStore(components, {
+
+    this.peerStore = this.configureComponent('peerStore', new PersistentPeerStore(components, {
       addressFilter: this.components.connectionGater.filterMultiaddrForPeer,
       ...init.peerStore
-    })
-
-    this.services = [
-      components
-    ]
+    }))
 
     // Create Metrics
     if (init.metrics != null) {
-      this.metrics = this.components.metrics = this.configureComponent(init.metrics(this.components))
+      this.metrics = this.configureComponent('metrics', init.metrics(this.components))
     }
 
-    this.peerStore = this.components.peerStore
-
-    this.peerStore.addEventListener('peer', evt => {
-      const { detail: peerData } = evt
-
-      this.dispatchEvent(new CustomEvent<PeerInfo>('peer:discovery', { detail: peerData }))
+    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) {
+        this.safeDispatchEvent('peer:discovery', { detail: evt.detail.peer })
+      }
     })
 
     // Set up connection protector if configured
     if (init.connectionProtector != null) {
-      this.components.connectionProtector = init.connectionProtector(components)
+      this.configureComponent('connectionProtector', init.connectionProtector(components))
     }
 
     // Set up the Upgrader
     this.components.upgrader = new DefaultUpgrader(this.components, {
-      connectionEncryption: (init.connectionEncryption ?? []).map(fn => this.configureComponent(fn(this.components))),
-      muxers: (init.streamMuxers ?? []).map(fn => this.configureComponent(fn(this.components))),
+      connectionEncryption: (init.connectionEncryption ?? []).map((fn, index) => this.configureComponent(`connection-encryption-${index}`, fn(this.components))),
+      muxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
       inboundUpgradeTimeout: init.connectionManager.inboundUpgradeTimeout
     })
 
-    // Create the dialer
-    this.components.dialer = new DefaultDialer(this.components, init.connectionManager)
+    // Setup the transport manager
+    this.configureComponent('transportManager', new DefaultTransportManager(this.components, init.transportManager))
 
     // Create the Connection Manager
-    this.connectionManager = this.components.connectionManager = new DefaultConnectionManager(this.components, init.connectionManager)
-
-    // forward connection manager events
-    this.components.connectionManager.addEventListener('peer:disconnect', (event) => {
-      this.dispatchEvent(new CustomEvent<Connection>('peer:disconnect', { detail: event.detail }))
-    })
-    this.components.connectionManager.addEventListener('peer:connect', (event) => {
-      this.dispatchEvent(new CustomEvent<Connection>('peer:connect', { detail: event.detail }))
-    })
+    this.configureComponent('connectionManager', new DefaultConnectionManager(this.components, init.connectionManager))
 
     // Create the Registrar
-    this.registrar = this.components.registrar = new DefaultRegistrar(this.components)
-
-    // Setup the transport manager
-    this.components.transportManager = new DefaultTransportManager(this.components, init.transportManager)
+    this.configureComponent('registrar', new DefaultRegistrar(this.components))
 
     // Addresses {listen, announce, noAnnounce}
-    this.components.addressManager = new DefaultAddressManager(this.components, init.addresses)
-
-    // update our peer record when addresses change
-    this.configureComponent(new PeerRecordUpdater(this.components))
+    this.configureComponent('addressManager', new DefaultAddressManager(this.components, init.addresses))
 
     // Create keychain
     const keychainOpts = DefaultKeyChain.generateOptions()
-    this.keychain = this.configureComponent(new DefaultKeyChain(this.components, {
+    this.keychain = this.configureComponent('keyChain', new DefaultKeyChain(this.components, {
       ...keychainOpts,
       ...init.keychain
     }))
 
-    // Create the Nat Manager
-    this.services.push(new NatManager(this.components, init.nat))
-
-    // Add the identify service
-    this.identifyService = new IdentifyService(this.components, {
-      ...init.identify
-    })
-    this.configureComponent(this.identifyService)
-
-    // dht provided components (peerRouting, contentRouting, dht)
-    if (init.dht != null) {
-      this.dht = this.components.dht = init.dht(this.components)
-    } else {
-      this.dht = new DummyDHT()
-    }
-
-    // Create pubsub if provided
-    if (init.pubsub != null) {
-      this.pubsub = this.components.pubsub = init.pubsub(this.components)
-    } else {
-      this.pubsub = new DummyPubSub()
-    }
-
-    // Attach remaining APIs
-    // peer and content routing will automatically get modules from _modules and _dht
-
-    const peerRouters: PeerRouting[] = (init.peerRouters ?? []).map(fn => this.configureComponent(fn(this.components)))
-
-    if (init.dht != null) {
-      // add dht to routers
-      peerRouters.push(this.configureComponent(new DHTPeerRouting(this.dht)))
-
-      // use dht for peer discovery
-      this.dht.addEventListener('peer', (evt) => {
-        this.onDiscoveryPeer(evt)
-      })
-    }
-
-    this.peerRouting = this.components.peerRouting = this.configureComponent(new DefaultPeerRouting(this.components, {
-      ...init.peerRouting,
+    // Peer routers
+    const peerRouters: PeerRouting[] = (init.peerRouters ?? []).map((fn, index) => this.configureComponent(`peer-router-${index}`, fn(this.components)))
+    this.peerRouting = this.components.peerRouting = this.configureComponent('peerRouting', new DefaultPeerRouting(this.components, {
       routers: peerRouters
     }))
 
-    const contentRouters: ContentRouting[] = (init.contentRouters ?? []).map(fn => this.configureComponent(fn(this.components)))
-
-    if (init.dht != null) {
-      // add dht to routers
-      contentRouters.push(this.configureComponent(new DHTContentRouting(this.dht)))
-    }
-
-    this.contentRouting = this.components.contentRouting = this.configureComponent(new CompoundContentRouting(this.components, {
+    // Content routers
+    const contentRouters: ContentRouting[] = (init.contentRouters ?? []).map((fn, index) => this.configureComponent(`content-router-${index}`, fn(this.components)))
+    this.contentRouting = this.components.contentRouting = this.configureComponent('contentRouting', new CompoundContentRouting(this.components, {
       routers: contentRouters
     }))
 
-    this.fetchService = this.configureComponent(new FetchService(this.components, {
-      ...init.fetch
-    }))
-
-    this.pingService = this.configureComponent(new PingService(this.components, {
-      ...init.ping
-    }))
-
-    this.autonatService = this.configureComponent(new AutonatService(this.components, {
-      ...init.autonat
-    }))
-
-    this.configureComponent(new AutoDialler(this.components, {
-      minConnections: init.connectionManager.minConnections,
-      autoDialInterval: init.connectionManager.autoDialInterval
-    }))
-
-    if (init.relay != null) {
-      this.circuitService = this.configureComponent(init.relay(this.components))
-    }
-
     // Discovery modules
-    for (const fn of init.peerDiscovery ?? []) {
-      const service = this.configureComponent(fn(this.components))
+    ;(init.peerDiscovery ?? []).forEach((fn, index) => {
+      const service = this.configureComponent(`peer-discovery-${index}`, fn(this.components))
 
       service.addEventListener('peer', (evt) => {
-        this.onDiscoveryPeer(evt)
+        this.#onDiscoveryPeer(evt)
       })
-    }
+    })
 
     // Transport modules
-    init.transports.forEach((fn) => {
-      this.components.transportManager.add(this.configureComponent(fn(this.components)))
+    init.transports.forEach((fn, index) => {
+      this.components.transportManager.add(this.configureComponent(`transport-${index}`, fn(this.components)))
     })
+
+    // User defined modules
+    if (init.services != null) {
+      for (const name of Object.keys(init.services)) {
+        const createService = init.services[name]
+        const service: any = createService(this.components)
+
+        if (service == null) {
+          log.error('service factory %s returned null or undefined instance', name)
+          continue
+        }
+
+        this.services[name as keyof T] = service
+        this.configureComponent(name, service)
+
+        if (service[contentRouting] != null) {
+          log('registering service %s for content routing', name)
+          contentRouters.push(service[contentRouting])
+        }
+
+        if (service[peerRouting] != null) {
+          log('registering service %s for peer routing', name)
+          peerRouters.push(service[peerRouting])
+        }
+
+        if (service[peerDiscovery] != null) {
+          log('registering service %s for peer discovery', name)
+          service[peerDiscovery].addEventListener('peer', (evt: CustomEvent<PeerInfo>) => {
+            this.#onDiscoveryPeer(evt)
+          })
+        }
+      }
+    }
   }
 
-  private configureComponent <T> (component: T): T {
-    if (isStartable(component)) {
-      this.services.push(component)
+  private configureComponent <T> (name: string, component: T): T {
+    if (component == null) {
+      log.error('component %s was null or undefined', name)
     }
 
+    this.components[name] = component
+
     return component
   }
 
@@ -266,11 +208,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
    * Starts the libp2p node and all its subsystems
    */
   async start (): Promise<void> {
-    if (this.started) {
+    if (this.#started) {
       return
     }
 
-    this.started = true
+    this.#started = true
 
     log('libp2p is starting')
 
@@ -282,27 +224,9 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     }
 
     try {
-      await Promise.all(
-        this.services.map(async service => {
-          if (service.beforeStart != null) {
-            await service.beforeStart()
-          }
-        })
-      )
-
-      // start any startables
-      await Promise.all(
-        this.services.map(async service => { await service.start() })
-      )
-
-      await Promise.all(
-        this.services.map(async service => {
-          if (service.afterStart != null) {
-            await service.afterStart()
-          }
-        })
-      )
-
+      await this.components.beforeStart?.()
+      await this.components.start()
+      await this.components.afterStart?.()
       log('libp2p has started')
     } catch (err: any) {
       log.error('An error occurred starting libp2p', err)
@@ -315,45 +239,33 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
    * Stop the libp2p node by closing its listeners and open connections
    */
   async stop (): Promise<void> {
-    if (!this.started) {
+    if (!this.#started) {
       return
     }
 
     log('libp2p is stopping')
 
-    this.started = false
-
-    await Promise.all(
-      this.services.map(async service => {
-        if (service.beforeStop != null) {
-          await service.beforeStop()
-        }
-      })
-    )
-
-    await Promise.all(
-      this.services.map(async service => { await service.stop() })
-    )
+    this.#started = false
 
-    await Promise.all(
-      this.services.map(async service => {
-        if (service.afterStop != null) {
-          await service.afterStop()
-        }
-      })
-    )
+    await this.components.beforeStop?.()
+    await this.components.stop()
+    await this.components.afterStop?.()
 
     log('libp2p has stopped')
   }
 
   isStarted (): boolean {
-    return this.started
+    return this.#started
   }
 
   getConnections (peerId?: PeerId): Connection[] {
     return this.components.connectionManager.getConnections(peerId)
   }
 
+  getDialQueue (): PendingDial[] {
+    return this.components.connectionManager.getDialQueue()
+  }
+
   getPeers (): PeerId[] {
     const peerSet = new PeerSet()
 
@@ -365,7 +277,6 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   async dial (peer: PeerId | Multiaddr | Multiaddr[], options: AbortOptions = {}): Promise<Connection> {
-    // @ts-expect-error
     return await this.components.connectionManager.openConnection(peer, options)
   }
 
@@ -413,12 +324,8 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     const peerInfo = await this.peerStore.get(peer)
 
-    if (peerInfo.pubKey != null) {
-      return peerInfo.pubKey
-    }
-
-    if (this.dht == null) {
-      throw new CodeError('Public key was not in the peer store and the DHT is not enabled', codes.ERR_NO_ROUTERS_AVAILABLE)
+    if (peerInfo.id.publicKey != null) {
+      return peerInfo.id.publicKey
     }
 
     const peerKey = uint8ArrayConcat([
@@ -426,38 +333,16 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       peer.multihash.digest
     ])
 
-    // search the dht
-    for await (const event of this.dht.get(peerKey, options)) {
-      if (event.name === 'VALUE') {
-        const key = unmarshalPublicKey(event.value)
-
-        await this.peerStore.keyBook.set(peer, event.value)
-
-        return key.bytes
-      }
-    }
-
-    throw new CodeError(`Node not responding with its public key: ${peer.toString()}`, codes.ERR_INVALID_RECORD)
-  }
-
-  async fetch (peer: PeerId | Multiaddr, key: string, options: AbortOptions = {}): Promise<Uint8Array | null> {
-    if (isMultiaddr(peer)) {
-      const peerId = peerIdFromString(peer.getPeerId() ?? '')
-      await this.components.peerStore.addressBook.add(peerId, [peer])
-      peer = peerId
-    }
+    // search any available content routing methods
+    const bytes = await this.contentRouting.get(peerKey, options)
+    // ensure the returned key is valid
+    unmarshalPublicKey(bytes)
 
-    return await this.fetchService.fetch(peer, key, options)
-  }
-
-  async ping (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<number> {
-    if (isMultiaddr(peer)) {
-      const peerId = peerIdFromString(peer.getPeerId() ?? '')
-      await this.components.peerStore.addressBook.add(peerId, [peer])
-      peer = peerId
-    }
+    await this.peerStore.patch(peer, {
+      publicKey: bytes
+    })
 
-    return await this.pingService.ping(peer, options)
+    return bytes
   }
 
   async handle (protocols: string | string[], handler: StreamHandler, options?: StreamHandlerOptions): Promise<void> {
@@ -485,18 +370,18 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   async register (protocol: string, topology: Topology): Promise<string> {
-    return await this.registrar.register(protocol, topology)
+    return await this.components.registrar.register(protocol, topology)
   }
 
   unregister (id: string): void {
-    this.registrar.unregister(id)
+    this.components.registrar.unregister(id)
   }
 
   /**
-   * Called whenever peer discovery services emit `peer` events.
-   * Known peers may be emitted.
+   * Called whenever peer discovery services emit `peer` events and adds peers
+   * to the peer store.
    */
-  onDiscoveryPeer (evt: CustomEvent<PeerInfo>): void {
+  #onDiscoveryPeer (evt: CustomEvent<PeerInfo>): void {
     const { detail: peer } = evt
 
     if (peer.id.toString() === this.peerId.toString()) {
@@ -504,15 +389,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       return
     }
 
-    if (peer.multiaddrs.length > 0) {
-      void this.components.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => { log.error(err) })
-    }
-
-    if (peer.protocols.length > 0) {
-      void this.components.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => { log.error(err) })
-    }
-
-    this.dispatchEvent(new CustomEvent<PeerInfo>('peer:discovery', { detail: peer }))
+    void this.components.peerStore.merge(peer.id, {
+      multiaddrs: peer.multiaddrs,
+      protocols: peer.protocols
+    })
+      .catch(err => { log.error(err) })
   }
 }
 
@@ -520,7 +401,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
  * Returns a new Libp2pNode instance - this exposes more of the internals than the
  * libp2p interface and is useful for testing and debugging.
  */
-export async function createLibp2pNode (options: Libp2pOptions): Promise<Libp2pNode> {
+export async function createLibp2pNode <T extends ServiceMap = {}> (options: Libp2pOptions<T>): Promise<Libp2pNode<T>> {
   if (options.peerId == null) {
     const datastore = options.datastore as Datastore | undefined