libp2p 0.46.21 → 1.0.0

package/src/connection-manager/index.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { KEEP_ALIVE } from '@libp2p/interface/peer-store/tags'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
@@ -9,18 +9,10 @@ import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import { AutoDial } from './auto-dial.js'
 import { ConnectionPruner } from './connection-pruner.js'
-import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PARALLEL_DIALS_PER_PEER, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
+import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
 import { DialQueue } from './dial-queue.js'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
-import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection'
-import type { ConnectionGater } from '@libp2p/interface/connection-gater'
-import type { TypedEventTarget } from '@libp2p/interface/events'
-import type { Metrics } from '@libp2p/interface/metrics'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Peer, PeerStore } from '@libp2p/interface/peer-store'
-import type { Startable } from '@libp2p/interface/startable'
-import type { ConnectionManager, OpenConnectionOptions } from '@libp2p/interface-internal/connection-manager'
-import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, Peer, PeerStore, Startable } from '@libp2p/interface'
+import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 
 const DEFAULT_DIAL_PRIORITY = 50
 
@@ -89,14 +81,6 @@ export interface ConnectionManagerInit {
    */
   maxParallelDials?: number
 
-  /**
-   * To prevent individual peers with large amounts of multiaddrs swamping the
-   * dial queue, this value controls how many addresses to dial in parallel per
-   * peer. So for example if two peers have 10 addresses and this value is set
-   * at 5, we will dial 5 addresses from each at a time. (default: 1)
-   */
-  maxParallelDialsPerPeer?: number
-
   /**
    * Maximum number of addresses allowed for a given peer - if a peer has more
    * addresses than this then the dial will fail. (default: 25)
@@ -186,7 +170,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly peerStore: PeerStore
   private readonly metrics?: Metrics
   private readonly events: TypedEventTarget<Libp2pEvents>
-  readonly #log: Logger
+  private readonly log: Logger
 
   constructor (components: DefaultConnectionManagerComponents, init: ConnectionManagerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
@@ -205,7 +189,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.peerStore = components.peerStore
     this.metrics = components.metrics
     this.events = components.events
-    this.#log = components.logger.forComponent('libp2p:connection-manager')
+    this.log = components.logger.forComponent('libp2p:connection-manager')
 
     this.onConnect = this.onConnect.bind(this)
     this.onDisconnect = this.onDisconnect.bind(this)
@@ -260,7 +244,6 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       addressSorter: init.addressSorter ?? defaultAddressSort,
       maxParallelDials: init.maxParallelDials ?? MAX_PARALLEL_DIALS,
       maxPeerAddrsToDial: init.maxPeerAddrsToDial ?? MAX_PEER_ADDRS_TO_DIAL,
-      maxParallelDialsPerPeer: init.maxParallelDialsPerPeer ?? MAX_PARALLEL_DIALS_PER_PEER,
       dialTimeout: init.dialTimeout ?? DIAL_TIMEOUT,
       resolvers: init.resolvers ?? {
         dnsaddr: dnsaddrResolver
@@ -359,7 +342,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.autoDial.start()
 
     this.started = true
-    this.#log('started')
+    this.log('started')
   }
 
   async afterStart (): Promise<void> {
@@ -376,13 +359,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
           keepAlivePeers.map(async peer => {
             await this.openConnection(peer.id)
               .catch(err => {
-                this.#log.error(err)
+                this.log.error(err)
               })
           })
         )
       })
       .catch(err => {
-        this.#log.error(err)
+        this.log.error(err)
       })
 
     this.autoDial.afterStart()
@@ -403,22 +386,22 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
           try {
             await connection.close()
           } catch (err) {
-            this.#log.error(err)
+            this.log.error(err)
           }
         })())
       }
     }
 
-    this.#log('closing %d connections', tasks.length)
+    this.log('closing %d connections', tasks.length)
     await Promise.all(tasks)
     this.connections.clear()
 
-    this.#log('stopped')
+    this.log('stopped')
   }
 
   onConnect (evt: CustomEvent<Connection>): void {
     void this._onConnect(evt).catch(err => {
-      this.#log.error(err)
+      this.log.error(err)
     })
   }
 
@@ -508,12 +491,12 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     const { peerId } = getPeerAddress(peerIdOrMultiaddr)
 
     if (peerId != null && options.force !== true) {
-      this.#log('dial %p', peerId)
+      this.log('dial %p', peerId)
       const existingConnection = this.getConnections(peerId)
         .find(conn => !conn.transient)
 
       if (existingConnection != null) {
-        this.#log('had an existing non-transient connection to %p', peerId)
+        this.log('had an existing non-transient connection to %p', peerId)
 
         return existingConnection
       }
@@ -569,7 +552,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     })
 
     if (denyConnection) {
-      this.#log('connection from %a refused - connection remote address was in deny list', maConn.remoteAddr)
+      this.log('connection from %a refused - connection remote address was in deny list', maConn.remoteAddr)
       return false
     }
 
@@ -586,7 +569,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     // check pending connections
     if (this.incomingPendingConnections === this.maxIncomingPendingConnections) {
-      this.#log('connection from %a refused - incomingPendingConnections exceeded by host', maConn.remoteAddr)
+      this.log('connection from %a refused - incomingPendingConnections exceeded by host', maConn.remoteAddr)
       return false
     }
 
@@ -596,7 +579,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       try {
         await this.inboundConnectionRateLimiter.consume(host, 1)
       } catch {
-        this.#log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
+        this.log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
         return false
       }
     }
@@ -607,7 +590,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       return true
     }
 
-    this.#log('connection from %a refused - maxConnections exceeded', maConn.remoteAddr)
+    this.log('connection from %a refused - maxConnections exceeded', maConn.remoteAddr)
     return false
   }
 

package/src/connection-manager/utils.ts

@@ -1,4 +1,4 @@
-import { setMaxListeners } from '@libp2p/interface/events'
+import { setMaxListeners } from '@libp2p/interface'
 import { type AbortOptions, multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { type ClearableSignal, anySignal } from 'any-signal'
 import type { LoggerOptions } from '@libp2p/interface'

package/src/content-routing/index.ts

@@ -1,17 +1,13 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
-import { messages, codes } from '../errors.js'
+import { codes, messages } from '../errors.js'
 import {
   storeAddresses,
   uniquePeers,
   requirePeers
 } from './utils.js'
-import type { AbortOptions } from '@libp2p/interface'
-import type { ContentRouting } from '@libp2p/interface/content-routing'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { PeerStore } from '@libp2p/interface/peer-store'
-import type { Startable } from '@libp2p/interface/startable'
+import type { AbortOptions, ContentRouting, PeerInfo, PeerStore, Startable } from '@libp2p/interface'
 import type { CID } from 'multiformats/cid'
 
 export interface CompoundContentRoutingInit {

package/src/content-routing/utils.ts

@@ -1,8 +1,7 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import filter from 'it-filter'
 import map from 'it-map'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { PeerInfo, PeerStore } from '@libp2p/interface'
 import type { Source } from 'it-stream-types'
 
 /**

package/src/errors.ts

@@ -37,7 +37,6 @@ export enum codes {
   ERR_INVALID_PEER = 'ERR_INVALID_PEER',
   ERR_MUXER_UNAVAILABLE = 'ERR_MUXER_UNAVAILABLE',
   ERR_NOT_FOUND = 'ERR_NOT_FOUND',
-  ERR_TIMEOUT = 'ERR_TIMEOUT',
   ERR_TRANSPORT_UNAVAILABLE = 'ERR_TRANSPORT_UNAVAILABLE',
   ERR_TRANSPORT_DIAL_FAILED = 'ERR_TRANSPORT_DIAL_FAILED',
   ERR_UNSUPPORTED_PROTOCOL = 'ERR_UNSUPPORTED_PROTOCOL',
@@ -48,7 +47,6 @@ export enum codes {
   ERR_NO_ROUTERS_AVAILABLE = 'ERR_NO_ROUTERS_AVAILABLE',
   ERR_CONNECTION_NOT_MULTIPLEXED = 'ERR_CONNECTION_NOT_MULTIPLEXED',
   ERR_NO_DIAL_TOKENS = 'ERR_NO_DIAL_TOKENS',
-  ERR_KEYCHAIN_REQUIRED = 'ERR_KEYCHAIN_REQUIRED',
   ERR_INVALID_CMS = 'ERR_INVALID_CMS',
   ERR_MISSING_KEYS = 'ERR_MISSING_KEYS',
   ERR_NO_KEY = 'ERR_NO_KEY',

package/src/get-peer.ts

@@ -1,14 +1,10 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { isPeerId } from '@libp2p/interface/peer-id'
-import { logger } from '@libp2p/logger'
+import { CodeError, isPeerId } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { isMultiaddr } from '@multiformats/multiaddr'
 import { codes } from './errors.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:get-peer')
-
 export interface PeerAddress {
   peerId?: PeerId
   multiaddrs: Multiaddr[]
@@ -35,7 +31,6 @@ export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAdd
     // ensure PeerId is either not set or is consistent
     peer.forEach(ma => {
       if (!isMultiaddr(ma)) {
-        log.error('multiaddr %s was invalid', ma)
         throw new CodeError('Invalid Multiaddr', codes.ERR_INVALID_MULTIADDR)
       }
 

package/src/index.ts

@@ -19,18 +19,7 @@ import type { AddressManagerInit } from './address-manager/index.js'
 import type { Components } from './components.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { TransportManagerInit } from './transport-manager.js'
-import type { Libp2p, ServiceMap, RecursivePartial, ComponentLogger } from '@libp2p/interface'
-import type { ConnectionProtector } from '@libp2p/interface/connection'
-import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
-import type { ConnectionGater } from '@libp2p/interface/connection-gater'
-import type { ContentRouting } from '@libp2p/interface/content-routing'
-import type { Metrics } from '@libp2p/interface/metrics'
-import type { PeerDiscovery } from '@libp2p/interface/peer-discovery'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerRouting } from '@libp2p/interface/peer-routing'
-import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
-import type { Transport } from '@libp2p/interface/transport'
-import type { KeyChainInit } from '@libp2p/keychain'
+import type { Libp2p, ServiceMap, RecursivePartial, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionEncrypter, ConnectionGater, ContentRouting, Metrics, PeerDiscovery, PeerId, PeerRouting, StreamMuxerFactory, Transport } from '@libp2p/interface'
 import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
 import type { Datastore } from 'interface-datastore'
 
@@ -47,6 +36,11 @@ export interface Libp2pInit<T extends ServiceMap = { x: Record<string, unknown>
    */
   peerId: PeerId
 
+  /**
+   * Metadata about the node - implementation name, version number, etc
+   */
+  nodeInfo: NodeInfo
+
   /**
    * Addresses for transport listening and to advertise to the network
    */
@@ -79,11 +73,6 @@ export interface Libp2pInit<T extends ServiceMap = { x: Record<string, unknown>
    */
   peerStore: PersistentPeerStoreInit
 
-  /**
-   * keychain configuration
-   */
-  keychain: KeyChainInit
-
   /**
    * An array that must include at least 1 compliant transport
    */

package/src/libp2p.ts

@@ -1,10 +1,6 @@
 import { unmarshalPublicKey } from '@libp2p/crypto/keys'
-import { type ContentRouting, contentRouting } from '@libp2p/interface/content-routing'
-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 { type ContentRouting, contentRoutingSymbol, type PeerRouting, peerRoutingSymbol, type Libp2pEvents, type PendingDial, type ServiceMap, type AbortOptions, type ComponentLogger, type Logger, type Connection, type NewStreamOptions, type Stream, type Metrics, type PeerId, type PeerInfo, type PeerStore, type Topology } from '@libp2p/interface'
+import { CodeError, TypedEventEmitter, CustomEvent, setMaxListeners, peerDiscoverySymbol } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
@@ -12,7 +8,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 +21,23 @@ 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'
+import type { StreamHandler, StreamHandlerOptions } from '@libp2p/interface-internal'
 
 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 +61,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 +91,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 +122,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,26 +155,26 @@ 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
         }
 
         this.services[name as keyof T] = service
         this.configureComponent(name, service)
 
-        if (service[contentRouting] != null) {
-          this.#log('registering service %s for content routing', name)
-          contentRouters.push(service[contentRouting])
+        if (service[contentRoutingSymbol] != null) {
+          this.log('registering service %s for content routing', name)
+          contentRouters.push(service[contentRoutingSymbol])
         }
 
-        if (service[peerRouting] != null) {
-          this.#log('registering service %s for peer routing', name)
-          peerRouters.push(service[peerRouting])
+        if (service[peerRoutingSymbol] != null) {
+          this.log('registering service %s for peer routing', name)
+          peerRouters.push(service[peerRoutingSymbol])
         }
 
-        if (service[peerDiscovery] != null) {
-          this.#log('registering service %s for peer discovery', name)
-          service[peerDiscovery].addEventListener('peer', (evt: CustomEvent<PeerInfo>) => {
+        if (service[peerDiscoverySymbol] != null) {
+          this.log('registering service %s for peer discovery', name)
+          service[peerDiscoverySymbol].addEventListener('peer', (evt: CustomEvent<PeerInfo>) => {
             this.#onDiscoveryPeer(evt)
           })
         }
@@ -202,7 +184,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 +202,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 +210,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 +226,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 +235,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 +300,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 +369,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 +385,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 { CodeError } from '@libp2p/interface'
 import filter from 'it-filter'
 import first from 'it-first'
 import merge from 'it-merge'
@@ -10,13 +9,8 @@ import {
   requirePeers
 } from './content-routing/utils.js'
 import { codes, messages } from './errors.js'
-import type { AbortOptions } 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 { AbortOptions, Logger, PeerId, PeerInfo, PeerRouting, PeerStore } from '@libp2p/interface'
+import type { ComponentLogger } from '@libp2p/logger'
 
 export interface PeerRoutingInit {
   routers?: PeerRouting[]
@@ -25,14 +19,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 +43,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 +83,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)
     )