@libp2p/kad-dht 0.28.7 → 1.0.2

package/src/query/query-path.ts

@@ -12,7 +12,6 @@ import type { EventEmitter } from '@libp2p/interfaces'
 import type { CleanUpEvents } from './manager.js'
 import type { Logger } from '@libp2p/logger'
 import type { QueryFunc } from '../query/types.js'
-import { base58btc } from 'multiformats/bases/base58'
 import type { QueryEvent } from '@libp2p/interfaces/dht'
 
 const MAX_XOR = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
@@ -101,7 +100,7 @@ export async function * queryPath (options: QueryPathOptions) {
       return
     }
 
-    peersSeen.add(peer.toString(base58btc))
+    peersSeen.add(peer.toString())
 
     const peerXor = BigInt('0x' + toString(xor(peerKadId, kadId), 'base16'))
 
@@ -131,7 +130,7 @@ export async function * queryPath (options: QueryPathOptions) {
           // if there are closer peers and the query has not completed, continue the query
           if (event.name === 'PEER_RESPONSE') {
             for (const closerPeer of event.closer) {
-              if (peersSeen.has(closerPeer.id.toString(base58btc))) { // eslint-disable-line max-depth
+              if (peersSeen.has(closerPeer.id.toString())) { // eslint-disable-line max-depth
                 log('already seen %p in query', closerPeer.id)
                 continue
               }

package/src/query-self.ts

@@ -7,12 +7,11 @@ import { TimeoutController } from 'timeout-abort-controller'
 import { anySignal } from 'any-signal'
 import { logger, Logger } from '@libp2p/logger'
 import type { PeerRouting } from './peer-routing/index.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { Startable } from '@libp2p/interfaces'
 import { pipe } from 'it-pipe'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
-export interface QuerySelfOptions {
-  peerId: PeerId
+export interface QuerySelfInit {
   lan: boolean
   peerRouting: PeerRouting
   count?: number
@@ -23,9 +22,9 @@ export interface QuerySelfOptions {
 /**
  * Receives notifications of new peers joining the network that support the DHT protocol
  */
-export class QuerySelf implements Startable {
+export class QuerySelf implements Startable, Initializable {
   private readonly log: Logger
-  private readonly peerId: PeerId
+  private components: Components = new Components()
   private readonly peerRouting: PeerRouting
   private readonly count: number
   private readonly interval: number
@@ -34,18 +33,21 @@ export class QuerySelf implements Startable {
   private timeoutId?: NodeJS.Timer
   private controller?: AbortController
 
-  constructor (options: QuerySelfOptions) {
-    const { peerId, peerRouting, lan, count, interval, queryTimeout } = options
+  constructor (init: QuerySelfInit) {
+    const { peerRouting, lan, count, interval, queryTimeout } = init
 
     this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:query-self`)
     this.running = false
-    this.peerId = peerId
     this.peerRouting = peerRouting
     this.count = count ?? K
     this.interval = interval ?? QUERY_SELF_INTERVAL
     this.queryTimeout = queryTimeout ?? QUERY_SELF_TIMEOUT
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   isStarted () {
     return this.running
   }
@@ -85,7 +87,7 @@ export class QuerySelf implements Startable {
           }
         } catch {} // fails on node < 15.4
         const found = await pipe(
-          this.peerRouting.getClosestPeers(this.peerId.toBytes(), {
+          this.peerRouting.getClosestPeers(this.components.getPeerId().toBytes(), {
             signal
           }),
           (source) => take(source, this.count),

package/src/routing-table/index.ts

@@ -6,9 +6,9 @@ import { PROTOCOL_DHT } from '../constants.js'
 import { TimeoutController } from 'timeout-abort-controller'
 import { logger } from '@libp2p/logger'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { Dialer, Startable } from '@libp2p/interfaces'
-import type { ComponentMetricsTracker } from '@libp2p/interfaces/metrics'
+import type { Startable } from '@libp2p/interfaces'
 import type { Logger } from '@libp2p/logger'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
 export interface KBucketPeer {
   id: Uint8Array
@@ -38,11 +38,8 @@ export interface KBucketTree {
 
 const METRIC_ROUTING_TABLE_SIZE = 'routing-table-size'
 
-export interface RoutingTableOptions {
-  peerId: PeerId
-  dialer: Dialer
+export interface RoutingTableInit {
   lan: boolean
-  metrics?: ComponentMetricsTracker
   kBucketSize?: number
   pingTimeout?: number
 }
@@ -51,34 +48,34 @@ export interface RoutingTableOptions {
  * A wrapper around `k-bucket`, to provide easy store and
  * retrieval for peers.
  */
-export class RoutingTable implements Startable {
+export class RoutingTable implements Startable, Initializable {
+  public kBucketSize: number
+  public kb?: KBucketTree
+  public pingQueue: Queue
+
   private readonly log: Logger
-  private readonly peerId: PeerId
-  public dialer: Dialer
+  private components: Components = new Components()
   private readonly lan: boolean
-  private readonly metrics?: ComponentMetricsTracker
-  public kBucketSize: number
   private readonly pingTimeout: number
-  public kb?: KBucketTree
   private running: boolean
-  public pingQueue: Queue
 
-  constructor (options: RoutingTableOptions) {
-    const { peerId, dialer, kBucketSize, pingTimeout, lan, metrics } = options
+  constructor (init: RoutingTableInit) {
+    const { kBucketSize, pingTimeout, lan } = init
 
     this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table`)
-    this.peerId = peerId
-    this.dialer = dialer
     this.kBucketSize = kBucketSize ?? 20
     this.pingTimeout = pingTimeout ?? 10000
     this.lan = lan
-    this.metrics = metrics
     this.pingQueue = new Queue({ concurrency: 1 })
     this.running = false
 
     this._onPing = this._onPing.bind(this)
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   isStarted () {
     return this.running
   }
@@ -87,7 +84,7 @@ export class RoutingTable implements Startable {
     this.running = true
 
     const kBuck = new KBuck({
-      localNodeId: await utils.convertPeerId(this.peerId),
+      localNodeId: await utils.convertPeerId(this.components.getPeerId()),
       numberOfNodesPerKBucket: this.kBucketSize,
       numberOfNodesToPing: 1
     })
@@ -131,7 +128,7 @@ export class RoutingTable implements Startable {
               timeoutController = new TimeoutController(this.pingTimeout)
 
               this.log('pinging old contact %p', oldContact.peer)
-              const { stream } = await this.dialer.dialProtocol(oldContact.peer, PROTOCOL_DHT, {
+              const { stream } = await this.components.getDialer().dialProtocol(oldContact.peer, PROTOCOL_DHT, {
                 signal: timeoutController.signal
               })
               await stream.close()
@@ -149,7 +146,7 @@ export class RoutingTable implements Startable {
                 timeoutController.clear()
               }
 
-              this.metrics?.updateComponentMetric({
+              this.components.getMetrics()?.updateComponentMetric({
                 system: 'libp2p',
                 component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
                 metric: METRIC_ROUTING_TABLE_SIZE,
@@ -235,7 +232,7 @@ export class RoutingTable implements Startable {
 
     this.log('added %p with kad id %b', peer, id)
 
-    this.metrics?.updateComponentMetric({
+    this.components.getMetrics()?.updateComponentMetric({
       system: 'libp2p',
       component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
       metric: METRIC_ROUTING_TABLE_SIZE,
@@ -255,7 +252,7 @@ export class RoutingTable implements Startable {
 
     this.kb.remove(id)
 
-    this.metrics?.updateComponentMetric({
+    this.components.getMetrics()?.updateComponentMetric({
       system: 'libp2p',
       component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
       metric: METRIC_ROUTING_TABLE_SIZE,

package/src/routing-table/refresh.ts

@@ -10,13 +10,14 @@ import { TABLE_REFRESH_INTERVAL, TABLE_REFRESH_QUERY_TIMEOUT } from '../constant
 import type { RoutingTable } from './index.js'
 import type { Logger } from '@libp2p/logger'
 import type { PeerRouting } from '../peer-routing/index.js'
+import type { Components, Initializable } from '@libp2p/interfaces/components'
 
 /**
  * Cannot generate random KadIds longer than this + 1
  */
 const MAX_COMMON_PREFIX_LENGTH = 15
 
-export interface RoutingTableRefreshOptions {
+export interface RoutingTableRefreshInit {
   peerRouting: PeerRouting
   routingTable: RoutingTable
   lan: boolean
@@ -28,7 +29,7 @@ export interface RoutingTableRefreshOptions {
  * A wrapper around `k-bucket`, to provide easy store and
  * retrieval for peers.
  */
-export class RoutingTableRefresh {
+export class RoutingTableRefresh implements Initializable {
   private readonly log: Logger
   private readonly peerRouting: PeerRouting
   private readonly routingTable: RoutingTable
@@ -37,8 +38,8 @@ export class RoutingTableRefresh {
   private readonly commonPrefixLengthRefreshedAt: Date[]
   private refreshTimeoutId?: NodeJS.Timer
 
-  constructor (options: RoutingTableRefreshOptions) {
-    const { peerRouting, routingTable, refreshInterval, refreshQueryTimeout, lan } = options
+  constructor (init: RoutingTableRefreshInit) {
+    const { peerRouting, routingTable, refreshInterval, refreshQueryTimeout, lan } = init
     this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table:refresh`)
     this.peerRouting = peerRouting
     this.routingTable = routingTable
@@ -49,6 +50,10 @@ export class RoutingTableRefresh {
     this.refreshTable = this.refreshTable.bind(this)
   }
 
+  init (components: Components): void {
+
+  }
+
   async start () {
     this.log(`refreshing routing table every ${this.refreshInterval}ms`)
     this.refreshTable(true)

package/src/rpc/handlers/add-provider.ts

@@ -5,21 +5,26 @@ import type { Providers } from '../../providers'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { DHTMessageHandler } from '../index.js'
 import type { Message } from '../../message/index.js'
+import type { Initializable } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:add-provider')
 
-export interface AddProviderHandlerOptions {
+export interface AddProviderHandlerInit {
   providers: Providers
 }
 
-export class AddProviderHandler implements DHTMessageHandler {
+export class AddProviderHandler implements DHTMessageHandler, Initializable {
   private readonly providers: Providers
 
-  constructor (options: AddProviderHandlerOptions) {
-    const { providers } = options
+  constructor (init: AddProviderHandlerInit) {
+    const { providers } = init
     this.providers = providers
   }
 
+  init (): void {
+
+  }
+
   async handle (peerId: PeerId, msg: Message) {
     log('start')
 

package/src/rpc/handlers/find-node.ts

@@ -11,24 +11,29 @@ import type { PeerId } from '@libp2p/interfaces/peer-id'
 import map from 'it-map'
 import filter from 'it-filter'
 import all from 'it-all'
+import type { Initializable } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:find-node')
 
-export interface FindNodeHandlerOptions {
+export interface FindNodeHandlerInit {
   peerRouting: PeerRouting
   lan: boolean
 }
 
-export class FindNodeHandler implements DHTMessageHandler {
+export class FindNodeHandler implements DHTMessageHandler, Initializable {
   private readonly peerRouting: PeerRouting
   private readonly lan: boolean
 
-  constructor (options: FindNodeHandlerOptions) {
-    const { peerRouting, lan } = options
+  constructor (init: FindNodeHandlerInit) {
+    const { peerRouting, lan } = init
     this.peerRouting = peerRouting
     this.lan = Boolean(lan)
   }
 
+  init (): void {
+
+  }
+
   /**
    * Process `FindNode` DHT messages
    */

package/src/rpc/handlers/get-providers.ts

@@ -8,35 +8,37 @@ import {
 import { logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
 import type { Providers } from '../../providers.js'
-import type { AddressBook } from '@libp2p/interfaces/peer-store'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { PeerData } from '@libp2p/interfaces/peer-data'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-providers')
 
-export interface GetProvidersHandlerOptions {
+export interface GetProvidersHandlerInit {
   peerRouting: PeerRouting
   providers: Providers
-  addressBook: AddressBook
   lan: boolean
 }
 
-export class GetProvidersHandler implements DHTMessageHandler {
+export class GetProvidersHandler implements DHTMessageHandler, Initializable {
+  private components: Components = new Components()
   private readonly peerRouting: PeerRouting
   private readonly providers: Providers
-  private readonly addressBook: AddressBook
   private readonly lan: boolean
 
-  constructor (options: GetProvidersHandlerOptions) {
-    const { peerRouting, providers, addressBook, lan } = options
+  constructor (init: GetProvidersHandlerInit) {
+    const { peerRouting, providers, lan } = init
 
     this.peerRouting = peerRouting
     this.providers = providers
-    this.addressBook = addressBook
     this.lan = Boolean(lan)
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   async handle (peerId: PeerId, msg: Message) {
     let cid
     try {
@@ -69,7 +71,7 @@ export class GetProvidersHandler implements DHTMessageHandler {
   }
 
   async _getAddresses (peerId: PeerId) {
-    const addrs = await this.addressBook.get(peerId)
+    const addrs = await this.components.getPeerStore().addressBook.get(peerId)
 
     return addrs.map(address => address.multiaddr)
   }

package/src/rpc/handlers/get-value.ts

@@ -7,30 +7,28 @@ import {
 import { bufferToRecordKey, isPublicKeyKey, fromPublicKeyKey } from '../../utils.js'
 import { logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
-import type { Datastore } from 'interface-datastore'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { KeyBook } from '@libp2p/interfaces/peer-store'
 import type { PeerRouting } from '../../peer-routing/index.js'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-value')
 
-export interface GetValueHandlerOptions {
-  keyBook: KeyBook
+export interface GetValueHandlerInit {
   peerRouting: PeerRouting
-  datastore: Datastore
 }
 
-export class GetValueHandler implements DHTMessageHandler {
-  private readonly keyBook: KeyBook
+export class GetValueHandler implements DHTMessageHandler, Initializable {
+  private components: Components = new Components()
   private readonly peerRouting: PeerRouting
-  private readonly datastore: Datastore
 
-  constructor (options: GetValueHandlerOptions) {
-    const { keyBook, peerRouting, datastore } = options
+  constructor (init: GetValueHandlerInit) {
+    const { peerRouting } = init
 
-    this.keyBook = keyBook
     this.peerRouting = peerRouting
-    this.datastore = datastore
+  }
+
+  init (components: Components): void {
+    this.components = components
   }
 
   async handle (peerId: PeerId, msg: Message) {
@@ -50,7 +48,7 @@ export class GetValueHandler implements DHTMessageHandler {
       let pubKey: Uint8Array | undefined
 
       try {
-        const key = await this.keyBook.get(idFromKey)
+        const key = await this.components.getPeerStore().keyBook.get(idFromKey)
 
         if (key == null) {
           throw errcode(new Error('No public key found in key book'), 'ERR_NOT_FOUND')
@@ -101,7 +99,7 @@ export class GetValueHandler implements DHTMessageHandler {
     // Fetch value from ds
     let rawRecord
     try {
-      rawRecord = await this.datastore.get(dsKey)
+      rawRecord = await this.components.getDatastore().get(dsKey)
     } catch (err: any) {
       if (err.code === 'ERR_NOT_FOUND') {
         return undefined
@@ -120,7 +118,7 @@ export class GetValueHandler implements DHTMessageHandler {
     if (record.timeReceived == null ||
       Date.now() - record.timeReceived.getTime() > MAX_RECORD_AGE) {
       // If record is bad delete it and return
-      await this.datastore.delete(dsKey)
+      await this.components.getDatastore().delete(dsKey)
       return undefined
     }
 

package/src/rpc/handlers/ping.ts

@@ -2,12 +2,17 @@ import { logger } from '@libp2p/logger'
 import type { Message } from '../../message/index.js'
 import type { DHTMessageHandler } from '../index.js'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Initializable } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:ping')
 
-export class PingHandler implements DHTMessageHandler {
+export class PingHandler implements DHTMessageHandler, Initializable {
   async handle (peerId: PeerId, msg: Message) {
     log('ping from %p', peerId)
     return msg
   }
+
+  init (): void {
+
+  }
 }

package/src/rpc/handlers/put-value.ts

@@ -4,29 +4,28 @@ import { verifyRecord } from '@libp2p/record/validators'
 import { Logger, logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
 import type { Validators } from '@libp2p/interfaces/dht'
-import type { Datastore } from 'interface-datastore'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { Message } from '../../message/index.js'
-import { base58btc } from 'multiformats/bases/base58'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
-export interface PutValueHandlerOptions {
-  peerId: PeerId
+export interface PutValueHandlerInit {
   validators: Validators
-  datastore: Datastore
 }
 
-export class PutValueHandler implements DHTMessageHandler {
-  private readonly validators: Validators
-  private readonly datastore: Datastore
+export class PutValueHandler implements DHTMessageHandler, Initializable {
   private readonly log: Logger
+  private components: Components = new Components()
+  private readonly validators: Validators
 
-  constructor (options: PutValueHandlerOptions) {
-    const { validators, datastore, peerId } = options
-
-    this.log = logger('libp2p:kad-dht:rpc:handlers:put-value:' + peerId.toString())
+  constructor (init: PutValueHandlerInit) {
+    const { validators } = init
 
+    this.log = logger('libp2p:kad-dht:rpc:handlers:put-value')
     this.validators = validators
-    this.datastore = datastore
+  }
+
+  init (components: Components): void {
+    this.components = components
   }
 
   async handle (peerId: PeerId, msg: Message) {
@@ -36,7 +35,7 @@ export class PutValueHandler implements DHTMessageHandler {
     const record = msg.record
 
     if (record == null) {
-      const errMsg = `Empty record from: ${peerId.toString(base58btc)}`
+      const errMsg = `Empty record from: ${peerId.toString()}`
 
       this.log.error(errMsg)
       throw errcode(new Error(errMsg), 'ERR_EMPTY_RECORD')
@@ -47,7 +46,7 @@ export class PutValueHandler implements DHTMessageHandler {
 
       record.timeReceived = new Date()
       const recordKey = bufferToRecordKey(record.key)
-      await this.datastore.put(recordKey, record.serialize())
+      await this.components.getDatastore().put(recordKey, record.serialize())
       this.log('put record for %b into datastore under key %k', key, recordKey)
     } catch (err: any) {
       this.log('did not put record for key %b into datastore %o', key, err)

package/src/rpc/index.ts

@@ -11,49 +11,50 @@ import { GetValueHandler } from './handlers/get-value.js'
 import { PingHandler } from './handlers/ping.js'
 import { PutValueHandler } from './handlers/put-value.js'
 import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
-import type { KeyBook, AddressBook } from '@libp2p/interfaces/peer-store'
 import type { Providers } from '../providers'
 import type { PeerRouting } from '../peer-routing'
-import type { Datastore } from 'interface-datastore'
 import type { Validators } from '@libp2p/interfaces/dht'
+import type { Components, Initializable } from '@libp2p/interfaces/components'
 
 export interface DHTMessageHandler {
   handle: (peerId: PeerId, msg: Message) => Promise<Message | undefined>
 }
 
-export interface RPCOptions {
-  peerId: PeerId
+export interface RPCInit {
   routingTable: RoutingTable
-  keyBook: KeyBook
-  addressBook: AddressBook
   providers: Providers
   peerRouting: PeerRouting
-  datastore: Datastore
   validators: Validators
   lan: boolean
 }
 
-export class RPC {
-  private readonly handlers: Record<number, DHTMessageHandler>
+export class RPC implements Initializable {
+  private readonly handlers: Record<number, DHTMessageHandler & Initializable>
   private readonly routingTable: RoutingTable
   private readonly log: Logger
 
-  constructor (options: RPCOptions) {
-    const { keyBook, addressBook, providers, peerRouting, datastore, validators, lan, peerId } = options
+  constructor (init: RPCInit) {
+    const { providers, peerRouting, validators, lan } = init
 
-    this.log = logger('libp2p:kad-dht:rpc:' + peerId.toString())
+    this.log = logger('libp2p:kad-dht:rpc')
 
-    this.routingTable = options.routingTable
+    this.routingTable = init.routingTable
     this.handlers = {
-      [MESSAGE_TYPE.GET_VALUE]: new GetValueHandler({ keyBook, peerRouting, datastore }),
-      [MESSAGE_TYPE.PUT_VALUE]: new PutValueHandler({ peerId, validators, datastore }),
+      [MESSAGE_TYPE.GET_VALUE]: new GetValueHandler({ peerRouting }),
+      [MESSAGE_TYPE.PUT_VALUE]: new PutValueHandler({ validators }),
       [MESSAGE_TYPE.FIND_NODE]: new FindNodeHandler({ peerRouting, lan }),
       [MESSAGE_TYPE.ADD_PROVIDER]: new AddProviderHandler({ providers }),
-      [MESSAGE_TYPE.GET_PROVIDERS]: new GetProvidersHandler({ peerRouting, providers, addressBook, lan }),
+      [MESSAGE_TYPE.GET_PROVIDERS]: new GetProvidersHandler({ peerRouting, providers, lan }),
       [MESSAGE_TYPE.PING]: new PingHandler()
     }
   }
 
+  init (components: Components): void {
+    for (const handler of Object.values(this.handlers)) {
+      handler.init(components)
+    }
+  }
+
   /**
    * Process incoming DHT messages
    */
@@ -78,9 +79,9 @@ export class RPC {
   /**
    * Handle incoming streams on the dht protocol
    */
-  onIncomingStream (evt: CustomEvent<IncomingStreamData>) {
+  onIncomingStream (data: IncomingStreamData) {
     Promise.resolve().then(async () => {
-      const { stream, connection } = evt.detail
+      const { stream, connection } = data
       const peerId = connection.remotePeer
 
       try {

package/src/topology-listener.ts

@@ -1,13 +1,12 @@
 import { createTopology } from '@libp2p/topology'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces'
 import { logger } from '@libp2p/logger'
-import type { Registrar } from '@libp2p/interfaces/registrar'
 import type { Logger } from '@libp2p/logger'
 import type { Startable } from '@libp2p/interfaces'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
-export interface TopologyListenerOptions {
-  registrar: Registrar
+export interface TopologyListenerInit {
   protocol: string
   lan: boolean
 }
@@ -19,24 +18,27 @@ export interface TopologyListenerEvents {
 /**
  * Receives notifications of new peers joining the network that support the DHT protocol
  */
-export class TopologyListener extends EventEmitter<TopologyListenerEvents> implements Startable {
+export class TopologyListener extends EventEmitter<TopologyListenerEvents> implements Startable, Initializable {
   private readonly log: Logger
-  private readonly registrar: Registrar
+  private components: Components = new Components()
   private readonly protocol: string
   private running: boolean
   private registrarId?: string
 
-  constructor (options: TopologyListenerOptions) {
+  constructor (init: TopologyListenerInit) {
     super()
 
-    const { registrar, protocol, lan } = options
+    const { protocol, lan } = init
 
     this.log = logger(`libp2p:kad-dht:topology-listener:${lan ? 'lan' : 'wan'}`)
     this.running = false
-    this.registrar = registrar
     this.protocol = protocol
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   isStarted () {
     return this.running
   }
@@ -60,7 +62,7 @@ export class TopologyListener extends EventEmitter<TopologyListenerEvents> imple
         }))
       }
     })
-    this.registrarId = await this.registrar.register(this.protocol, topology)
+    this.registrarId = await this.components.getRegistrar().register(this.protocol, topology)
   }
 
   /**
@@ -71,7 +73,7 @@ export class TopologyListener extends EventEmitter<TopologyListenerEvents> imple
 
     // unregister protocol and handlers
     if (this.registrarId != null) {
-      this.registrar.unregister(this.registrarId)
+      this.components.getRegistrar().unregister(this.registrarId)
       this.registrarId = undefined
     }
   }