libp2p 0.46.21 → 1.0.0-551622a96

package/src/connection-manager/connection-pruner.ts

@@ -1,9 +1,7 @@
 import { PeerMap } from '@libp2p/peer-collections'
 import { MAX_CONNECTIONS } from './constants.js'
-import type { Libp2pEvents, Logger, ComponentLogger } from '@libp2p/interface'
-import type { TypedEventTarget } from '@libp2p/interface/events'
-import type { PeerStore } from '@libp2p/interface/peer-store'
-import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Libp2pEvents, Logger, ComponentLogger, TypedEventTarget, PeerStore } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 interface ConnectionPrunerInit {
@@ -32,7 +30,7 @@ export class ConnectionPruner {
   private readonly peerStore: PeerStore
   private readonly allow: Multiaddr[]
   private readonly events: TypedEventTarget<Libp2pEvents>
-  readonly #log: Logger
+  private readonly log: Logger
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
@@ -40,13 +38,13 @@ export class ConnectionPruner {
     this.connectionManager = components.connectionManager
     this.peerStore = components.peerStore
     this.events = components.events
-    this.#log = components.logger.forComponent('libp2p:connection-manager:connection-pruner')
+    this.log = components.logger.forComponent('libp2p:connection-manager:connection-pruner')
 
     // check the max connection limit whenever a peer connects
     components.events.addEventListener('connection:open', () => {
       this.maybePruneConnections()
         .catch(err => {
-          this.#log.error(err)
+          this.log.error(err)
         })
     })
   }
@@ -60,12 +58,12 @@ export class ConnectionPruner {
     const numConnections = connections.length
     const toPrune = Math.max(numConnections - this.maxConnections, 0)
 
-    this.#log('checking max connections limit %d/%d', numConnections, this.maxConnections)
+    this.log('checking max connections limit %d/%d', numConnections, this.maxConnections)
     if (numConnections <= this.maxConnections) {
       return
     }
 
-    this.#log('max connections limit exceeded %d/%d, pruning %d connection(s)', numConnections, this.maxConnections, toPrune)
+    this.log('max connections limit exceeded %d/%d, pruning %d connection(s)', numConnections, this.maxConnections, toPrune)
     const peerValues = new PeerMap<number>()
 
     // work out peer values
@@ -87,7 +85,7 @@ export class ConnectionPruner {
         }, 0))
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
-          this.#log.error('error loading peer tags', err)
+          this.log.error('error loading peer tags', err)
         }
       }
     }
@@ -124,7 +122,7 @@ export class ConnectionPruner {
     const toClose = []
 
     for (const connection of sortedConnections) {
-      this.#log('too many connections open - closing a connection to %p', connection.remotePeer)
+      this.log('too many connections open - closing a connection to %p', connection.remotePeer)
       // check allow list
       const connectionInAllowList = this.allow.some((ma) => {
         return connection.remoteAddr.toString().startsWith(ma.toString())
@@ -146,7 +144,7 @@ export class ConnectionPruner {
         try {
           await connection.close()
         } catch (err) {
-          this.#log.error(err)
+          this.log.error(err)
         }
       })
     )

package/src/connection-manager/constants.defaults.ts

@@ -13,11 +13,6 @@ export const INBOUND_UPGRADE_TIMEOUT = 30e3
  */
 export const MAX_PEER_ADDRS_TO_DIAL = 25
 
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxParallelDialsPerPeer
- */
-export const MAX_PARALLEL_DIALS_PER_PEER = 1
-
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#autoDialInterval
  */

package/src/connection-manager/dial-queue.ts

@@ -1,5 +1,4 @@
-import { AbortError, CodeError } from '@libp2p/interface/errors'
-import { setMaxListeners } from '@libp2p/interface/events'
+import { AbortError, CodeError, ERR_TIMEOUT, setMaxListeners } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
@@ -12,19 +11,13 @@ import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import {
   DIAL_TIMEOUT,
-  MAX_PARALLEL_DIALS_PER_PEER,
   MAX_PARALLEL_DIALS,
   MAX_PEER_ADDRS_TO_DIAL,
   LAST_DIAL_FAILURE_KEY
 } from './constants.js'
 import { combineSignals, resolveMultiaddrs } from './utils.js'
-import type { AddressSorter, AbortOptions, PendingDial, ComponentLogger, Logger } from '@libp2p/interface'
-import type { Connection } from '@libp2p/interface/connection'
-import type { ConnectionGater } from '@libp2p/interface/connection-gater'
-import type { Metric, Metrics } from '@libp2p/interface/metrics'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Address, PeerStore } from '@libp2p/interface/peer-store'
-import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
+import type { AddressSorter, AbortOptions, PendingDial, ComponentLogger, Logger, Connection, ConnectionGater, Metric, Metrics, PeerId, Address, PeerStore } from '@libp2p/interface'
+import type { TransportManager } from '@libp2p/interface-internal'
 
 export interface PendingDialTarget {
   resolve(value: any): void
@@ -44,7 +37,6 @@ interface DialerInit {
   addressSorter?: AddressSorter
   maxParallelDials?: number
   maxPeerAddrsToDial?: number
-  maxParallelDialsPerPeer?: number
   dialTimeout?: number
   resolvers?: Record<string, Resolver>
   connections?: PeerMap<Connection[]>
@@ -54,7 +46,6 @@ const defaultOptions = {
   addressSorter: defaultAddressSort,
   maxParallelDials: MAX_PARALLEL_DIALS,
   maxPeerAddrsToDial: MAX_PEER_ADDRS_TO_DIAL,
-  maxParallelDialsPerPeer: MAX_PARALLEL_DIALS_PER_PEER,
   dialTimeout: DIAL_TIMEOUT,
   resolvers: {
     dnsaddr: dnsaddrResolver
@@ -79,21 +70,19 @@ export class DialQueue {
   private readonly transportManager: TransportManager
   private readonly addressSorter: AddressSorter
   private readonly maxPeerAddrsToDial: number
-  private readonly maxParallelDialsPerPeer: number
   private readonly dialTimeout: number
   private readonly inProgressDialCount?: Metric
   private readonly pendingDialCount?: Metric
   private readonly shutDownController: AbortController
   private readonly connections: PeerMap<Connection[]>
-  readonly #log: Logger
+  private readonly log: Logger
 
   constructor (components: DialQueueComponents, init: DialerInit = {}) {
     this.addressSorter = init.addressSorter ?? defaultOptions.addressSorter
     this.maxPeerAddrsToDial = init.maxPeerAddrsToDial ?? defaultOptions.maxPeerAddrsToDial
-    this.maxParallelDialsPerPeer = init.maxParallelDialsPerPeer ?? defaultOptions.maxParallelDialsPerPeer
     this.dialTimeout = init.dialTimeout ?? defaultOptions.dialTimeout
     this.connections = init.connections ?? new PeerMap()
-    this.#log = components.logger.forComponent('libp2p:connection-manager:dial-queue')
+    this.log = components.logger.forComponent('libp2p:connection-manager:dial-queue')
 
     this.peerId = components.peerId
     this.peerStore = components.peerStore
@@ -103,8 +92,8 @@ export class DialQueue {
 
     setMaxListeners(Infinity, this.shutDownController.signal)
 
-    this.pendingDialCount = components.metrics?.registerMetric('libp2p_dialler_pending_dials')
-    this.inProgressDialCount = components.metrics?.registerMetric('libp2p_dialler_in_progress_dials')
+    this.pendingDialCount = components.metrics?.registerMetric('libp2p_dial_queue_pending_dials')
+    this.inProgressDialCount = components.metrics?.registerMetric('libp2p_dial_queue_in_progress_dials')
     this.pendingDials = []
 
     for (const [key, value] of Object.entries(init.resolvers ?? {})) {
@@ -133,7 +122,7 @@ export class DialQueue {
     })
     // a started job errored
     this.queue.on('error', (err) => {
-      this.#log.error('error in dial queue', err)
+      this.log.error('error in dial queue', err)
       this.pendingDialCount?.update(this.queue.size)
       this.inProgressDialCount?.update(this.queue.pending)
     })
@@ -205,7 +194,7 @@ export class DialQueue {
     })
 
     if (existingConnection != null) {
-      this.#log('already connected to %a', existingConnection.remoteAddr)
+      this.log('already connected to %a', existingConnection.remoteAddr)
       return existingConnection
     }
 
@@ -226,12 +215,12 @@ export class DialQueue {
     })
 
     if (existingDial != null) {
-      this.#log('joining existing dial target for %p', peerId)
+      this.log('joining existing dial target for %p', peerId)
       signal.clear()
       return existingDial.promise
     }
 
-    this.#log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
+    this.log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
     // @ts-expect-error .promise property is set below
     const pendingDial: PendingDialInternal = {
       id: randomId(),
@@ -252,7 +241,7 @@ export class DialQueue {
         signal.clear()
       })
       .catch(async err => {
-        this.#log.error('dial failed to %s', pendingDial.multiaddrs.map(ma => ma.toString()).join(', '), err)
+        this.log.error('dial failed to %s', pendingDial.multiaddrs.map(ma => ma.toString()).join(', '), err)
 
         if (peerId != null) {
           // record the last failed dial
@@ -263,13 +252,13 @@ export class DialQueue {
               }
             })
           } catch (err: any) {
-            this.#log.error('could not update last dial failure key for %p', peerId, err)
+            this.log.error('could not update last dial failure key for %p', peerId, err)
           }
         }
 
         // Error is a timeout
         if (signal.aborted) {
-          const error = new CodeError(err.message, codes.ERR_TIMEOUT)
+          const error = new CodeError(err.message, ERR_TIMEOUT)
           throw error
         }
 
@@ -294,12 +283,12 @@ export class DialQueue {
     })
 
     if (existingConnection != null) {
-      this.#log('already connected to %a', existingConnection.remoteAddr)
+      this.log('already connected to %a', existingConnection.remoteAddr)
       await connection.close()
       return existingConnection
     }
 
-    this.#log('connection opened to %a', connection.remoteAddr)
+    this.log('connection opened to %a', connection.remoteAddr)
     return connection
   }
 
@@ -334,11 +323,11 @@ export class DialQueue {
 
       // if just a peer id was passed, load available multiaddrs for this peer from the address book
       if (addrs.length === 0) {
-        this.#log('loading multiaddrs for %p', peerId)
+        this.log('loading multiaddrs for %p', peerId)
         try {
           const peer = await this.peerStore.get(peerId)
           addrs.push(...peer.addresses)
-          this.#log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+          this.log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
         } catch (err: any) {
           if (err.code !== codes.ERR_NOT_FOUND) {
             throw err
@@ -352,7 +341,7 @@ export class DialQueue {
       addrs.map(async addr => {
         const result = await resolveMultiaddrs(addr.multiaddr, {
           ...options,
-          log: this.#log
+          log: this.log
         })
 
         if (result.length === 1 && result[0].equals(addr.multiaddr)) {
@@ -425,8 +414,8 @@ export class DialQueue {
     const dedupedMultiaddrs = [...dedupedAddrs.values()]
 
     if (dedupedMultiaddrs.length === 0 || dedupedMultiaddrs.length > this.maxPeerAddrsToDial) {
-      this.#log('addresses for %p before filtering', peerId ?? 'unknown peer', resolvedAddresses.map(({ multiaddr }) => multiaddr.toString()))
-      this.#log('addresses for %p after filtering', peerId ?? 'unknown peer', dedupedMultiaddrs.map(({ multiaddr }) => multiaddr.toString()))
+      this.log('addresses for %p before filtering', peerId ?? 'unknown peer', resolvedAddresses.map(({ multiaddr }) => multiaddr.toString()))
+      this.log('addresses for %p after filtering', peerId ?? 'unknown peer', dedupedMultiaddrs.map(({ multiaddr }) => multiaddr.toString()))
     }
 
     // make sure we actually have some addresses to dial
@@ -463,14 +452,10 @@ export class DialQueue {
     const dialAbortControllers: Array<(AbortController | undefined)> = pendingDial.multiaddrs.map(() => new AbortController())
 
     try {
-      // internal peer dial queue to ensure we only dial the configured number of addresses
-      // per peer at the same time to prevent one peer with a lot of addresses swamping
-      // the dial queue
-      const peerDialQueue = new PQueue({
-        concurrency: this.maxParallelDialsPerPeer
-      })
+      // internal peer dial queue - only one dial per peer at a time
+      const peerDialQueue = new PQueue({ concurrency: 1 })
       peerDialQueue.on('error', (err) => {
-        this.#log.error('error dialling', err)
+        this.log.error('error dialing %s %o', pendingDial.multiaddrs, err)
       })
 
       const conn = await Promise.any(pendingDial.multiaddrs.map(async (addr, i) => {
@@ -483,13 +468,13 @@ export class DialQueue {
         // let any signal abort the dial
         const signal = combineSignals(controller.signal, options.signal)
         signal.addEventListener('abort', () => {
-          this.#log('dial to %a aborted', addr)
+          this.log('dial to %a aborted', addr)
         })
         const deferred = pDefer<Connection>()
 
         await peerDialQueue.add(async () => {
           if (signal.aborted) {
-            this.#log('dial to %a was aborted before reaching the head of the peer dial queue', addr)
+            this.log('dial to %a was aborted before reaching the head of the peer dial queue', addr)
             deferred.reject(new AbortError())
             return
           }
@@ -498,7 +483,7 @@ export class DialQueue {
           await this.queue.add(async () => {
             try {
               if (signal.aborted) {
-                this.#log('dial to %a was aborted before reaching the head of the dial queue', addr)
+                this.log('dial to %a was aborted before reaching the head of the dial queue', addr)
                 deferred.reject(new AbortError())
                 return
               }
@@ -513,10 +498,10 @@ export class DialQueue {
 
               if (controller.signal.aborted) {
                 // another dial succeeded faster than this one
-                this.#log('multiple dials succeeded, closing superfluous connection')
+                this.log('multiple dials succeeded, closing superfluous connection')
 
                 conn.close().catch(err => {
-                  this.#log.error('error closing superfluous connection', err)
+                  this.log.error('error closing superfluous connection', err)
                 })
 
                 deferred.reject(new AbortError())
@@ -533,13 +518,13 @@ export class DialQueue {
                 }
               })
 
-              this.#log('dial to %a succeeded', addr)
+              this.log('dial to %a succeeded', addr)
 
               // resolve the connection promise
               deferred.resolve(conn)
             } catch (err: any) {
               // something only went wrong if our signal was not aborted
-              this.#log.error('error during dial of %a', addr, err)
+              this.log.error('error during dial of %a', addr, err)
               deferred.reject(err)
             }
           }, {

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
    */