@libp2p/kad-dht 10.0.15 → 11.0.0-06e6d235f

package/src/routing-table/refresh.ts

@@ -1,5 +1,4 @@
 import { randomBytes } from '@libp2p/crypto'
-import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import length from 'it-length'
 import { sha256 } from 'multiformats/hashes/sha2'
@@ -8,14 +7,17 @@ import { TABLE_REFRESH_INTERVAL, TABLE_REFRESH_QUERY_TIMEOUT } from '../constant
 import GENERATED_PREFIXES from './generated-prefix-list.js'
 import type { RoutingTable } from './index.js'
 import type { PeerRouting } from '../peer-routing/index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Logger } from '@libp2p/logger'
+import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 
 /**
  * Cannot generate random KadIds longer than this + 1
  */
 const MAX_COMMON_PREFIX_LENGTH = 15
 
+export interface RoutingTableRefreshComponents {
+  logger: ComponentLogger
+}
+
 export interface RoutingTableRefreshInit {
   peerRouting: PeerRouting
   routingTable: RoutingTable
@@ -37,9 +39,9 @@ export class RoutingTableRefresh {
   private readonly commonPrefixLengthRefreshedAt: Date[]
   private refreshTimeoutId?: ReturnType<typeof setTimeout>
 
-  constructor (init: RoutingTableRefreshInit) {
+  constructor (components: RoutingTableRefreshComponents, init: RoutingTableRefreshInit) {
     const { peerRouting, routingTable, refreshInterval, refreshQueryTimeout, lan } = init
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table:refresh`)
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table:refresh`)
     this.peerRouting = peerRouting
     this.routingTable = routingTable
     this.refreshInterval = refreshInterval ?? TABLE_REFRESH_INTERVAL

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

@@ -1,12 +1,13 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import { CID } from 'multiformats/cid'
 import type { Message } from '../../message/index.js'
 import type { Providers } from '../../providers'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 
-const log = logger('libp2p:kad-dht:rpc:handlers:add-provider')
+export interface AddProviderComponents {
+  logger: ComponentLogger
+}
 
 export interface AddProviderHandlerInit {
   providers: Providers
@@ -14,14 +15,15 @@ export interface AddProviderHandlerInit {
 
 export class AddProviderHandler implements DHTMessageHandler {
   private readonly providers: Providers
+  private readonly log: Logger
 
-  constructor (init: AddProviderHandlerInit) {
-    const { providers } = init
-    this.providers = providers
+  constructor (components: AddProviderComponents, init: AddProviderHandlerInit) {
+    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:add-provider')
+    this.providers = init.providers
   }
 
   async handle (peerId: PeerId, msg: Message): Promise<Message | undefined> {
-    log('start')
+    this.log('start')
 
     if (msg.key == null || msg.key.length === 0) {
       throw new CodeError('Missing key', 'ERR_MISSING_KEY')
@@ -36,23 +38,23 @@ export class AddProviderHandler implements DHTMessageHandler {
     }
 
     if (msg.providerPeers == null || msg.providerPeers.length === 0) {
-      log.error('no providers found in message')
+      this.log.error('no providers found in message')
     }
 
     await Promise.all(
       msg.providerPeers.map(async (pi) => {
         // Ignore providers not from the originator
         if (!pi.id.equals(peerId)) {
-          log('invalid provider peer %p from %p', pi.id, peerId)
+          this.log('invalid provider peer %p from %p', pi.id, peerId)
           return
         }
 
         if (pi.multiaddrs.length < 1) {
-          log('no valid addresses for provider %p. Ignore', peerId)
+          this.log('no valid addresses for provider %p. Ignore', peerId)
           return
         }
 
-        log('received provider %p for %s (addrs %s)', peerId, cid, pi.multiaddrs.map((m) => m.toString()))
+        this.log('received provider %p for %s (addrs %s)', peerId, cid, pi.multiaddrs.map((m) => m.toString()))
 
         await this.providers.addProvider(cid, pi.id)
       })

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

@@ -1,4 +1,3 @@
-import { logger } from '@libp2p/logger'
 import { protocols } from '@multiformats/multiaddr'
 import { equals as uint8ArrayEquals } from 'uint8arrays'
 import { Message } from '../../message/index.js'
@@ -8,11 +7,8 @@ import {
 } from '../../utils.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { AddressManager } from '@libp2p/interface-internal/address-manager'
-
-const log = logger('libp2p:kad-dht:rpc:handlers:find-node')
+import type { ComponentLogger, Logger, PeerId, PeerInfo } from '@libp2p/interface'
+import type { AddressManager } from '@libp2p/interface-internal'
 
 export interface FindNodeHandlerInit {
   peerRouting: PeerRouting
@@ -22,17 +18,22 @@ export interface FindNodeHandlerInit {
 export interface FindNodeHandlerComponents {
   peerId: PeerId
   addressManager: AddressManager
+  logger: ComponentLogger
 }
 
 export class FindNodeHandler implements DHTMessageHandler {
   private readonly peerRouting: PeerRouting
   private readonly lan: boolean
-  private readonly components: FindNodeHandlerComponents
+  private readonly peerId: PeerId
+  private readonly addressManager: AddressManager
+  private readonly log: Logger
 
   constructor (components: FindNodeHandlerComponents, init: FindNodeHandlerInit) {
     const { peerRouting, lan } = init
 
-    this.components = components
+    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:find-node')
+    this.peerId = components.peerId
+    this.addressManager = components.addressManager
     this.peerRouting = peerRouting
     this.lan = Boolean(lan)
   }
@@ -41,15 +42,14 @@ export class FindNodeHandler implements DHTMessageHandler {
    * Process `FindNode` DHT messages
    */
   async handle (peerId: PeerId, msg: Message): Promise<Message> {
-    log('incoming request from %p for peers closer to %b', peerId, msg.key)
+    this.log('incoming request from %p for peers closer to %b', peerId, msg.key)
 
     let closer: PeerInfo[] = []
 
-    if (uint8ArrayEquals(this.components.peerId.toBytes(), msg.key)) {
+    if (uint8ArrayEquals(this.peerId.toBytes(), msg.key)) {
       closer = [{
-        id: this.components.peerId,
-        multiaddrs: this.components.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code)),
-        protocols: []
+        id: this.peerId,
+        multiaddrs: this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
       }]
     } else {
       closer = await this.peerRouting.getCloserPeersOffline(msg.key, peerId)
@@ -64,7 +64,7 @@ export class FindNodeHandler implements DHTMessageHandler {
     if (closer.length > 0) {
       response.closerPeers = closer
     } else {
-      log('could not find any peers closer to %b than %p', msg.key, peerId)
+      this.log('could not find any peers closer to %b than %p', msg.key, peerId)
     }
 
     return response

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

@@ -1,5 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import { CID } from 'multiformats/cid'
 import { Message } from '../../message/index.js'
 import {
@@ -9,13 +8,9 @@ import {
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { Providers } from '../../providers.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { ComponentLogger, Logger, PeerId, PeerInfo, PeerStore } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:kad-dht:rpc:handlers:get-providers')
-
 export interface GetProvidersHandlerInit {
   peerRouting: PeerRouting
   providers: Providers
@@ -24,18 +19,21 @@ export interface GetProvidersHandlerInit {
 
 export interface GetProvidersHandlerComponents {
   peerStore: PeerStore
+  logger: ComponentLogger
 }
 
 export class GetProvidersHandler implements DHTMessageHandler {
-  private readonly components: GetProvidersHandlerComponents
   private readonly peerRouting: PeerRouting
   private readonly providers: Providers
   private readonly lan: boolean
+  private readonly peerStore: PeerStore
+  private readonly log: Logger
 
   constructor (components: GetProvidersHandlerComponents, init: GetProvidersHandlerInit) {
     const { peerRouting, providers, lan } = init
 
-    this.components = components
+    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:get-providers')
+    this.peerStore = components.peerStore
     this.peerRouting = peerRouting
     this.providers = providers
     this.lan = Boolean(lan)
@@ -49,7 +47,7 @@ export class GetProvidersHandler implements DHTMessageHandler {
       throw new CodeError('Invalid CID', 'ERR_INVALID_CID')
     }
 
-    log('%p asking for providers for %s', peerId, cid)
+    this.log('%p asking for providers for %s', peerId, cid)
 
     const [peers, closer] = await Promise.all([
       this.providers.getProviders(cid),
@@ -68,7 +66,7 @@ export class GetProvidersHandler implements DHTMessageHandler {
       response.closerPeers = closerPeers
     }
 
-    log('got %s providers %s closerPeers', providerPeers.length, closerPeers.length)
+    this.log('got %s providers %s closerPeers', providerPeers.length, closerPeers.length)
     return response
   }
 
@@ -82,12 +80,11 @@ export class GetProvidersHandler implements DHTMessageHandler {
 
     for (const peerId of peerIds) {
       try {
-        const peer = await this.components.peerStore.get(peerId)
+        const peer = await this.peerStore.get(peerId)
 
         const peerAfterFilter = addrFilter({
           id: peerId,
-          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr),
-          protocols: peer.protocols
+          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
         })
 
         if (peerAfterFilter.multiaddrs.length > 0) {

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

@@ -1,5 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import {
   MAX_RECORD_AGE
 } from '../../constants.js'
@@ -8,12 +7,9 @@ import { Libp2pRecord } from '../../record/index.js'
 import { bufferToRecordKey, isPublicKeyKey, fromPublicKeyKey } from '../../utils.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { ComponentLogger, Logger, PeerId, PeerStore } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
 
-const log = logger('libp2p:kad-dht:rpc:handlers:get-value')
-
 export interface GetValueHandlerInit {
   peerRouting: PeerRouting
 }
@@ -21,23 +17,26 @@ export interface GetValueHandlerInit {
 export interface GetValueHandlerComponents {
   peerStore: PeerStore
   datastore: Datastore
+  logger: ComponentLogger
 }
 
 export class GetValueHandler implements DHTMessageHandler {
-  private readonly components: GetValueHandlerComponents
+  private readonly peerStore: PeerStore
+  private readonly datastore: Datastore
   private readonly peerRouting: PeerRouting
+  private readonly log: Logger
 
   constructor (components: GetValueHandlerComponents, init: GetValueHandlerInit) {
-    const { peerRouting } = init
-
-    this.components = components
-    this.peerRouting = peerRouting
+    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:get-value')
+    this.peerStore = components.peerStore
+    this.datastore = components.datastore
+    this.peerRouting = init.peerRouting
   }
 
   async handle (peerId: PeerId, msg: Message): Promise<Message> {
     const key = msg.key
 
-    log('%p asked for key %b', peerId, key)
+    this.log('%p asked for key %b', peerId, key)
 
     if (key == null || key.length === 0) {
       throw new CodeError('Invalid key', 'ERR_INVALID_KEY')
@@ -46,12 +45,12 @@ export class GetValueHandler implements DHTMessageHandler {
     const response = new Message(MESSAGE_TYPE.GET_VALUE, key, msg.clusterLevel)
 
     if (isPublicKeyKey(key)) {
-      log('is public key')
+      this.log('is public key')
       const idFromKey = fromPublicKeyKey(key)
       let pubKey: Uint8Array | undefined
 
       try {
-        const peer = await this.components.peerStore.get(idFromKey)
+        const peer = await this.peerStore.get(idFromKey)
 
         if (peer.id.publicKey == null) {
           throw new CodeError('No public key found in key book', 'ERR_NOT_FOUND')
@@ -65,7 +64,7 @@ export class GetValueHandler implements DHTMessageHandler {
       }
 
       if (pubKey != null) {
-        log('returning found public key')
+        this.log('returning found public key')
         response.record = new Libp2pRecord(key, pubKey, new Date())
         return response
       }
@@ -77,12 +76,12 @@ export class GetValueHandler implements DHTMessageHandler {
     ])
 
     if (record != null) {
-      log('had record for %b in local datastore', key)
+      this.log('had record for %b in local datastore', key)
       response.record = record
     }
 
     if (closer.length > 0) {
-      log('had %s closer peers in routing table', closer.length)
+      this.log('had %s closer peers in routing table', closer.length)
       response.closerPeers = closer
     }
 
@@ -96,13 +95,13 @@ export class GetValueHandler implements DHTMessageHandler {
    * - it was received less than `MAX_RECORD_AGE` ago.
    */
   async _checkLocalDatastore (key: Uint8Array): Promise<Libp2pRecord | undefined> {
-    log('checkLocalDatastore looking for %b', key)
+    this.log('checkLocalDatastore looking for %b', key)
     const dsKey = bufferToRecordKey(key)
 
     // Fetch value from ds
     let rawRecord
     try {
-      rawRecord = await this.components.datastore.get(dsKey)
+      rawRecord = await this.datastore.get(dsKey)
     } catch (err: any) {
       if (err.code === 'ERR_NOT_FOUND') {
         return undefined
@@ -121,7 +120,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.components.datastore.delete(dsKey)
+      await this.datastore.delete(dsKey)
       return undefined
     }
 

package/src/rpc/handlers/ping.ts

@@ -1,13 +1,20 @@
-import { logger } from '@libp2p/logger'
 import type { Message } from '../../message/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 
-const log = logger('libp2p:kad-dht:rpc:handlers:ping')
+export interface PingComponents {
+  logger: ComponentLogger
+}
 
 export class PingHandler implements DHTMessageHandler {
+  private readonly log: Logger
+
+  constructor (components: PingComponents) {
+    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:ping')
+  }
+
   async handle (peerId: PeerId, msg: Message): Promise<Message> {
-    log('ping from %p', peerId)
+    this.log('ping from %p', peerId)
     return msg
   }
 }

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

@@ -1,11 +1,10 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { type Logger, logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import { verifyRecord } from '../../record/validators.js'
 import { bufferToRecordKey } from '../../utils.js'
 import type { Validators } from '../../index.js'
 import type { Message } from '../../message/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
 
 export interface PutValueHandlerInit {
@@ -14,18 +13,19 @@ export interface PutValueHandlerInit {
 
 export interface PutValueHandlerComponents {
   datastore: Datastore
+  logger: ComponentLogger
 }
 
 export class PutValueHandler implements DHTMessageHandler {
-  private readonly log: Logger
   private readonly components: PutValueHandlerComponents
   private readonly validators: Validators
+  private readonly log: Logger
 
   constructor (components: PutValueHandlerComponents, init: PutValueHandlerInit) {
     const { validators } = init
 
     this.components = components
-    this.log = logger('libp2p:kad-dht:rpc:handlers:put-value')
+    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:put-value')
     this.validators = validators
   }
 

package/src/rpc/index.ts

@@ -1,4 +1,3 @@
-import { type Logger, logger } from '@libp2p/logger'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
 import { Message, MESSAGE_TYPE } from '../message/index.js'
@@ -12,8 +11,8 @@ import type { Validators } from '../index.js'
 import type { PeerRouting } from '../peer-routing'
 import type { Providers } from '../providers'
 import type { RoutingTable } from '../routing-table'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
+import type { Logger, PeerId } from '@libp2p/interface'
+import type { IncomingStreamData } from '@libp2p/interface-internal'
 
 export interface DHTMessageHandler {
   handle(peerId: PeerId, msg: Message): Promise<Message | undefined>
@@ -39,15 +38,15 @@ export class RPC {
   constructor (components: RPCComponents, init: RPCInit) {
     const { providers, peerRouting, validators, lan } = init
 
-    this.log = logger('libp2p:kad-dht:rpc')
+    this.log = components.logger.forComponent('libp2p:kad-dht:rpc')
     this.routingTable = init.routingTable
     this.handlers = {
       [MESSAGE_TYPE.GET_VALUE]: new GetValueHandler(components, { peerRouting }),
       [MESSAGE_TYPE.PUT_VALUE]: new PutValueHandler(components, { validators }),
       [MESSAGE_TYPE.FIND_NODE]: new FindNodeHandler(components, { peerRouting, lan }),
-      [MESSAGE_TYPE.ADD_PROVIDER]: new AddProviderHandler({ providers }),
+      [MESSAGE_TYPE.ADD_PROVIDER]: new AddProviderHandler(components, { providers }),
       [MESSAGE_TYPE.GET_PROVIDERS]: new GetProvidersHandler(components, { peerRouting, providers, lan }),
-      [MESSAGE_TYPE.PING]: new PingHandler()
+      [MESSAGE_TYPE.PING]: new PingHandler(components)
     }
   }
 

package/src/topology-listener.ts

@@ -1,9 +1,6 @@
-import { CustomEvent, TypedEventEmitter } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
+import { CustomEvent, TypedEventEmitter } from '@libp2p/interface'
 import type { KadDHTComponents } from '.'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Startable } from '@libp2p/interface/startable'
-import type { Logger } from '@libp2p/logger'
+import type { Logger, PeerId, Startable } from '@libp2p/interface'
 
 export interface TopologyListenerInit {
   protocol: string
@@ -30,7 +27,7 @@ export class TopologyListener extends TypedEventEmitter<TopologyListenerEvents>
     const { protocol, lan } = init
 
     this.components = components
-    this.log = logger(`libp2p:kad-dht:topology-listener:${lan ? 'lan' : 'wan'}`)
+    this.log = components.logger.forComponent(`libp2p:kad-dht:topology-listener:${lan ? 'lan' : 'wan'}`)
     this.running = false
     this.protocol = protocol
   }

package/src/utils.ts

@@ -7,8 +7,7 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { RECORD_KEY_PREFIX } from './constants.js'
 import { Libp2pRecord } from './record/index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerId, PeerInfo } from '@libp2p/interface'
 
 // const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
 const PK_PREFIX = uint8ArrayFromString('/pk/')

package/dist/typedoc-urls.json

@@ -1,55 +0,0 @@
-{
-  "EventTypes": "https://libp2p.github.io/js-libp2p/enums/_libp2p_kad_dht.EventTypes.html",
-  ".:EventTypes": "https://libp2p.github.io/js-libp2p/enums/_libp2p_kad_dht.EventTypes.html",
-  "MessageType": "https://libp2p.github.io/js-libp2p/enums/_libp2p_kad_dht.MessageType.html",
-  ".:MessageType": "https://libp2p.github.io/js-libp2p/enums/_libp2p_kad_dht.MessageType.html",
-  "Record": "https://libp2p.github.io/js-libp2p/classes/_libp2p_kad_dht.Record.html",
-  "AddPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.AddPeerEvent.html",
-  ".:AddPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.AddPeerEvent.html",
-  "DHTRecord": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.DHTRecord.html",
-  ".:DHTRecord": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.DHTRecord.html",
-  "DialPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.DialPeerEvent.html",
-  ".:DialPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.DialPeerEvent.html",
-  "DualKadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.DualKadDHT.html",
-  ".:DualKadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.DualKadDHT.html",
-  "FinalPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.FinalPeerEvent.html",
-  ".:FinalPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.FinalPeerEvent.html",
-  "KadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.KadDHT.html",
-  ".:KadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.KadDHT.html",
-  "KadDHTComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.KadDHTComponents.html",
-  ".:KadDHTComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.KadDHTComponents.html",
-  "KadDHTInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.KadDHTInit.html",
-  ".:KadDHTInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.KadDHTInit.html",
-  "PeerResponseEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.PeerResponseEvent.html",
-  ".:PeerResponseEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.PeerResponseEvent.html",
-  "ProviderEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.ProviderEvent.html",
-  ".:ProviderEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.ProviderEvent.html",
-  "QueryErrorEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.QueryErrorEvent.html",
-  ".:QueryErrorEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.QueryErrorEvent.html",
-  "QueryOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.QueryOptions.html",
-  ".:QueryOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.QueryOptions.html",
-  "RoutingTable": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.RoutingTable.html",
-  ".:RoutingTable": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.RoutingTable.html",
-  "SelectFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.SelectFn.html",
-  ".:SelectFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.SelectFn.html",
-  "SendQueryEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.SendQueryEvent.html",
-  ".:SendQueryEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.SendQueryEvent.html",
-  "SingleKadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.SingleKadDHT.html",
-  ".:SingleKadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.SingleKadDHT.html",
-  "ValidateFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.ValidateFn.html",
-  ".:ValidateFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.ValidateFn.html",
-  "ValueEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.ValueEvent.html",
-  ".:ValueEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.ValueEvent.html",
-  "DHTProgressEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.DHTProgressEvents.html",
-  ".:DHTProgressEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.DHTProgressEvents.html",
-  "MessageName": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.MessageName.html",
-  ".:MessageName": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.MessageName.html",
-  "QueryEvent": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.QueryEvent.html",
-  ".:QueryEvent": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.QueryEvent.html",
-  "Selectors": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.Selectors.html",
-  ".:Selectors": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.Selectors.html",
-  "Validators": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.Validators.html",
-  ".:Validators": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad_dht.Validators.html",
-  "kadDHT": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad_dht.kadDHT-1.html",
-  ".:kadDHT": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad_dht.kadDHT-1.html"
-}