@libp2p/kad-dht 13.1.1 → 13.1.2-35b48025c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/kad-dht",
-  "version": "13.1.1",
+  "version": "13.1.2-35b48025c",
   "description": "JavaScript implementation of the Kad-DHT for libp2p",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/kad-dht#readme",
@@ -57,13 +57,13 @@
     "doc-check": "aegir doc-check"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.0.4",
-    "@libp2p/interface": "^2.1.2",
-    "@libp2p/interface-internal": "^2.0.6",
-    "@libp2p/peer-collections": "^6.0.6",
-    "@libp2p/peer-id": "^5.0.4",
-    "@libp2p/record": "^4.0.4",
-    "@libp2p/utils": "^6.0.6",
+    "@libp2p/crypto": "5.0.4-35b48025c",
+    "@libp2p/interface": "2.1.2-35b48025c",
+    "@libp2p/interface-internal": "2.0.6-35b48025c",
+    "@libp2p/peer-collections": "6.0.6-35b48025c",
+    "@libp2p/peer-id": "5.0.4-35b48025c",
+    "@libp2p/record": "4.0.4-35b48025c",
+    "@libp2p/utils": "6.0.6-35b48025c",
     "@multiformats/multiaddr": "^12.2.3",
     "any-signal": "^4.1.1",
     "hashlru": "^2.3.0",
@@ -89,9 +89,9 @@
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/interface-compliance-tests": "^6.1.4",
-    "@libp2p/logger": "^5.1.0",
-    "@libp2p/peer-store": "^11.0.6",
+    "@libp2p/interface-compliance-tests": "6.1.4-35b48025c",
+    "@libp2p/logger": "5.1.0-35b48025c",
+    "@libp2p/peer-store": "11.0.6-35b48025c",
     "@types/lodash.random": "^3.2.9",
     "@types/lodash.range": "^3.2.9",
     "@types/sinon": "^17.0.3",

package/src/index.ts

@@ -397,12 +397,10 @@ export interface KadDHTInit {
   logPrefix?: string
 
   /**
-   * How long to wait in ms when pinging DHT peers to decide if they
-   * should be evicted from the routing table or not.
-   *
-   * @default 10000
+   * Settings for how long to wait in ms when pinging DHT peers to decide if
+   * they should be evicted from the routing table or not.
    */
-  pingTimeout?: number
+  pingTimeout?: Omit<AdaptiveTimeoutInit, 'metricsName' | 'metrics'>
 
   /**
    * How many peers to ping in parallel when deciding if they should

package/src/kad-dht.ts

@@ -161,7 +161,9 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
       pingTimeout,
       pingConcurrency,
       protocol: this.protocol,
-      logPrefix: loggingPrefix
+      logPrefix: loggingPrefix,
+      prefixLength: init.prefixLength,
+      splitThreshold: init.kBucketSplitThreshold
     })
 
     this.providers = new Providers(components, providersInit ?? {})

package/src/network.ts

@@ -11,7 +11,7 @@ import {
   queryErrorEvent
 } from './query/events.js'
 import type { KadDHTComponents, QueryEvent } from './index.js'
-import type { AbortOptions, Logger, Stream, PeerId, PeerInfo, Startable, RoutingOptions } from '@libp2p/interface'
+import type { AbortOptions, Logger, Stream, PeerId, PeerInfo, Startable, RoutingOptions, CounterGroup } from '@libp2p/interface'
 
 export interface NetworkInit {
   protocol: string
@@ -32,6 +32,10 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   private running: boolean
   private readonly components: KadDHTComponents
   private readonly timeout: AdaptiveTimeout
+  private readonly metrics: {
+    operations?: CounterGroup
+    errors?: CounterGroup
+  }
 
   /**
    * Create a new network
@@ -49,6 +53,10 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       metrics: components.metrics,
       metricName: `${init.logPrefix.replaceAll(':', '_')}_network_message_send_times_milliseconds`
     })
+    this.metrics = {
+      operations: components.metrics?.registerCounterGroup(`${init.logPrefix.replaceAll(':', '_')}_outbound_rpc_requests_total`),
+      errors: components.metrics?.registerCounterGroup(`${init.logPrefix.replaceAll(':', '_')}_outbound_rpc_errors_total`)
+    }
   }
 
   /**
@@ -103,6 +111,8 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
     }
 
     try {
+      this.metrics.operations?.increment({ [type]: true })
+
       const connection = await this.components.connectionManager.openConnection(to, options)
       stream = await connection.newStream(this.protocol, options)
       const response = await this._writeReadMessage(stream, msg, options)
@@ -121,6 +131,8 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
         record: response.record == null ? undefined : Libp2pRecord.deserialize(response.record)
       }, options)
     } catch (err: any) {
+      this.metrics.errors?.increment({ [type]: true })
+
       stream?.abort(err)
 
       // only log if the incoming signal was not aborted - this means we were
@@ -162,6 +174,8 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
     }
 
     try {
+      this.metrics.operations?.increment({ [type]: true })
+
       const connection = await this.components.connectionManager.openConnection(to, options)
       stream = await connection.newStream(this.protocol, options)
 
@@ -175,6 +189,8 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
 
       yield peerResponseEvent({ from: to, messageType: type }, options)
     } catch (err: any) {
+      this.metrics.errors?.increment({ [type]: true })
+
       stream?.abort(err)
       yield queryErrorEvent({ from: to, error: err }, options)
     } finally {

package/src/query/manager.ts

@@ -12,7 +12,7 @@ import { queryPath } from './query-path.js'
 import type { QueryFunc } from './types.js'
 import type { QueryEvent } from '../index.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { ComponentLogger, Metric, Metrics, PeerId, RoutingOptions, Startable } from '@libp2p/interface'
+import type { ComponentLogger, Counter, Metric, Metrics, PeerId, RoutingOptions, Startable } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { DeferredPromise } from 'p-defer'
 
@@ -52,16 +52,16 @@ export class QueryManager implements Startable {
   private readonly alpha: number
   private shutDownController: AbortController
   private running: boolean
-  private queries: number
   private readonly logger: ComponentLogger
   private readonly peerId: PeerId
   private readonly connectionManager: ConnectionManager
   private readonly routingTable: RoutingTable
   private initialQuerySelfHasRun?: DeferredPromise<void>
   private readonly logPrefix: string
-  private readonly metrics?: {
-    runningQueries: Metric
-    queryTime: Metric
+  private readonly metrics: {
+    queries?: Counter
+    errors?: Counter
+    queryTime?: Metric
   }
 
   constructor (components: QueryManagerComponents, init: QueryManagerInit) {
@@ -71,18 +71,16 @@ export class QueryManager implements Startable {
     this.disjointPaths = disjointPaths ?? K
     this.running = false
     this.alpha = alpha ?? ALPHA
-    this.queries = 0
     this.initialQuerySelfHasRun = init.initialQuerySelfHasRun
     this.routingTable = init.routingTable
     this.logger = components.logger
     this.peerId = components.peerId
     this.connectionManager = components.connectionManager
 
-    if (components.metrics != null) {
-      this.metrics = {
-        runningQueries: components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_running_queries`),
-        queryTime: components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_query_time_seconds`)
-      }
+    this.metrics = {
+      queries: components.metrics?.registerCounter(`${logPrefix.replaceAll(':', '_')}_queries_total`),
+      errors: components.metrics?.registerCounter(`${logPrefix.replaceAll(':', '_')}_query_errors_total`),
+      queryTime: components.metrics?.registerMetric(`${logPrefix.replaceAll(':', '_')}_query_time_seconds`)
     }
 
     // allow us to stop queries on shut down
@@ -121,7 +119,7 @@ export class QueryManager implements Startable {
       throw new Error('QueryManager not started')
     }
 
-    const stopQueryTimer = this.metrics?.queryTime.timer()
+    const stopQueryTimer = this.metrics.queryTime?.timer()
 
     if (options.signal == null) {
       // don't let queries run forever
@@ -167,8 +165,7 @@ export class QueryManager implements Startable {
       }
 
       log('query:start')
-      this.queries++
-      this.metrics?.runningQueries.update(this.queries)
+      this.metrics?.queries?.increment()
 
       const id = await convertBuffer(key)
       const peers = this.routingTable.closestPeers(id)
@@ -223,6 +220,10 @@ export class QueryManager implements Startable {
 
       queryFinished = true
     } catch (err: any) {
+      if (!queryFinished) {
+        this.metrics?.errors?.increment()
+      }
+
       if (!this.running && err.name === 'QueryAbortedError') {
         // ignore query aborted errors that were thrown during query manager shutdown
       } else {
@@ -236,13 +237,7 @@ export class QueryManager implements Startable {
 
       signal.clear()
 
-      this.queries--
-      this.metrics?.runningQueries.update(this.queries)
-
-      if (stopQueryTimer != null) {
-        stopQueryTimer()
-      }
-
+      stopQueryTimer?.()
       log('query:done in %dms', Date.now() - startTime)
     }
   }

package/src/routing-table/index.ts

@@ -1,19 +1,21 @@
-import { InvalidMessageError, TypedEventEmitter } from '@libp2p/interface'
+import { InvalidMessageError, KEEP_ALIVE, TypedEventEmitter } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
+import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { pbStream } from 'it-protobuf-stream'
 import { Message, MessageType } from '../message/dht.js'
 import * as utils from '../utils.js'
 import { KBucket, isLeafBucket, type Bucket, type PingEventDetails } from './k-bucket.js'
-import type { ComponentLogger, Logger, Metric, Metrics, PeerId, PeerStore, Startable, Stream } from '@libp2p/interface'
+import type { ComponentLogger, CounterGroup, Logger, Metric, Metrics, PeerId, PeerStore, Startable, Stream } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
 
 export const KAD_CLOSE_TAG_NAME = 'kad-close'
 export const KAD_CLOSE_TAG_VALUE = 50
 export const KBUCKET_SIZE = 20
 export const PREFIX_LENGTH = 32
-export const PING_TIMEOUT = 10000
-export const PING_CONCURRENCY = 10
+export const PING_TIMEOUT = 2000
+export const PING_CONCURRENCY = 20
 
 export interface RoutingTableInit {
   logPrefix: string
@@ -21,7 +23,7 @@ export interface RoutingTableInit {
   prefixLength?: number
   splitThreshold?: number
   kBucketSize?: number
-  pingTimeout?: number
+  pingTimeout?: AdaptiveTimeoutInit
   pingConcurrency?: number
   tagName?: string
   tagValue?: number
@@ -53,7 +55,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   private readonly components: RoutingTableComponents
   private readonly prefixLength: number
   private readonly splitThreshold: number
-  private readonly pingTimeout: number
+  private readonly pingTimeout: AdaptiveTimeout
   private readonly pingConcurrency: number
   private running: boolean
   private readonly protocol: string
@@ -64,6 +66,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     routingTableKadBucketTotal: Metric
     routingTableKadBucketAverageOccupancy: Metric
     routingTableKadBucketMaxDepth: Metric
+    kadBucketEvents: CounterGroup<'ping' | 'ping_error' | 'peer_added' | 'peer_removed'>
   }
 
   constructor (components: RoutingTableComponents, init: RoutingTableInit) {
@@ -72,7 +75,6 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.components = components
     this.log = components.logger.forComponent(`${init.logPrefix}:routing-table`)
     this.kBucketSize = init.kBucketSize ?? KBUCKET_SIZE
-    this.pingTimeout = init.pingTimeout ?? PING_TIMEOUT
     this.pingConcurrency = init.pingConcurrency ?? PING_CONCURRENCY
     this.running = false
     this.protocol = init.protocol
@@ -89,13 +91,19 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.pingQueue.addEventListener('error', evt => {
       this.log.error('error pinging peer', evt.detail)
     })
+    this.pingTimeout = new AdaptiveTimeout({
+      ...(init.pingTimeout ?? {}),
+      metrics: this.components.metrics,
+      metricName: `${init.logPrefix.replaceAll(':', '_')}_routing_table_ping_time_milliseconds`
+    })
 
     if (this.components.metrics != null) {
       this.metrics = {
         routingTableSize: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_size`),
         routingTableKadBucketTotal: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_total`),
         routingTableKadBucketAverageOccupancy: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_average_occupancy`),
-        routingTableKadBucketMaxDepth: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_max_depth`)
+        routingTableKadBucketMaxDepth: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_max_depth`),
+        kadBucketEvents: this.components.metrics.registerCounterGroup(`${init.logPrefix.replaceAll(':', '_')}_kad_bucket_events_total`)
       }
     }
   }
@@ -121,7 +129,10 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     // test whether to evict peers
     kBuck.addEventListener('ping', (evt) => {
+      this.metrics?.kadBucketEvents.increment({ ping: true })
+
       this._onPing(evt).catch(err => {
+        this.metrics?.kadBucketEvents.increment({ ping_error: true })
         this.log.error('could not process k-bucket ping event', err)
       })
     })
@@ -172,6 +183,9 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
               tags: {
                 [this.tagName]: {
                   value: this.tagValue
+                },
+                [KEEP_ALIVE]: {
+                  value: 1
                 }
               }
             })
@@ -180,7 +194,8 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
           for (const peer of removedPeers) {
             await this.components.peerStore.merge(peer, {
               tags: {
-                [this.tagName]: undefined
+                [this.tagName]: undefined,
+                [KEEP_ALIVE]: undefined
               }
             })
           }
@@ -195,11 +210,13 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     kBuck.addEventListener('added', (evt) => {
       updatePeerTags()
 
+      this.metrics?.kadBucketEvents.increment({ peer_added: true })
       this.safeDispatchEvent('peer:add', { detail: evt.detail.peerId })
     })
     kBuck.addEventListener('removed', (evt) => {
       updatePeerTags()
 
+      this.metrics?.kadBucketEvents.increment({ peer_removed: true })
       this.safeDispatchEvent('peer:remove', { detail: evt.detail.peerId })
     })
   }
@@ -235,43 +252,48 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
         return this.pingQueue.add(async () => {
           let stream: Stream | undefined
+          const signal = this.pingTimeout.getTimeoutSignal()
 
           try {
             const options = {
-              signal: AbortSignal.timeout(this.pingTimeout)
+              signal
             }
 
             this.log('pinging old contact %p', oldContact.peerId)
             const connection = await this.components.connectionManager.openConnection(oldContact.peerId, options)
             stream = await connection.newStream(this.protocol, options)
 
-            const pb = pbStream(stream)
+            const pb = pbStream(stream).pb(Message)
             await pb.write({
-              type: MessageType.PING
-            }, Message, options)
-            const response = await pb.read(Message, options)
+              type: MessageType.PING,
+              closer: [],
+              providers: []
+            }, options)
+            const response = await pb.read(options)
 
-            await pb.unwrap().close()
+            await pb.unwrap().unwrap().close(options)
 
             if (response.type !== MessageType.PING) {
               throw new InvalidMessageError(`Incorrect message type received, expected PING got ${response.type}`)
             }
 
+            this.log('old contact %p ping ok', oldContact.peerId)
             return true
           } catch (err: any) {
-            if (this.running && this.kb != null) {
+            if (this.running) {
               // only evict peers if we are still running, otherwise we evict
               // when dialing is cancelled due to shutdown in progress
-              this.log.error('could not ping peer %p', oldContact.peerId, err)
+              this.log.error('could not ping peer %p - %e', oldContact.peerId, err)
               this.log('evicting old contact after ping failed %p', oldContact.peerId)
-              this.kb.remove(oldContact.kadId)
+              this.kb?.remove(oldContact.kadId)
             }
 
             stream?.abort(err)
 
             return false
           } finally {
-            this.metrics?.routingTableSize.update(this.size)
+            this.pingTimeout.cleanUp(signal)
+            this.updateMetrics()
           }
         }, {
           peerId: oldContact.peerId

package/dist/typedoc-urls.json

@@ -1,56 +0,0 @@
-{
-  "codec": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad_dht.MessageType.codec.html",
-  "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-1.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",
-  "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",
-  "PeerInfoMapper": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.PeerInfoMapper.html",
-  ".:PeerInfoMapper": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.PeerInfoMapper.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",
-  "ProvidersInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad_dht.ProvidersInit.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",
-  "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",
-  "passthroughMapper": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad_dht.passthroughMapper.html",
-  "removePrivateAddressesMapper": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad_dht.removePrivateAddressesMapper.html",
-  "removePublicAddressesMapper": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad_dht.removePublicAddressesMapper.html"
-}