libp2p 0.39.5 → 0.40.0

package/src/keychain/index.ts

@@ -11,9 +11,9 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { generateKeyPair, importKey, unmarshalPrivateKey } from '@libp2p/crypto/keys'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Components } from '@libp2p/components'
 import { pbkdf2, randomBytes } from '@libp2p/crypto'
 import type { Startable } from '@libp2p/interfaces/dist/src/startable'
+import type { Datastore } from 'interface-datastore'
 
 const log = logger('libp2p:keychain')
 
@@ -103,6 +103,11 @@ function DsInfoName (name: string) {
   return new Key(infoPrefix + name)
 }
 
+export interface KeyChainComponents {
+  peerId: PeerId
+  datastore: Datastore
+}
+
 /**
  * Manages the lifecycle of a key. Keys are encrypted at rest using PKCS #8.
  *
@@ -112,14 +117,14 @@ function DsInfoName (name: string) {
  *
  */
 export class KeyChain implements Startable {
-  private readonly components: Components
+  private readonly components: KeyChainComponents
   private init: KeyChainInit
   private started: boolean
 
   /**
    * Creates a new instance of a key chain
    */
-  constructor (components: Components, init: KeyChainInit) {
+  constructor (components: KeyChainComponents, init: KeyChainInit) {
     this.components = components
     this.init = mergeOptions(defaultOptions, init)
 
@@ -157,8 +162,8 @@ export class KeyChain implements Startable {
   async start () {
     const dsname = DsInfoName('self')
 
-    if (!(await this.components.getDatastore().has(dsname))) {
-      await this.importPeer('self', this.components.getPeerId())
+    if (!(await this.components.datastore.has(dsname))) {
+      await this.importPeer('self', this.components.peerId)
     }
 
     this.started = true
@@ -229,7 +234,7 @@ export class KeyChain implements Startable {
     }
 
     const dsname = DsName(name)
-    const exists = await this.components.getDatastore().has(dsname)
+    const exists = await this.components.datastore.has(dsname)
     if (exists) {
       await randomDelay()
       throw errCode(new Error('Key name already exists'), codes.ERR_KEY_ALREADY_EXISTS)
@@ -262,7 +267,7 @@ export class KeyChain implements Startable {
         name: name,
         id: kid
       }
-      const batch = this.components.getDatastore().batch()
+      const batch = this.components.datastore.batch()
       batch.put(dsname, uint8ArrayFromString(pem))
       batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo)))
 
@@ -286,7 +291,7 @@ export class KeyChain implements Startable {
     }
 
     const info = []
-    for await (const value of this.components.getDatastore().query(query)) {
+    for await (const value of this.components.datastore.query(query)) {
       info.push(JSON.parse(uint8ArrayToString(value.value)))
     }
 
@@ -320,7 +325,7 @@ export class KeyChain implements Startable {
 
     const dsname = DsInfoName(name)
     try {
-      const res = await this.components.getDatastore().get(dsname)
+      const res = await this.components.datastore.get(dsname)
       return JSON.parse(uint8ArrayToString(res))
     } catch (err: any) {
       await randomDelay()
@@ -342,7 +347,7 @@ export class KeyChain implements Startable {
     }
     const dsname = DsName(name)
     const keyInfo = await this.findKeyByName(name)
-    const batch = this.components.getDatastore().batch()
+    const batch = this.components.datastore.batch()
     batch.delete(dsname)
     batch.delete(DsInfoName(name))
     await batch.commit()
@@ -370,19 +375,19 @@ export class KeyChain implements Startable {
     const oldInfoName = DsInfoName(oldName)
     const newInfoName = DsInfoName(newName)
 
-    const exists = await this.components.getDatastore().has(newDsname)
+    const exists = await this.components.datastore.has(newDsname)
     if (exists) {
       await randomDelay()
       throw errCode(new Error(`Key '${newName}' already exists`), codes.ERR_KEY_ALREADY_EXISTS)
     }
 
     try {
-      const pem = await this.components.getDatastore().get(oldDsname)
-      const res = await this.components.getDatastore().get(oldInfoName)
+      const pem = await this.components.datastore.get(oldDsname)
+      const res = await this.components.datastore.get(oldInfoName)
 
       const keyInfo = JSON.parse(uint8ArrayToString(res))
       keyInfo.name = newName
-      const batch = this.components.getDatastore().batch()
+      const batch = this.components.datastore.batch()
       batch.put(newDsname, pem)
       batch.put(newInfoName, uint8ArrayFromString(JSON.stringify(keyInfo)))
       batch.delete(oldDsname)
@@ -410,7 +415,7 @@ export class KeyChain implements Startable {
 
     const dsname = DsName(name)
     try {
-      const res = await this.components.getDatastore().get(dsname)
+      const res = await this.components.datastore.get(dsname)
       const pem = uint8ArrayToString(res)
       const cached = privates.get(this)
 
@@ -445,7 +450,7 @@ export class KeyChain implements Startable {
       throw errCode(new Error('PEM encoded key is required'), codes.ERR_PEM_REQUIRED)
     }
     const dsname = DsName(name)
-    const exists = await this.components.getDatastore().has(dsname)
+    const exists = await this.components.datastore.has(dsname)
     if (exists) {
       await randomDelay()
       throw errCode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS)
@@ -479,7 +484,7 @@ export class KeyChain implements Startable {
       name: name,
       id: kid
     }
-    const batch = this.components.getDatastore().batch()
+    const batch = this.components.datastore.batch()
     batch.put(dsname, uint8ArrayFromString(pem))
     batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo)))
     await batch.commit()
@@ -505,7 +510,7 @@ export class KeyChain implements Startable {
       const privateKey = await unmarshalPrivateKey(peer.privateKey)
 
       const dsname = DsName(name)
-      const exists = await this.components.getDatastore().has(dsname)
+      const exists = await this.components.datastore.has(dsname)
       if (exists) {
         await randomDelay()
         throw errCode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS)
@@ -523,7 +528,7 @@ export class KeyChain implements Startable {
         name: name,
         id: peer.toString()
       }
-      const batch = this.components.getDatastore().batch()
+      const batch = this.components.datastore.batch()
       batch.put(dsname, uint8ArrayFromString(pem))
       batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo)))
       await batch.commit()
@@ -545,7 +550,7 @@ export class KeyChain implements Startable {
 
     try {
       const dsname = DsName(name)
-      const res = await this.components.getDatastore().get(dsname)
+      const res = await this.components.datastore.get(dsname)
       return uint8ArrayToString(res)
     } catch (err: any) {
       await randomDelay()
@@ -590,14 +595,14 @@ export class KeyChain implements Startable {
     privates.set(this, { dek: newDek })
     const keys = await this.listKeys()
     for (const key of keys) {
-      const res = await this.components.getDatastore().get(DsName(key.name))
+      const res = await this.components.datastore.get(DsName(key.name))
       const pem = uint8ArrayToString(res)
       const privateKey = await importKey(pem, oldDek)
       const password = newDek.toString()
       const keyAsPEM = await privateKey.export(password)
 
       // Update stored key
-      const batch = this.components.getDatastore().batch()
+      const batch = this.components.datastore.batch()
       const keyInfo = {
         name: key.name,
         id: key.id

package/src/libp2p.ts

@@ -26,8 +26,8 @@ import { PeerRecordUpdater } from './peer-record-updater.js'
 import { DHTPeerRouting } from './dht/dht-peer-routing.js'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { DHTContentRouting } from './dht/dht-content-routing.js'
-import { AutoDialer } from './connection-manager/dialer/auto-dialer.js'
-import { Initializable, Components, isInitializable } from '@libp2p/components'
+import { DefaultComponents } from './components.js'
+import type { Components } from './components.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Connection } from '@libp2p/interface-connection'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
@@ -71,15 +71,13 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
   private started: boolean
   private readonly services: Startable[]
-  private readonly initializables: Initializable[]
 
   constructor (init: Libp2pInit) {
     super()
 
-    this.initializables = []
     this.started = false
     this.peerId = init.peerId
-    this.components = new Components({
+    const components = this.components = new DefaultComponents({
       peerId: init.peerId,
       datastore: init.datastore ?? new MemoryDatastore(),
       connectionGater: {
@@ -95,21 +93,21 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
         ...init.connectionGater
       }
     })
-    this.components.setPeerStore(new PersistentPeerStore({
-      addressFilter: this.components.getConnectionGater().filterMultiaddrForPeer,
+    components.peerStore = new PersistentPeerStore(components, {
+      addressFilter: this.components.connectionGater.filterMultiaddrForPeer,
       ...init.peerStore
-    }))
+    })
 
     this.services = [
-      this.components
+      components
     ]
 
     // Create Metrics
     if (init.metrics.enabled) {
-      this.metrics = this.components.setMetrics(new DefaultMetrics(init.metrics))
+      this.metrics = this.components.metrics = new DefaultMetrics(init.metrics)
     }
 
-    this.peerStore = this.components.getPeerStore()
+    this.peerStore = this.components.peerStore
 
     this.peerStore.addEventListener('peer', evt => {
       const { detail: peerData } = evt
@@ -119,30 +117,30 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     // Set up connection protector if configured
     if (init.connectionProtector != null) {
-      this.components.setConnectionProtector(init.connectionProtector)
+      this.components.connectionProtector = init.connectionProtector(components)
     }
 
     // Set up the Upgrader
-    this.components.setUpgrader(new DefaultUpgrader(this.components, {
-      connectionEncryption: (init.connectionEncryption ?? []).map(component => this.configureComponent(component)),
-      muxers: (init.streamMuxers ?? []).map(component => this.configureComponent(component)),
+    this.components.upgrader = new DefaultUpgrader(this.components, {
+      connectionEncryption: (init.connectionEncryption ?? []).map(fn => this.configureComponent(fn(this.components))),
+      muxers: (init.streamMuxers ?? []).map(fn => this.configureComponent(fn(this.components))),
       inboundUpgradeTimeout: init.connectionManager.inboundUpgradeTimeout
-    }))
+    })
 
     // Create the dialer
-    this.components.setDialer(new DefaultDialer(this.components, init.connectionManager))
+    this.components.dialer = new DefaultDialer(this.components, init.connectionManager)
 
     // Create the Connection Manager
-    this.connectionManager = this.components.setConnectionManager(new DefaultConnectionManager(init.connectionManager))
+    this.connectionManager = this.components.connectionManager = new DefaultConnectionManager(this.components, init.connectionManager)
 
     // Create the Registrar
-    this.registrar = this.components.setRegistrar(new DefaultRegistrar(this.components))
+    this.registrar = this.components.registrar = new DefaultRegistrar(this.components)
 
     // Setup the transport manager
-    this.components.setTransportManager(new DefaultTransportManager(this.components, init.transportManager))
+    this.components.transportManager = new DefaultTransportManager(this.components, init.transportManager)
 
     // Addresses {listen, announce, noAnnounce}
-    this.components.setAddressManager(new DefaultAddressManager(this.components, init.addresses))
+    this.components.addressManager = new DefaultAddressManager(this.components, init.addresses)
 
     // update our peer record when addresses change
     this.configureComponent(new PeerRecordUpdater(this.components))
@@ -163,29 +161,26 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     // Create the Nat Manager
     this.services.push(new NatManager(this.components, init.nat))
 
-    init.transports.forEach((transport) => {
-      this.components.getTransportManager().add(this.configureComponent(transport))
+    init.transports.forEach((fn) => {
+      this.components.transportManager.add(this.configureComponent(fn(this.components)))
     })
 
-    // Attach stream multiplexers
-    if (init.streamMuxers != null && init.streamMuxers.length > 0) {
-      // Add the identify service since we can multiplex
-      this.identifyService = new IdentifyService(this.components, {
-        ...init.identify
-      })
-      this.configureComponent(this.identifyService)
-    }
+    // Add the identify service
+    this.identifyService = new IdentifyService(this.components, {
+      ...init.identify
+    })
+    this.configureComponent(this.identifyService)
 
     // dht provided components (peerRouting, contentRouting, dht)
     if (init.dht != null) {
-      this.dht = this.components.setDHT(init.dht)
+      this.dht = this.components.dht = init.dht(this.components)
     } else {
       this.dht = new DummyDHT()
     }
 
     // Create pubsub if provided
     if (init.pubsub != null) {
-      this.pubsub = this.components.setPubSub(init.pubsub)
+      this.pubsub = this.components.pubsub = init.pubsub(this.components)
     } else {
       this.pubsub = new DummyPubSub()
     }
@@ -193,7 +188,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     // Attach remaining APIs
     // peer and content routing will automatically get modules from _modules and _dht
 
-    const peerRouters: PeerRouting[] = (init.peerRouters ?? []).map(component => this.configureComponent(component))
+    const peerRouters: PeerRouting[] = (init.peerRouters ?? []).map(fn => this.configureComponent(fn(this.components)))
 
     if (init.dht != null) {
       // add dht to routers
@@ -205,24 +200,24 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       })
     }
 
-    this.peerRouting = this.components.setPeerRouting(this.configureComponent(new DefaultPeerRouting(this.components, {
+    this.peerRouting = this.components.peerRouting = this.configureComponent(new DefaultPeerRouting(this.components, {
       ...init.peerRouting,
       routers: peerRouters
-    })))
+    }))
 
-    const contentRouters: ContentRouting[] = (init.contentRouters ?? []).map(component => this.configureComponent(component))
+    const contentRouters: ContentRouting[] = (init.contentRouters ?? []).map(fn => this.configureComponent(fn(this.components)))
 
     if (init.dht != null) {
       // add dht to routers
       contentRouters.push(this.configureComponent(new DHTContentRouting(this.dht)))
     }
 
-    this.contentRouting = this.components.setContentRouting(this.configureComponent(new CompoundContentRouting(this.components, {
+    this.contentRouting = this.components.contentRouting = this.configureComponent(new CompoundContentRouting(this.components, {
       routers: contentRouters
-    })))
+    }))
 
     if (init.relay.enabled) {
-      this.components.getTransportManager().add(this.configureComponent(new Circuit(init.relay)))
+      this.components.transportManager.add(this.configureComponent(new Circuit(this.components, init.relay)))
 
       this.configureComponent(new Relay(this.components, {
         addressSorter: init.connectionManager.addressSorter,
@@ -238,23 +233,9 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       ...init.ping
     }))
 
-    const autoDialer = this.configureComponent(new AutoDialer(this.components, {
-      enabled: init.connectionManager.autoDial !== false,
-      minConnections: init.connectionManager.minConnections,
-      dialTimeout: init.connectionManager.dialTimeout ?? 30000
-    }))
-
-    this.addEventListener('peer:discovery', evt => {
-      if (!this.isStarted()) {
-        return
-      }
-
-      autoDialer.handle(evt)
-    })
-
     // Discovery modules
-    for (const service of init.peerDiscovery ?? []) {
-      this.configureComponent(service)
+    for (const fn of init.peerDiscovery ?? []) {
+      const service = this.configureComponent(fn(this.components))
 
       service.addEventListener('peer', (evt) => {
         this.onDiscoveryPeer(evt)
@@ -267,10 +248,6 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       this.services.push(component)
     }
 
-    if (isInitializable(component)) {
-      this.initializables.push(component)
-    }
-
     return component
   }
 
@@ -287,11 +264,6 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     log('libp2p is starting')
 
     try {
-      // Set available components on all modules interested in components
-      this.initializables.forEach(obj => {
-        obj.init(this.components)
-      })
-
       await Promise.all(
         this.services.map(async service => {
           if (service.beforeStart != null) {
@@ -361,13 +333,13 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   getConnections (peerId?: PeerId): Connection[] {
-    return this.components.getConnectionManager().getConnections(peerId)
+    return this.components.connectionManager.getConnections(peerId)
   }
 
   getPeers (): PeerId[] {
     const peerSet = new PeerSet()
 
-    for (const conn of this.components.getConnectionManager().getConnections()) {
+    for (const conn of this.components.connectionManager.getConnections()) {
       peerSet.add(conn.remotePeer)
     }
 
@@ -377,9 +349,9 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   async dial (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<Connection> {
     const { id, multiaddrs } = getPeer(peer)
 
-    await this.components.getPeerStore().addressBook.add(id, multiaddrs)
+    await this.components.peerStore.addressBook.add(id, multiaddrs)
 
-    return await this.components.getConnectionManager().openConnection(id, options)
+    return await this.components.connectionManager.openConnection(id, options)
   }
 
   async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}) {
@@ -399,13 +371,13 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   }
 
   getMultiaddrs (): Multiaddr[] {
-    return this.components.getAddressManager().getAddresses()
+    return this.components.addressManager.getAddresses()
   }
 
   async hangUp (peer: PeerId | Multiaddr | string): Promise<void> {
     const { id } = getPeer(peer)
 
-    await this.components.getConnectionManager().closeConnections(id)
+    await this.components.connectionManager.closeConnections(id)
   }
 
   /**
@@ -451,7 +423,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     const { id, multiaddrs } = getPeer(peer)
 
     if (multiaddrs != null) {
-      await this.components.getPeerStore().addressBook.add(id, multiaddrs)
+      await this.components.peerStore.addressBook.add(id, multiaddrs)
     }
 
     return await this.fetchService.fetch(id, key, options)
@@ -461,7 +433,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     const { id, multiaddrs } = getPeer(peer)
 
     if (multiaddrs.length > 0) {
-      await this.components.getPeerStore().addressBook.add(id, multiaddrs)
+      await this.components.peerStore.addressBook.add(id, multiaddrs)
     }
 
     return await this.pingService.ping(id, options)
@@ -474,7 +446,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     await Promise.all(
       protocols.map(async protocol => {
-        await this.components.getRegistrar().handle(protocol, handler, options)
+        await this.components.registrar.handle(protocol, handler, options)
       })
     )
   }
@@ -486,7 +458,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
     await Promise.all(
       protocols.map(async protocol => {
-        await this.components.getRegistrar().unhandle(protocol)
+        await this.components.registrar.unhandle(protocol)
       })
     )
   }
@@ -504,11 +476,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     }
 
     if (peer.multiaddrs.length > 0) {
-      void this.components.getPeerStore().addressBook.add(peer.id, peer.multiaddrs).catch(err => log.error(err))
+      void this.components.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => log.error(err))
     }
 
     if (peer.protocols.length > 0) {
-      void this.components.getPeerStore().protoBook.set(peer.id, peer.protocols).catch(err => log.error(err))
+      void this.components.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => log.error(err))
     }
 
     this.dispatchEvent(new CustomEvent<PeerInfo>('peer:discovery', { detail: peer }))

package/src/nat-manager.ts

@@ -8,7 +8,9 @@ import errCode from 'err-code'
 import { codes } from './errors.js'
 import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/components'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 
 const log = logger('libp2p:nat')
 const DEFAULT_TTL = 7200
@@ -61,8 +63,14 @@ export interface NatManagerInit {
   gateway?: string
 }
 
+export interface NatManagerComponents {
+  peerId: PeerId
+  transportManager: TransportManager
+  addressManager: AddressManager
+}
+
 export class NatManager implements Startable {
-  private readonly components: Components
+  private readonly components: NatManagerComponents
   private readonly enabled: boolean
   private readonly externalAddress?: string
   private readonly localAddress?: string
@@ -73,14 +81,14 @@ export class NatManager implements Startable {
   private started: boolean
   private client?: NatAPI
 
-  constructor (components: Components, init: NatManagerInit) {
+  constructor (components: NatManagerComponents, init: NatManagerInit) {
     this.components = components
 
     this.started = false
     this.enabled = init.enabled
     this.externalAddress = init.externalAddress
     this.localAddress = init.localAddress
-    this.description = init.description ?? `${pkg.name}@${pkg.version} ${this.components.getPeerId().toString()}`
+    this.description = init.description ?? `${pkg.name}@${pkg.version} ${this.components.peerId.toString()}`
     this.ttl = init.ttl ?? DEFAULT_TTL
     this.keepAlive = init.keepAlive ?? true
     this.gateway = init.gateway
@@ -116,7 +124,7 @@ export class NatManager implements Startable {
   }
 
   async _start () {
-    const addrs = this.components.getTransportManager().getAddrs()
+    const addrs = this.components.transportManager.getAddrs()
 
     for (const addr of addrs) {
       // try to open uPnP ports for each thin waist address
@@ -157,7 +165,7 @@ export class NatManager implements Startable {
         protocol: transport.toUpperCase() === 'TCP' ? 'TCP' : 'UDP'
       })
 
-      this.components.getAddressManager().addObservedAddr(fromNodeAddress({
+      this.components.addressManager.addObservedAddr(fromNodeAddress({
         family: 4,
         address: publicIp,
         port: publicPort

package/src/peer-record-updater.ts

@@ -1,16 +1,26 @@
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
-import type { Components } from '@libp2p/components'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { logger } from '@libp2p/logger'
 import { protocols } from '@multiformats/multiaddr'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { AddressManager } from '@libp2p/interface-address-manager'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 
 const log = logger('libp2p:peer-record-updater')
 
+export interface PeerRecordUpdaterComponents {
+  peerId: PeerId
+  peerStore: PeerStore
+  transportManager: TransportManager
+  addressManager: AddressManager
+}
+
 export class PeerRecordUpdater implements Startable {
-  private readonly components: Components
+  private readonly components: PeerRecordUpdaterComponents
   private started: boolean
 
-  constructor (components: Components) {
+  constructor (components: PeerRecordUpdaterComponents) {
     this.components = components
     this.started = false
     this.update = this.update.bind(this)
@@ -22,16 +32,16 @@ export class PeerRecordUpdater implements Startable {
 
   async start () {
     this.started = true
-    this.components.getTransportManager().addEventListener('listener:listening', this.update)
-    this.components.getTransportManager().addEventListener('listener:close', this.update)
-    this.components.getAddressManager().addEventListener('change:addresses', this.update)
+    this.components.transportManager.addEventListener('listener:listening', this.update)
+    this.components.transportManager.addEventListener('listener:close', this.update)
+    this.components.addressManager.addEventListener('change:addresses', this.update)
   }
 
   async stop () {
     this.started = false
-    this.components.getTransportManager().removeEventListener('listener:listening', this.update)
-    this.components.getTransportManager().removeEventListener('listener:close', this.update)
-    this.components.getAddressManager().removeEventListener('change:addresses', this.update)
+    this.components.transportManager.removeEventListener('listener:listening', this.update)
+    this.components.transportManager.removeEventListener('listener:close', this.update)
+    this.components.addressManager.removeEventListener('change:addresses', this.update)
   }
 
   /**
@@ -41,12 +51,12 @@ export class PeerRecordUpdater implements Startable {
     Promise.resolve()
       .then(async () => {
         const peerRecord = new PeerRecord({
-          peerId: this.components.getPeerId(),
-          multiaddrs: this.components.getAddressManager().getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
+          peerId: this.components.peerId,
+          multiaddrs: this.components.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
         })
 
-        const envelope = await RecordEnvelope.seal(peerRecord, this.components.getPeerId())
-        await this.components.getPeerStore().addressBook.consumePeerRecord(envelope)
+        const envelope = await RecordEnvelope.seal(peerRecord, this.components.peerId)
+        await this.components.peerStore.addressBook.consumePeerRecord(envelope)
       })
       .catch(err => {
         log.error('Could not update self peer record: %o', err)