libp2p 0.46.20 → 0.46.21-0b4a2ee79

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

@@ -1,4 +1,4 @@
-import { AbortError, CodeError } from '@libp2p/interface/errors'
+import { AbortError, CodeError, ERR_TIMEOUT } from '@libp2p/interface/errors'
 import { setMaxListeners } from '@libp2p/interface/events'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
@@ -12,7 +12,6 @@ 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
@@ -44,7 +43,6 @@ interface DialerInit {
   addressSorter?: AddressSorter
   maxParallelDials?: number
   maxPeerAddrsToDial?: number
-  maxParallelDialsPerPeer?: number
   dialTimeout?: number
   resolvers?: Record<string, Resolver>
   connections?: PeerMap<Connection[]>
@@ -54,7 +52,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 +76,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 +98,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 +128,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 +200,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 +221,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 +247,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 +258,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 +289,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 +329,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 +347,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 +420,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 +458,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 +474,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 +489,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 +504,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 +524,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

@@ -9,7 +9,7 @@ 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'
@@ -89,14 +89,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 +178,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 +197,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 +252,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 +350,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 +367,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 +394,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 +499,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 +560,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 +577,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 +587,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 +598,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/content-routing/index.ts

@@ -1,7 +1,7 @@
 import { CodeError } from '@libp2p/interface/errors'
 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,

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,11 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { isPeerId } from '@libp2p/interface/peer-id'
-import { logger } from '@libp2p/logger'
 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 { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:get-peer')
-
 export interface PeerAddress {
   peerId?: PeerId
   multiaddrs: Multiaddr[]
@@ -35,7 +32,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,7 +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 { Libp2p, ServiceMap, RecursivePartial, ComponentLogger, NodeInfo } 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'
@@ -30,7 +30,6 @@ 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 { PersistentPeerStoreInit } from '@libp2p/peer-store'
 import type { Datastore } from 'interface-datastore'
 
@@ -47,6 +46,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 +83,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
    */