libp2p 0.46.20 → 0.46.21-0b4a2ee79

package/src/libp2p.ts

@@ -4,7 +4,6 @@ import { CodeError } from '@libp2p/interface/errors'
 import { TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface/events'
 import { peerDiscovery } from '@libp2p/interface/peer-discovery'
 import { type PeerRouting, peerRouting } from '@libp2p/interface/peer-routing'
-import { DefaultKeyChain } from '@libp2p/keychain'
 import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
@@ -12,7 +11,6 @@ import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
-import mergeOptions from 'merge-options'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DefaultAddressManager } from './address-manager/index.js'
@@ -26,32 +24,30 @@ import { DefaultPeerRouting } from './peer-routing.js'
 import { DefaultRegistrar } from './registrar.js'
 import { DefaultTransportManager } from './transport-manager.js'
 import { DefaultUpgrader } from './upgrader.js'
+import * as pkg from './version.js'
 import type { Components } from './components.js'
 import type { Libp2p, Libp2pInit, Libp2pOptions } from './index.js'
 import type { Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Connection, NewStreamOptions, Stream } from '@libp2p/interface/connection'
-import type { KeyChain } from '@libp2p/interface/keychain'
 import type { Metrics } from '@libp2p/interface/metrics'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerInfo } from '@libp2p/interface/peer-info'
 import type { PeerStore } from '@libp2p/interface/peer-store'
 import type { Topology } from '@libp2p/interface/topology'
 import type { StreamHandler, StreamHandlerOptions } from '@libp2p/interface-internal/registrar'
-import type { Datastore } from 'interface-datastore'
 
 export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends TypedEventEmitter<Libp2pEvents> implements Libp2p<T> {
   public peerId: PeerId
   public peerStore: PeerStore
   public contentRouting: ContentRouting
   public peerRouting: PeerRouting
-  public keychain: KeyChain
   public metrics?: Metrics
   public services: T
   public logger: ComponentLogger
 
   public components: Components
   #started: boolean
-  readonly #log: Logger
+  private readonly log: Logger
 
   constructor (init: Libp2pInit<T>) {
     super()
@@ -75,11 +71,15 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     this.#started = false
     this.peerId = init.peerId
     this.logger = init.logger ?? defaultLogger()
-    this.#log = this.logger.forComponent('libp2p')
+    this.log = this.logger.forComponent('libp2p')
     // @ts-expect-error {} may not be of type T
     this.services = {}
     const components = this.components = defaultComponents({
       peerId: init.peerId,
+      nodeInfo: init.nodeInfo ?? {
+        name: pkg.name,
+        version: pkg.version
+      },
       logger: this.logger,
       events,
       datastore: init.datastore ?? new MemoryDatastore(),
@@ -101,8 +101,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
       if (evt.detail.previous == null) {
         const peerInfo: PeerInfo = {
           id: evt.detail.peer.id,
-          multiaddrs: evt.detail.peer.addresses.map(a => a.multiaddr),
-          protocols: evt.detail.peer.protocols
+          multiaddrs: evt.detail.peer.addresses.map(a => a.multiaddr)
         }
 
         components.events.safeDispatchEvent('peer:discovery', { detail: peerInfo })
@@ -133,13 +132,6 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     // Addresses {listen, announce, noAnnounce}
     this.configureComponent('addressManager', new DefaultAddressManager(this.components, init.addresses))
 
-    // Create keychain
-    const keychainOpts = DefaultKeyChain.generateOptions()
-    this.keychain = this.configureComponent('keyChain', new DefaultKeyChain(this.components, {
-      ...keychainOpts,
-      ...init.keychain
-    }))
-
     // 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, {
@@ -173,7 +165,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
         const service: any = createService(this.components)
 
         if (service == null) {
-          this.#log.error('service factory %s returned null or undefined instance', name)
+          this.log.error('service factory %s returned null or undefined instance', name)
           continue
         }
 
@@ -181,17 +173,17 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
         this.configureComponent(name, service)
 
         if (service[contentRouting] != null) {
-          this.#log('registering service %s for content routing', name)
+          this.log('registering service %s for content routing', name)
           contentRouters.push(service[contentRouting])
         }
 
         if (service[peerRouting] != null) {
-          this.#log('registering service %s for peer routing', name)
+          this.log('registering service %s for peer routing', name)
           peerRouters.push(service[peerRouting])
         }
 
         if (service[peerDiscovery] != null) {
-          this.#log('registering service %s for peer discovery', name)
+          this.log('registering service %s for peer discovery', name)
           service[peerDiscovery].addEventListener('peer', (evt: CustomEvent<PeerInfo>) => {
             this.#onDiscoveryPeer(evt)
           })
@@ -202,7 +194,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
 
   private configureComponent <T> (name: string, component: T): T {
     if (component == null) {
-      this.#log.error('component %s was null or undefined', name)
+      this.log.error('component %s was null or undefined', name)
     }
 
     this.components[name] = component
@@ -220,14 +212,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
 
     this.#started = true
 
-    this.#log('libp2p is starting')
-
-    const keys = await this.keychain.listKeys()
-
-    if (keys.find(key => key.name === 'self') == null) {
-      this.#log('importing self key into keychain')
-      await this.keychain.importPeer('self', this.components.peerId)
-    }
+    this.log('libp2p is starting')
 
     try {
       await this.components.beforeStart?.()
@@ -235,9 +220,9 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
       await this.components.afterStart?.()
 
       this.safeDispatchEvent('start', { detail: this })
-      this.#log('libp2p has started')
+      this.log('libp2p has started')
     } catch (err: any) {
-      this.#log.error('An error occurred starting libp2p', err)
+      this.log.error('An error occurred starting libp2p', err)
       await this.stop()
       throw err
     }
@@ -251,7 +236,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
       return
     }
 
-    this.#log('libp2p is stopping')
+    this.log('libp2p is stopping')
 
     this.#started = false
 
@@ -260,7 +245,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     await this.components.afterStop?.()
 
     this.safeDispatchEvent('stop', { detail: this })
-    this.#log('libp2p has stopped')
+    this.log('libp2p has stopped')
   }
 
   isStarted (): boolean {
@@ -325,7 +310,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
    * Get the public key for the given peer id
    */
   async getPublicKey (peer: PeerId, options: AbortOptions = {}): Promise<Uint8Array> {
-    this.#log('getPublicKey %p', peer)
+    this.log('getPublicKey %p', peer)
 
     if (peer.publicKey != null) {
       return peer.publicKey
@@ -394,15 +379,14 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     const { detail: peer } = evt
 
     if (peer.id.toString() === this.peerId.toString()) {
-      this.#log.error(new Error(codes.ERR_DISCOVERED_SELF))
+      this.log.error(new Error(codes.ERR_DISCOVERED_SELF))
       return
     }
 
     void this.components.peerStore.merge(peer.id, {
-      multiaddrs: peer.multiaddrs,
-      protocols: peer.protocols
+      multiaddrs: peer.multiaddrs
     })
-      .catch(err => { this.#log.error(err) })
+      .catch(err => { this.log.error(err) })
   }
 }
 
@@ -411,29 +395,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
  * libp2p interface and is useful for testing and debugging.
  */
 export async function createLibp2pNode <T extends ServiceMap = Record<string, unknown>> (options: Libp2pOptions<T>): Promise<Libp2pNode<T>> {
-  if (options.peerId == null) {
-    const datastore = options.datastore as Datastore | undefined
-
-    if (datastore != null) {
-      try {
-        // try load the peer id from the keychain
-        const keyChain = new DefaultKeyChain({
-          datastore
-        }, mergeOptions(DefaultKeyChain.generateOptions(), options.keychain))
-
-        options.peerId = await keyChain.exportPeerId('self')
-      } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
-          throw err
-        }
-      }
-    }
-  }
-
-  if (options.peerId == null) {
-    // no peer id in the keychain, create a new peer id
-    options.peerId = await createEd25519PeerId()
-  }
+  options.peerId ??= await createEd25519PeerId()
 
   return new Libp2pNode(validateConfig(options))
 }

package/src/peer-routing.ts

@@ -1,5 +1,4 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
 import filter from 'it-filter'
 import first from 'it-first'
 import merge from 'it-merge'
@@ -10,13 +9,12 @@ import {
   requirePeers
 } from './content-routing/utils.js'
 import { codes, messages } from './errors.js'
-import type { AbortOptions } from '@libp2p/interface'
+import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerInfo } from '@libp2p/interface/peer-info'
 import type { PeerRouting } from '@libp2p/interface/peer-routing'
 import type { PeerStore } from '@libp2p/interface/peer-store'
-
-const log = logger('libp2p:peer-routing')
+import type { ComponentLogger } from '@libp2p/logger'
 
 export interface PeerRoutingInit {
   routers?: PeerRouting[]
@@ -25,14 +23,19 @@ export interface PeerRoutingInit {
 export interface DefaultPeerRoutingComponents {
   peerId: PeerId
   peerStore: PeerStore
+  logger: ComponentLogger
 }
 
 export class DefaultPeerRouting implements PeerRouting {
-  private readonly components: DefaultPeerRoutingComponents
+  private readonly log: Logger
+  private readonly peerId: PeerId
+  private readonly peerStore: PeerStore
   private readonly routers: PeerRouting[]
 
   constructor (components: DefaultPeerRoutingComponents, init: PeerRoutingInit) {
-    this.components = components
+    this.log = components.logger.forComponent('libp2p:peer-routing')
+    this.peerId = components.peerId
+    this.peerStore = components.peerStore
     this.routers = init.routers ?? []
   }
 
@@ -44,22 +47,24 @@ export class DefaultPeerRouting implements PeerRouting {
       throw new CodeError('No peer routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
-    if (id.toString() === this.components.peerId.toString()) {
+    if (id.toString() === this.peerId.toString()) {
       throw new CodeError('Should not try to find self', codes.ERR_FIND_SELF)
     }
 
+    const self = this
+
     const output = await pipe(
       merge(
         ...this.routers.map(router => (async function * () {
           try {
             yield await router.findPeer(id, options)
           } catch (err) {
-            log.error(err)
+            self.log.error(err)
           }
         })())
       ),
       (source) => filter(source, Boolean),
-      (source) => storeAddresses(source, this.components.peerStore),
+      (source) => storeAddresses(source, this.peerStore),
       async (source) => first(source)
     )
 
@@ -82,7 +87,7 @@ export class DefaultPeerRouting implements PeerRouting {
       merge(
         ...this.routers.map(router => router.getClosestPeers(key, options))
       ),
-      (source) => storeAddresses(source, this.components.peerStore),
+      (source) => storeAddresses(source, this.peerStore),
       (source) => uniquePeers(source),
       (source) => requirePeers(source)
     )

package/src/registrar.ts

@@ -1,16 +1,14 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
 import merge from 'merge-options'
 import { codes } from './errors.js'
-import type { IdentifyResult, Libp2pEvents, PeerUpdate } from '@libp2p/interface'
+import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate } from '@libp2p/interface'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerStore } from '@libp2p/interface/peer-store'
 import type { Topology } from '@libp2p/interface/topology'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { StreamHandlerOptions, StreamHandlerRecord, Registrar, StreamHandler } from '@libp2p/interface-internal/registrar'
-
-const log = logger('libp2p:registrar')
+import type { ComponentLogger } from '@libp2p/logger'
 
 export const DEFAULT_MAX_INBOUND_STREAMS = 32
 export const DEFAULT_MAX_OUTBOUND_STREAMS = 64
@@ -20,17 +18,20 @@ export interface RegistrarComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 /**
  * Responsible for notifying registered protocols of events in the network.
  */
 export class DefaultRegistrar implements Registrar {
+  private readonly log: Logger
   private readonly topologies: Map<string, Map<string, Topology>>
   private readonly handlers: Map<string, StreamHandlerRecord>
   private readonly components: RegistrarComponents
 
   constructor (components: RegistrarComponents) {
+    this.log = components.logger.forComponent('libp2p:registrar')
     this.topologies = new Map()
     this.handlers = new Map()
     this.components = components
@@ -178,7 +179,7 @@ export class DefaultRegistrar implements Registrar {
           return
         }
 
-        log.error('could not inform topologies of disconnecting peer %p', remotePeer, err)
+        this.log.error('could not inform topologies of disconnecting peer %p', remotePeer, err)
       })
   }
 

package/src/transport-manager.ts

@@ -1,9 +1,8 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { trackedMap } from '@libp2p/interface/metrics/tracked-map'
 import { FaultTolerance } from '@libp2p/interface/transport'
-import { logger } from '@libp2p/logger'
 import { codes } from './errors.js'
-import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { Libp2pEvents, AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Connection } from '@libp2p/interface/connection'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { Metrics } from '@libp2p/interface/metrics'
@@ -13,8 +12,6 @@ import type { AddressManager } from '@libp2p/interface-internal/address-manager'
 import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:transports')
-
 export interface TransportManagerInit {
   faultTolerance?: FaultTolerance
 }
@@ -24,9 +21,11 @@ export interface DefaultTransportManagerComponents {
   addressManager: AddressManager
   upgrader: Upgrader
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 export class DefaultTransportManager implements TransportManager, Startable {
+  private readonly log: Logger
   private readonly components: DefaultTransportManagerComponents
   private readonly transports: Map<string, Transport>
   private readonly listeners: Map<string, Listener[]>
@@ -34,6 +33,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
   private started: boolean
 
   constructor (components: DefaultTransportManagerComponents, init: TransportManagerInit = {}) {
+    this.log = components.logger.forComponent('libp2p:transports')
     this.components = components
     this.started = false
     this.transports = new Map<string, Transport>()
@@ -58,7 +58,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
       throw new CodeError(`There is already a transport with the tag ${tag}`, codes.ERR_DUPLICATE_TRANSPORT)
     }
 
-    log('adding transport %s', tag)
+    this.log('adding transport %s', tag)
 
     this.transports.set(tag, transport)
 
@@ -88,7 +88,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
   async stop (): Promise<void> {
     const tasks = []
     for (const [key, listeners] of this.listeners) {
-      log('closing listeners for %s', key)
+      this.log('closing listeners for %s', key)
       while (listeners.length > 0) {
         const listener = listeners.pop()
 
@@ -101,7 +101,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     }
 
     await Promise.all(tasks)
-    log('all listeners closed')
+    this.log('all listeners closed')
     for (const key of this.listeners.keys()) {
       this.listeners.set(key, [])
     }
@@ -182,7 +182,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     }
 
     if (addrs == null || addrs.length === 0) {
-      log('no addresses were provided for listening, this node is dial only')
+      this.log('no addresses were provided for listening, this node is dial only')
       return
     }
 
@@ -194,7 +194,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
 
       // For each supported multiaddr, create a listener
       for (const addr of supportedAddrs) {
-        log('creating listener for %s on %a', key, addr)
+        this.log('creating listener for %s on %a', key, addr)
         const listener = transport.createListener({
           upgrader: this.components.upgrader
         })
@@ -253,7 +253,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
       if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
         throw new CodeError(message, codes.ERR_NO_VALID_ADDRESSES)
       }
-      log(`libp2p in dial mode only: ${message}`)
+      this.log(`libp2p in dial mode only: ${message}`)
     }
   }
 
@@ -263,11 +263,11 @@ export class DefaultTransportManager implements TransportManager, Startable {
    */
   async remove (key: string): Promise<void> {
     const listeners = this.listeners.get(key) ?? []
-    log.trace('removing transport %s', key)
+    this.log.trace('removing transport %s', key)
 
     // Close any running listeners
     const tasks = []
-    log.trace('closing listeners for %s', key)
+    this.log.trace('closing listeners for %s', key)
     while (listeners.length > 0) {
       const listener = listeners.pop()