libp2p 0.39.5 → 0.40.0

package/src/peer-routing.ts

@@ -23,7 +23,7 @@ import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { Components } from '@libp2p/components'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 
 const log = logger('libp2p:peer-routing')
 
@@ -54,15 +54,20 @@ export interface PeerRoutingInit {
   refreshManager?: RefreshManagerInit
 }
 
+export interface DefaultPeerRoutingComponents {
+  peerId: PeerId
+  peerStore: PeerStore
+}
+
 export class DefaultPeerRouting implements PeerRouting, Startable {
-  private readonly components: Components
+  private readonly components: DefaultPeerRoutingComponents
   private readonly routers: PeerRouting[]
   private readonly refreshManagerInit: RefreshManagerInit
   private timeoutId?: ReturnType<typeof setTimeout>
   private started: boolean
   private abortController?: TimeoutController
 
-  constructor (components: Components, init: PeerRoutingInit) {
+  constructor (components: DefaultPeerRoutingComponents, init: PeerRoutingInit) {
     this.components = components
     this.routers = init.routers
     this.refreshManagerInit = init.refreshManager ?? {}
@@ -110,7 +115,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
       } catch {}
 
       // nb getClosestPeers adds the addresses to the address book
-      await drain(this.getClosestPeers(this.components.getPeerId().toBytes(), { signal: this.abortController.signal }))
+      await drain(this.getClosestPeers(this.components.peerId.toBytes(), { signal: this.abortController.signal }))
     } catch (err: any) {
       log.error(err)
     } finally {
@@ -139,7 +144,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
       throw errCode(new Error('No peer routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
-    if (id.toString() === this.components.getPeerId().toString()) {
+    if (id.toString() === this.components.peerId.toString()) {
       throw errCode(new Error('Should not try to find self'), codes.ERR_FIND_SELF)
     }
 
@@ -154,7 +159,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
         })())
       ),
       (source) => filter(source, Boolean),
-      (source) => storeAddresses(source, this.components.getPeerStore()),
+      (source) => storeAddresses(source, this.components.peerStore),
       async (source) => await first(source)
     )
 
@@ -177,7 +182,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
       merge(
         ...this.routers.map(router => router.getClosestPeers(key, options))
       ),
-      (source) => storeAddresses(source, this.components.getPeerStore()),
+      (source) => storeAddresses(source, this.components.peerStore),
       (source) => uniquePeers(source),
       (source) => requirePeers(source)
     )

package/src/ping/index.ts

@@ -6,15 +6,15 @@ import { pipe } from 'it-pipe'
 import first from 'it-first'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION } from './constants.js'
-import type { IncomingStreamData } from '@libp2p/interface-registrar'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
 import { TimeoutController } from 'timeout-abort-controller'
 import type { Stream } from '@libp2p/interface-connection'
 import { setMaxListeners } from 'events'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 
 const log = logger('libp2p:ping')
 
@@ -29,13 +29,18 @@ export interface PingServiceInit {
   timeout: number
 }
 
+export interface PingServiceComponents {
+  registrar: Registrar
+  connectionManager: ConnectionManager
+}
+
 export class PingService implements Startable {
   public readonly protocol: string
-  private readonly components: Components
+  private readonly components: PingServiceComponents
   private started: boolean
   private readonly init: PingServiceInit
 
-  constructor (components: Components, init: PingServiceInit) {
+  constructor (components: PingServiceComponents, init: PingServiceInit) {
     this.components = components
     this.started = false
     this.protocol = `/${init.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
@@ -43,7 +48,7 @@ export class PingService implements Startable {
   }
 
   async start () {
-    await this.components.getRegistrar().handle(this.protocol, this.handleMessage, {
+    await this.components.registrar.handle(this.protocol, this.handleMessage, {
       maxInboundStreams: this.init.maxInboundStreams,
       maxOutboundStreams: this.init.maxOutboundStreams
     })
@@ -51,7 +56,7 @@ export class PingService implements Startable {
   }
 
   async stop () {
-    await this.components.getRegistrar().unhandle(this.protocol)
+    await this.components.registrar.unhandle(this.protocol)
     this.started = false
   }
 
@@ -82,7 +87,7 @@ export class PingService implements Startable {
 
     const start = Date.now()
     const data = randomBytes(PING_LENGTH)
-    const connection = await this.components.getConnectionManager().openConnection(peer, options)
+    const connection = await this.components.connectionManager.openConnection(peer, options)
     let timeoutController
     let signal = options.signal
     let stream: Stream | undefined

package/src/pnet/index.ts

@@ -24,7 +24,7 @@ export interface ProtectorInit {
   psk: Uint8Array
 }
 
-export class PreSharedKeyConnectionProtector implements ConnectionProtector {
+class PreSharedKeyConnectionProtector implements ConnectionProtector {
   public tag: string
   private readonly psk: Uint8Array
   private readonly enabled: boolean
@@ -96,3 +96,7 @@ export class PreSharedKeyConnectionProtector implements ConnectionProtector {
     }
   }
 }
+
+export function preSharedKey (init: ProtectorInit): () => ConnectionProtector {
+  return () => new PreSharedKeyConnectionProtector(init)
+}

package/src/pubsub/dummy-pubsub.ts

@@ -1,10 +1,12 @@
 import { EventEmitter } from '@libp2p/interfaces/events'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interface-pubsub'
+import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign, TopicValidatorFn } from '@libp2p/interface-pubsub'
 import errCode from 'err-code'
 import { messages, codes } from '../errors.js'
 
 export class DummyPubSub extends EventEmitter<PubSubEvents> implements PubSub {
+  public topicValidators = new Map<string, TopicValidatorFn>()
+
   isStarted (): boolean {
     return false
   }

package/src/registrar.ts

@@ -4,24 +4,31 @@ import { codes } from './errors.js'
 import { isTopology, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface-registrar'
 import merge from 'merge-options'
 import type { Registrar, StreamHandler, Topology } from '@libp2p/interface-registrar'
-import type { PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
+import type { PeerProtocolsChangeData, PeerStore } from '@libp2p/interface-peer-store'
 import type { Connection } from '@libp2p/interface-connection'
-import type { Components } from '@libp2p/components'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 const log = logger('libp2p:registrar')
 
 export const DEFAULT_MAX_INBOUND_STREAMS = 32
 export const DEFAULT_MAX_OUTBOUND_STREAMS = 64
 
+export interface RegistrarComponents {
+  peerId: PeerId
+  connectionManager: ConnectionManager
+  peerStore: PeerStore
+}
+
 /**
  * Responsible for notifying registered protocols of events in the network.
  */
 export class DefaultRegistrar implements Registrar {
   private readonly topologies: Map<string, Map<string, Topology>>
   private readonly handlers: Map<string, StreamHandlerRecord>
-  private readonly components: Components
+  private readonly components: RegistrarComponents
 
-  constructor (components: Components) {
+  constructor (components: RegistrarComponents) {
     this.topologies = new Map()
     this.handlers = new Map()
     this.components = components
@@ -29,10 +36,10 @@ export class DefaultRegistrar implements Registrar {
     this._onDisconnect = this._onDisconnect.bind(this)
     this._onProtocolChange = this._onProtocolChange.bind(this)
 
-    this.components.getConnectionManager().addEventListener('peer:disconnect', this._onDisconnect)
+    this.components.connectionManager.addEventListener('peer:disconnect', this._onDisconnect)
 
     // happens after identify
-    this.components.getPeerStore().addEventListener('change:protocols', this._onProtocolChange)
+    this.components.peerStore.addEventListener('change:protocols', this._onProtocolChange)
   }
 
   getProtocols () {
@@ -83,7 +90,7 @@ export class DefaultRegistrar implements Registrar {
     })
 
     // Add new protocols to self protocols in the Protobook
-    await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), [protocol])
+    await this.components.peerStore.protoBook.add(this.components.peerId, [protocol])
   }
 
   /**
@@ -98,7 +105,7 @@ export class DefaultRegistrar implements Registrar {
     })
 
     // Remove protocols from self protocols in the Protobook
-    await this.components.getPeerStore().protoBook.remove(this.components.getPeerId(), protocolList)
+    await this.components.peerStore.protoBook.remove(this.components.peerId, protocolList)
   }
 
   /**
@@ -149,7 +156,7 @@ export class DefaultRegistrar implements Registrar {
   _onDisconnect (evt: CustomEvent<Connection>) {
     const connection = evt.detail
 
-    void this.components.getPeerStore().protoBook.get(connection.remotePeer)
+    void this.components.peerStore.protoBook.get(connection.remotePeer)
       .then(peerProtocols => {
         for (const protocol of peerProtocols) {
           const topologies = this.topologies.get(protocol)
@@ -200,7 +207,7 @@ export class DefaultRegistrar implements Registrar {
       }
 
       for (const topology of topologies.values()) {
-        const connection = this.components.getConnectionManager().getConnections(peerId)[0]
+        const connection = this.components.connectionManager.getConnections(peerId)[0]
 
         if (connection == null) {
           continue

package/src/transport-manager.ts

@@ -2,14 +2,15 @@ import { logger } from '@libp2p/logger'
 import pSettle from 'p-settle'
 import { codes } from './errors.js'
 import errCode from 'err-code'
-import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interface-transport'
+import type { Listener, Transport, TransportManager, TransportManagerEvents, Upgrader } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/components'
 import { trackedMap } from '@libp2p/tracked-map'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 
 const log = logger('libp2p:transports')
 
@@ -17,14 +18,20 @@ export interface TransportManagerInit {
   faultTolerance?: FaultTolerance
 }
 
+export interface DefaultTransportManagerComponents {
+  metrics?: Metrics
+  addressManager: AddressManager
+  upgrader: Upgrader
+}
+
 export class DefaultTransportManager extends EventEmitter<TransportManagerEvents> implements TransportManager, Startable {
-  private readonly components: Components
+  private readonly components: DefaultTransportManagerComponents
   private readonly transports: Map<string, Transport>
   private readonly listeners: Map<string, Listener[]>
   private readonly faultTolerance: FaultTolerance
   private started: boolean
 
-  constructor (components: Components, init: TransportManagerInit = {}) {
+  constructor (components: DefaultTransportManagerComponents, init: TransportManagerInit = {}) {
     super()
 
     this.components = components
@@ -33,7 +40,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     this.listeners = trackedMap({
       component: 'transport-manager',
       metric: 'listeners',
-      metrics: this.components.getMetrics()
+      metrics: this.components.metrics
     })
     this.faultTolerance = init.faultTolerance ?? FaultTolerance.FATAL_ALL
   }
@@ -67,7 +74,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
 
   async start () {
     // Listen on the provided transports for the provided addresses
-    const addrs = this.components.getAddressManager().getListenAddrs()
+    const addrs = this.components.addressManager.getListenAddrs()
 
     await this.listen(addrs)
 
@@ -114,7 +121,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     try {
       return await transport.dial(ma, {
         ...options,
-        upgrader: this.components.getUpgrader()
+        upgrader: this.components.upgrader
       })
     } catch (err: any) {
       if (err.code == null) {
@@ -177,7 +184,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
       for (const addr of supportedAddrs) {
         log('creating listener for %s on %s', key, addr)
         const listener = transport.createListener({
-          upgrader: this.components.getUpgrader()
+          upgrader: this.components.upgrader
         })
 
         let listeners = this.listeners.get(key)

package/src/upgrader.ts

@@ -8,19 +8,21 @@ import { codes } from './errors.js'
 import { createConnection } from '@libp2p/connection'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { MultiaddrConnection, Connection, Stream } from '@libp2p/interface-connection'
+import type { MultiaddrConnection, Connection, Stream, ConnectionGater, ConnectionProtector } from '@libp2p/interface-connection'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
 import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Upgrader, UpgraderEvents } from '@libp2p/interface-transport'
+import type { Upgrader, UpgraderEvents, UpgraderOptions } from '@libp2p/interface-transport'
 import type { Duplex } from 'it-stream-types'
-import { Components, isInitializable } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Registrar } from '@libp2p/interface-registrar'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
 import { TimeoutController } from 'timeout-abort-controller'
 import { abortableDuplex } from 'abortable-iterator'
 import { setMaxListeners } from 'events'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 
 const log = logger('libp2p:upgrader')
 
@@ -94,13 +96,23 @@ function countStreams (protocol: string, direction: 'inbound' | 'outbound', conn
   return streamCount
 }
 
+export interface DefaultUpgraderComponents {
+  peerId: PeerId
+  metrics?: Metrics
+  connectionManager: ConnectionManager
+  connectionGater: ConnectionGater
+  connectionProtector?: ConnectionProtector
+  registrar: Registrar
+  peerStore: PeerStore
+}
+
 export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upgrader {
-  private readonly components: Components
+  private readonly components: DefaultUpgraderComponents
   private readonly connectionEncryption: Map<string, ConnectionEncrypter>
   private readonly muxers: Map<string, StreamMuxerFactory>
   private readonly inboundUpgradeTimeout: number
 
-  constructor (components: Components, init: UpgraderInit) {
+  constructor (components: DefaultUpgraderComponents, init: UpgraderInit) {
     super()
 
     this.components = components
@@ -123,6 +135,12 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * Upgrades an inbound connection
    */
   async upgradeInbound (maConn: MultiaddrConnection): Promise<Connection> {
+    const accept = await this.components.connectionManager.acceptIncomingConnection(maConn)
+
+    if (!accept) {
+      throw errCode(new Error('connection denied'), codes.ERR_CONNECTION_DENIED)
+    }
+
     let encryptedConn
     let remotePeer
     let upgradedConn: Duplex<Uint8Array>
@@ -130,7 +148,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     let cryptoProtocol
     let setPeer
     let proxyPeer
-    const metrics = this.components.getMetrics()
+    const metrics = this.components.metrics
 
     const timeoutController = new TimeoutController(this.inboundUpgradeTimeout)
 
@@ -144,7 +162,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       maConn.source = abortableStream.source
       maConn.sink = abortableStream.sink
 
-      if (await this.components.getConnectionGater().denyInboundConnection(maConn)) {
+      if (await this.components.connectionGater.denyInboundConnection(maConn)) {
         throw errCode(new Error('The multiaddr connection is blocked by gater.acceptConnection'), codes.ERR_CONNECTION_INTERCEPTED)
       }
 
@@ -159,7 +177,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
       // Protect
       let protectedConn = maConn
-      const protector = this.components.getConnectionProtector()
+      const protector = this.components.connectionProtector
 
       if (protector != null) {
         log('protecting the inbound connection')
@@ -174,7 +192,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
           protocol: cryptoProtocol
         } = await this._encryptInbound(protectedConn))
 
-        if (await this.components.getConnectionGater().denyInboundEncryptedConnection(remotePeer, {
+        if (await this.components.connectionGater.denyInboundEncryptedConnection(remotePeer, {
           ...protectedConn,
           ...encryptedConn
         })) {
@@ -194,11 +212,10 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         }
       } catch (err: any) {
         log.error('Failed to upgrade inbound connection', err)
-        await maConn.close(err)
         throw err
       }
 
-      if (await this.components.getConnectionGater().denyInboundUpgradedConnection(remotePeer, {
+      if (await this.components.connectionGater.denyInboundUpgradedConnection(remotePeer, {
         ...protectedConn,
         ...encryptedConn
       })) {
@@ -221,6 +238,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         remotePeer
       })
     } finally {
+      this.components.connectionManager.afterUpgradeInbound()
       timeoutController.clear()
     }
   }
@@ -228,7 +246,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
   /**
    * Upgrades an outbound connection
    */
-  async upgradeOutbound (maConn: MultiaddrConnection): Promise<Connection> {
+  async upgradeOutbound (maConn: MultiaddrConnection, opts?: UpgraderOptions): Promise<Connection> {
     const idStr = maConn.remoteAddr.getPeerId()
     if (idStr == null) {
       throw errCode(new Error('outbound connection must have a peer id'), codes.ERR_INVALID_MULTIADDR)
@@ -236,7 +254,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
     const remotePeerId = peerIdFromString(idStr)
 
-    if (await this.components.getConnectionGater().denyOutboundConnection(remotePeerId, maConn)) {
+    if (await this.components.connectionGater.denyOutboundConnection(remotePeerId, maConn)) {
       throw errCode(new Error('The multiaddr connection is blocked by connectionGater.denyOutboundConnection'), codes.ERR_CONNECTION_INTERCEPTED)
     }
 
@@ -247,7 +265,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     let muxerFactory
     let setPeer
     let proxyPeer
-    const metrics = this.components.getMetrics()
+    const metrics = this.components.metrics
 
     if (metrics != null) {
       ({ setTarget: setPeer, proxy: proxyPeer } = mutableProxy())
@@ -258,39 +276,51 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
     log('Starting the outbound connection upgrade')
 
+    // If the transport natively supports encryption, skip connection
+    // protector and encryption
+
     // Protect
     let protectedConn = maConn
-    const protector = this.components.getConnectionProtector()
+    if (opts?.skipProtection !== true) {
+      const protector = this.components.connectionProtector
 
-    if (protector != null) {
-      protectedConn = await protector.protect(maConn)
+      if (protector != null) {
+        protectedConn = await protector.protect(maConn)
+      }
     }
 
     try {
       // Encrypt the connection
-      ({
-        conn: encryptedConn,
-        remotePeer,
-        protocol: cryptoProtocol
-      } = await this._encryptOutbound(protectedConn, remotePeerId))
+      encryptedConn = protectedConn
+      if (opts?.skipEncryption !== true) {
+        ({
+          conn: encryptedConn,
+          remotePeer,
+          protocol: cryptoProtocol
+        } = await this._encryptOutbound(protectedConn, remotePeerId))
 
-      if (await this.components.getConnectionGater().denyOutboundEncryptedConnection(remotePeer, {
-        ...protectedConn,
-        ...encryptedConn
-      })) {
-        throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+        if (await this.components.connectionGater.denyOutboundEncryptedConnection(remotePeer, {
+          ...protectedConn,
+          ...encryptedConn
+        })) {
+          throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+        }
+      } else {
+        cryptoProtocol = 'native'
+        remotePeer = remotePeerId
       }
 
-      // Multiplex the connection
-      if (this.muxers.size > 0) {
+      upgradedConn = encryptedConn
+      if (opts?.muxerFactory != null) {
+        muxerFactory = opts.muxerFactory
+      } else if (this.muxers.size > 0) {
+        // Multiplex the connection
         const multiplexed = await this._multiplexOutbound({
           ...protectedConn,
           ...encryptedConn
         }, this.muxers)
         muxerFactory = multiplexed.muxerFactory
         upgradedConn = multiplexed.stream
-      } else {
-        upgradedConn = encryptedConn
       }
     } catch (err: any) {
       log.error('Failed to upgrade outbound connection', err)
@@ -298,7 +328,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       throw err
     }
 
-    if (await this.components.getConnectionGater().denyOutboundUpgradedConnection(remotePeer, {
+    if (await this.components.connectionGater.denyOutboundUpgradedConnection(remotePeer, {
       ...protectedConn,
       ...encryptedConn
     })) {
@@ -351,11 +381,11 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
           void Promise.resolve()
             .then(async () => {
-              const protocols = this.components.getRegistrar().getProtocols()
+              const protocols = this.components.registrar.getProtocols()
               const { stream, protocol } = await mss.handle(muxedStream, protocols)
               log('%s: incoming stream opened on %s', direction, protocol)
 
-              const metrics = this.components.getMetrics()
+              const metrics = this.components.metrics
 
               if (metrics != null) {
                 metrics.trackStream({ stream, remotePeer, protocol })
@@ -365,7 +395,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
                 return
               }
 
-              const incomingLimit = findIncomingStreamLimit(protocol, this.components.getRegistrar())
+              const incomingLimit = findIncomingStreamLimit(protocol, this.components.registrar)
               const streamCount = countStreams(protocol, 'inbound', connection)
 
               if (streamCount === incomingLimit) {
@@ -382,7 +412,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
               // If a protocol stream has been successfully negotiated and is to be passed to the application,
               // the peerstore should ensure that the peer is registered with that protocol
-              this.components.getPeerStore().protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
+              this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
 
               connection.addStream(muxedStream)
               this._onStream({ connection, stream: muxedStream, protocol })
@@ -401,18 +431,14 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         }
       })
 
-      if (isInitializable(muxer)) {
-        muxer.init(this.components)
-      }
-
       newStream = async (protocols: string[], options: AbortOptions = {}): Promise<Stream> => {
         if (muxer == null) {
           throw errCode(new Error('Stream is not multiplexed'), codes.ERR_MUXER_UNAVAILABLE)
         }
 
         log('%s: starting new stream on %s', direction, protocols)
-        const muxedStream = muxer.newStream()
-        const metrics = this.components.getMetrics()
+        const muxedStream = await muxer.newStream()
+        const metrics = this.components.metrics
         let controller: TimeoutController | undefined
 
         try {
@@ -434,7 +460,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
             metrics.trackStream({ stream, remotePeer, protocol })
           }
 
-          const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.getRegistrar())
+          const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.registrar)
           const streamCount = countStreams(protocol, 'outbound', connection)
 
           if (streamCount === outgoingLimit) {
@@ -446,7 +472,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
           // If a protocol stream has been successfully negotiated and is to be passed to the application,
           // the peerstore should ensure that the peer is registered with that protocol
-          this.components.getPeerStore().protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
+          this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
 
           // after the handshake the returned stream can have early data so override
           // the souce/sink
@@ -543,7 +569,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    */
   _onStream (opts: OnStreamOptions): void {
     const { connection, stream, protocol } = opts
-    const { handler } = this.components.getRegistrar().getHandler(protocol)
+    const { handler } = this.components.registrar.getHandler(protocol)
 
     handler({ connection, stream })
   }
@@ -568,7 +594,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       log('encrypting inbound connection...')
 
       return {
-        ...await encrypter.secureInbound(this.components.getPeerId(), stream),
+        ...await encrypter.secureInbound(this.components.peerId, stream),
         protocol
       }
     } catch (err: any) {
@@ -597,7 +623,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       log('encrypting outbound connection to %p', remotePeerId)
 
       return {
-        ...await encrypter.secureOutbound(this.components.getPeerId(), stream, remotePeerId),
+        ...await encrypter.secureOutbound(this.components.peerId, stream, remotePeerId),
         protocol
       }
     } catch (err: any) {
@@ -609,7 +635,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * Selects one of the given muxers via multistream-select. That
    * muxer will be used for all future streams on the connection.
    */
-  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory}> {
+  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory}> {
     const protocols = Array.from(muxers.keys())
     log('outbound selecting muxer %s', protocols)
     try {
@@ -629,7 +655,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * Registers support for one of the given muxers via multistream-select. The
    * selected muxer will be used for all future streams on the connection.
    */
-  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory}> {
+  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory}> {
     const protocols = Array.from(muxers.keys())
     log('inbound handling muxers %s', protocols)
     try {

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.39.5'
+export const version = '0.40.0'
 export const name = 'libp2p'