@libp2p/kad-dht 15.1.2 → 15.1.3-6c42ea64a

package/src/routing-table/k-bucket.ts

@@ -1,4 +1,4 @@
-import { PeerMap } from '@libp2p/peer-collections'
+import { PeerMap, trackedPeerMap } from '@libp2p/peer-collections'
 import map from 'it-map'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
@@ -6,7 +6,7 @@ import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { PeerDistanceList } from '../peer-distance-list.js'
 import { convertPeerId } from '../utils.js'
 import { KBUCKET_SIZE, LAST_PING_THRESHOLD, PING_OLD_CONTACT_COUNT, PREFIX_LENGTH } from './index.js'
-import type { PeerId, AbortOptions } from '@libp2p/interface'
+import type { PeerId, AbortOptions, Metrics } from '@libp2p/interface'
 
 export interface PingFunction {
   /**
@@ -28,21 +28,26 @@ export interface OnAddCallback {
   /**
    * Invoked when a new peer is added to the routing tables
    */
-  (peer: Peer, bucket: LeafBucket): Promise<void>
+  (peer: Peer, bucket: LeafBucket, options?: AbortOptions): Promise<void>
 }
 
 export interface OnRemoveCallback {
   /**
    * Invoked when a peer is evicted from the routing tables
    */
-  (peer: Peer, bucket: LeafBucket): Promise<void>
+  (peer: Peer, bucket: LeafBucket, options?: AbortOptions): Promise<void>
 }
 
 export interface OnMoveCallback {
   /**
    * Invoked when a peer is moved between buckets in the routing tables
    */
-  (peer: Peer, oldBucket: LeafBucket, newBucket: LeafBucket): Promise<void>
+  (peer: Peer, oldBucket: LeafBucket, newBucket: LeafBucket, options?: AbortOptions): Promise<void>
+}
+
+export interface KBucketComponents {
+  peerId: PeerId
+  metrics?: Metrics
 }
 
 export interface KBucketOptions {
@@ -97,6 +102,7 @@ export interface KBucketOptions {
   verify: VerifyFunction
   onAdd?: OnAddCallback
   onRemove?: OnRemoveCallback
+  metricsPrefix?: string
 }
 
 export interface Peer {
@@ -124,11 +130,17 @@ export function isLeafBucket (obj: any): obj is LeafBucket {
   return Array.isArray(obj?.peers)
 }
 
+export interface GetClosestPeersOptions extends AbortOptions {
+  count?: number
+  exclude?: PeerId[]
+}
+
 /**
  * Implementation of a Kademlia DHT routing table as a prefix binary trie with
  * configurable prefix length, bucket split threshold and size.
  */
 export class KBucket {
+  private readonly peerId: PeerId
   public root: Bucket
   public localPeer?: Peer
   private readonly prefixLength: number
@@ -143,7 +155,8 @@ export class KBucket {
   private readonly onMove?: OnMoveCallback
   private readonly addingPeerMap: PeerMap<Promise<void>>
 
-  constructor (options: KBucketOptions) {
+  constructor (components: KBucketComponents, options: KBucketOptions) {
+    this.peerId = components.peerId
     this.prefixLength = options.prefixLength ?? PREFIX_LENGTH
     this.kBucketSize = options.kBucketSize ?? KBUCKET_SIZE
     this.splitThreshold = options.splitThreshold ?? this.kBucketSize
@@ -153,7 +166,10 @@ export class KBucket {
     this.verify = options.verify
     this.onAdd = options.onAdd
     this.onRemove = options.onRemove
-    this.addingPeerMap = new PeerMap()
+    this.addingPeerMap = trackedPeerMap({
+      name: `${options.metricsPrefix}_adding_peer_map`,
+      metrics: components.metrics
+    })
 
     this.root = {
       prefix: '',
@@ -162,10 +178,24 @@ export class KBucket {
     }
   }
 
-  async addSelfPeer (peerId: PeerId): Promise<void> {
+  async start (): Promise<void> {
+    await this.addSelfPeer(this.peerId)
+  }
+
+  stop (): void {
+    this.addingPeerMap.clear()
+
+    this.root = {
+      prefix: '',
+      depth: 0,
+      peers: []
+    }
+  }
+
+  async addSelfPeer (peerId: PeerId, options?: AbortOptions): Promise<void> {
     this.localPeer = {
       peerId,
-      kadId: await convertPeerId(peerId),
+      kadId: await convertPeerId(peerId, options),
       lastPing: Date.now()
     }
   }
@@ -176,7 +206,7 @@ export class KBucket {
   async add (peerId: PeerId, options?: AbortOptions): Promise<void> {
     const peer = {
       peerId,
-      kadId: await convertPeerId(peerId),
+      kadId: await convertPeerId(peerId, options),
       lastPing: 0
     }
 
@@ -206,7 +236,7 @@ export class KBucket {
     // are there too many peers in the bucket and can we make the trie deeper?
     if (bucket.peers.length === this.splitThreshold && bucket.depth < this.prefixLength) {
       // split the bucket
-      await this._split(bucket)
+      await this._split(bucket, options)
 
       // try again
       await this._add(peer, options)
@@ -219,7 +249,7 @@ export class KBucket {
       // we've ping this peer previously, just add them to the bucket
       if (!needsPing(peer, this.lastPingThreshold)) {
         bucket.peers.push(peer)
-        await this.onAdd?.(peer, bucket)
+        await this.onAdd?.(peer, bucket, options)
         return
       }
 
@@ -274,7 +304,7 @@ export class KBucket {
 
     for await (const toEvict of this.ping(toPing, options)) {
       evicted = true
-      await this.remove(toEvict.kadId)
+      await this.remove(toEvict.kadId, options)
     }
 
     // did not evict any peers, cannot add new contact
@@ -293,10 +323,14 @@ export class KBucket {
    * @param {Uint8Array} id - Contact node id
    * @returns {Generator<Peer, void, undefined>} Array Maximum of n closest contacts to the node id
    */
-  * closest (id: Uint8Array, n: number = this.kBucketSize): Generator<PeerId, void, undefined> {
-    const list = new PeerDistanceList(id, n)
+  * closest (id: Uint8Array, options?: GetClosestPeersOptions): Generator<PeerId, void, undefined> {
+    const list = new PeerDistanceList(id, options?.count ?? this.kBucketSize)
 
     for (const peer of this.toIterable()) {
+      if (options?.exclude?.some(p => p.equals(peer.peerId)) === true) {
+        continue
+      }
+
       list.addWithKadId({ id: peer.peerId, multiaddrs: [] }, peer.kadId)
     }
 
@@ -351,14 +385,14 @@ export class KBucket {
    *
    * @param {Uint8Array} kadId - The ID of the contact to remove
    */
-  async remove (kadId: Uint8Array): Promise<void> {
+  async remove (kadId: Uint8Array, options?: AbortOptions): Promise<void> {
     const bucket = this._determineBucket(kadId)
     const index = this._indexOf(bucket, kadId)
 
     if (index > -1) {
       const peer = bucket.peers.splice(index, 1)[0]
 
-      await this.onRemove?.(peer, bucket)
+      await this.onRemove?.(peer, bucket, options)
     }
   }
 
@@ -439,7 +473,7 @@ export class KBucket {
    *
    * @param {any} bucket - bucket for splitting
    */
-  private async _split (bucket: LeafBucket): Promise<void> {
+  private async _split (bucket: LeafBucket, options?: AbortOptions): Promise<void> {
     // create child buckets
     const left: LeafBucket = {
       prefix: '0',
@@ -458,10 +492,10 @@ export class KBucket {
 
       if (bitString[bucket.depth] === '0') {
         left.peers.push(peer)
-        await this.onMove?.(peer, bucket, left)
+        await this.onMove?.(peer, bucket, left, options)
       } else {
         right.peers.push(peer)
-        await this.onMove?.(peer, bucket, right)
+        await this.onMove?.(peer, bucket, right, options)
       }
     }
 

package/src/routing-table/refresh.ts

@@ -1,7 +1,8 @@
 import { randomBytes } from '@libp2p/crypto'
-import { setMaxListeners } from '@libp2p/interface'
 import { peerIdFromMultihash } from '@libp2p/peer-id'
+import { anySignal } from 'any-signal'
 import length from 'it-length'
+import { setMaxListeners } from 'main-event'
 import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
@@ -9,7 +10,7 @@ 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 { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
+import type { AbortOptions, ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 
 /**
  * Cannot generate random KadIds longer than this + 1
@@ -70,7 +71,7 @@ export class RoutingTableRefresh {
    * that is close to the requested peer ID and query that, then network
    * peers will tell us who they know who is close to the fake ID
    */
-  refreshTable (force: boolean = false): void {
+  refreshTable (force: boolean = false, options?: AbortOptions): void {
     this.log('refreshing routing table')
 
     const prefixLength = this._maxCommonPrefix()
@@ -97,14 +98,14 @@ export class RoutingTableRefresh {
     Promise.all(
       refreshCommonPrefixLengths.map(async (lastRefresh, index) => {
         try {
-          await this._refreshCommonPrefixLength(index, lastRefresh, force)
+          await this._refreshCommonPrefixLength(index, lastRefresh, force, options)
 
           if (this._numPeersForCpl(prefixLength) === 0) {
             const lastCpl = Math.min(2 * (index + 1), refreshCommonPrefixLengths.length - 1)
 
             for (let n = index + 1; n < lastCpl + 1; n++) {
               try {
-                await this._refreshCommonPrefixLength(n, lastRefresh, force)
+                await this._refreshCommonPrefixLength(n, lastRefresh, force, options)
               } catch (err: any) {
                 this.log.error(err)
               }
@@ -127,26 +128,30 @@ export class RoutingTableRefresh {
     })
   }
 
-  async _refreshCommonPrefixLength (cpl: number, lastRefresh: Date, force: boolean): Promise<void> {
+  async _refreshCommonPrefixLength (cpl: number, lastRefresh: Date, force: boolean, options?: AbortOptions): Promise<void> {
     if (!force && lastRefresh.getTime() > (Date.now() - this.refreshInterval)) {
       this.log('not running refresh for cpl %s as time since last refresh not above interval', cpl)
       return
     }
 
     // gen a key for the query to refresh the cpl
-    const peerId = await this._generateRandomPeerId(cpl)
+    const peerId = this._generateRandomPeerId(cpl)
 
     this.log('starting refreshing cpl %s with key %p (routing table size was %s)', cpl, peerId, this.routingTable.size)
 
-    const signal = AbortSignal.timeout(this.refreshQueryTimeout)
+    const signal = anySignal([options?.signal, AbortSignal.timeout(this.refreshQueryTimeout)])
     setMaxListeners(Infinity, signal)
 
-    const peers = await length(this.peerRouting.getClosestPeers(peerId.toMultihash().bytes, {
-      signal
-    }))
+    try {
+      const peers = await length(this.peerRouting.getClosestPeers(peerId.toMultihash().bytes, {
+        signal
+      }))
 
-    this.log(`found ${peers} peers that were close to imaginary peer %p`, peerId)
-    this.log('finished refreshing cpl %s with key %p (routing table size is now %s)', cpl, peerId, this.routingTable.size)
+      this.log(`found ${peers} peers that were close to imaginary peer %p`, peerId)
+      this.log('finished refreshing cpl %s with key %p (routing table size is now %s)', cpl, peerId, this.routingTable.size)
+    } finally {
+      signal.clear()
+    }
   }
 
   _getTrackedCommonPrefixLengthsForRefresh (maxCommonPrefix: number): Date[] {
@@ -164,7 +169,7 @@ export class RoutingTableRefresh {
     return dates
   }
 
-  async _generateRandomPeerId (targetCommonPrefixLength: number): Promise<PeerId> {
+  _generateRandomPeerId (targetCommonPrefixLength: number): PeerId {
     if (this.routingTable.kb == null) {
       throw new Error('Routing table not started')
     }
@@ -176,13 +181,13 @@ export class RoutingTableRefresh {
     const randomData = randomBytes(2)
     const randomUint16 = (randomData[1] << 8) + randomData[0]
 
-    const key = await this._makePeerId(this.routingTable.kb.localPeer.kadId, randomUint16, targetCommonPrefixLength)
+    const key = this._makePeerId(this.routingTable.kb.localPeer.kadId, randomUint16, targetCommonPrefixLength)
     const multihash = Digest.decode(key)
 
     return peerIdFromMultihash(multihash)
   }
 
-  async _makePeerId (localKadId: Uint8Array, randomPrefix: number, targetCommonPrefixLength: number): Promise<Uint8Array> {
+  _makePeerId (localKadId: Uint8Array, randomPrefix: number, targetCommonPrefixLength: number): Uint8Array {
     if (targetCommonPrefixLength > MAX_COMMON_PREFIX_LENGTH) {
       throw new Error(`Cannot generate peer ID for common prefix length greater than ${MAX_COMMON_PREFIX_LENGTH}`)
     }

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

@@ -42,38 +42,52 @@ export class FindNodeHandler implements DHTMessageHandler {
    * Process `FindNode` DHT messages
    */
   async handle (peerId: PeerId, msg: Message): Promise<Message> {
-    this.log('incoming request from %p for peers closer to %b', peerId, msg.key)
+    this.log('incoming request from %p for peers close to %b', peerId, msg.key)
+    try {
+      if (msg.key == null) {
+        throw new InvalidMessageError('Invalid FIND_NODE message received - key was missing')
+      }
 
-    if (msg.key == null) {
-      throw new InvalidMessageError('Invalid FIND_NODE message received - key was missing')
-    }
-
-    const closer: PeerInfo[] = await this.peerRouting.getCloserPeersOffline(msg.key, peerId)
+      const closer: PeerInfo[] = await this.peerRouting.getClosestPeersOffline(msg.key, {
+        exclude: [
+        // never tell a peer about itself
+          peerId,
 
-    if (uint8ArrayEquals(this.peerId.toMultihash().bytes, msg.key)) {
-      closer.push({
-        id: this.peerId,
-        multiaddrs: this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
+          // do not include the server in the results
+          this.peerId
+        ]
       })
-    }
 
-    const response: Message = {
-      type: MessageType.FIND_NODE,
-      clusterLevel: msg.clusterLevel,
-      closer: closer
-        .map(this.peerInfoMapper)
-        .filter(({ multiaddrs }) => multiaddrs.length)
-        .map(peerInfo => ({
-          id: peerInfo.id.toMultihash().bytes,
-          multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
-        })),
-      providers: []
-    }
+      if (uint8ArrayEquals(this.peerId.toMultihash().bytes, msg.key)) {
+        closer.push({
+          id: this.peerId,
+          multiaddrs: this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
+        })
+      }
 
-    if (response.closer.length === 0) {
-      this.log('could not find any peers closer to %b than %p', msg.key, peerId)
-    }
+      const response: Message = {
+        type: MessageType.FIND_NODE,
+        clusterLevel: msg.clusterLevel,
+        closer: closer
+          .map(this.peerInfoMapper)
+          .filter(({ multiaddrs }) => multiaddrs.length)
+          .map(peerInfo => ({
+            id: peerInfo.id.toMultihash().bytes,
+            multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
+          })),
+        providers: []
+      }
+
+      if (response.closer.length === 0) {
+        this.log('could not find any peers closer to %b for %p', msg.key, peerId)
+      } else {
+        this.log('found %d peers close to %b for %p', response.closer.length, msg.key, peerId)
+      }
 
-    return response
+      return response
+    } catch (err: any) {
+      this.log('error during finding peers closer to %b for %p - %e', msg.key, peerId, err)
+      throw err
+    }
   }
 }

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

@@ -67,7 +67,7 @@ export class GetProvidersHandler implements DHTMessageHandler {
 
         return info
       })),
-      this.peerRouting.getCloserPeersOffline(msg.key, peerId)
+      this.peerRouting.getClosestPeersOffline(msg.key)
     ])
 
     const response: Message = {

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

@@ -84,7 +84,7 @@ export class GetValueHandler implements DHTMessageHandler {
 
     const [record, closer] = await Promise.all([
       this._checkLocalDatastore(key),
-      this.peerRouting.getCloserPeersOffline(key, peerId)
+      this.peerRouting.getClosestPeersOffline(key)
     ])
 
     if (record != null) {

package/src/rpc/index.ts

@@ -1,5 +1,5 @@
-import * as lp from 'it-length-prefixed'
-import { pipe } from 'it-pipe'
+import { TimeoutError } from '@libp2p/interface'
+import { pbStream } from 'it-protobuf-stream'
 import { Message, MessageType } from '../message/dht.js'
 import { AddProviderHandler } from './handlers/add-provider.js'
 import { FindNodeHandler } from './handlers/find-node.js'
@@ -15,7 +15,7 @@ import type { GetProvidersHandlerComponents } from './handlers/get-providers.js'
 import type { GetValueHandlerComponents } from './handlers/get-value.js'
 import type { PutValueHandlerComponents } from './handlers/put-value.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { CounterGroup, Logger, Metrics, PeerId, IncomingStreamData } from '@libp2p/interface'
+import type { CounterGroup, Logger, Metrics, PeerId, IncomingStreamData, MetricGroup } from '@libp2p/interface'
 
 export interface DHTMessageHandler {
   handle(peerId: PeerId, msg: Message): Promise<Message | undefined>
@@ -30,6 +30,7 @@ export interface RPCInit {
   metricsPrefix: string
   datastorePrefix: string
   peerInfoMapper: PeerInfoMapper
+  incomingMessageTimeout?: number
 }
 
 export interface RPCComponents extends GetValueHandlerComponents, PutValueHandlerComponents, FindNodeHandlerComponents, GetProvidersHandlerComponents {
@@ -38,21 +39,24 @@ export interface RPCComponents extends GetValueHandlerComponents, PutValueHandle
 
 export class RPC {
   private readonly handlers: Record<string, DHTMessageHandler>
-  private readonly routingTable: RoutingTable
   private readonly log: Logger
   private readonly metrics: {
     operations?: CounterGroup
     errors?: CounterGroup
+    rpcTime?: MetricGroup
   }
 
+  private readonly incomingMessageTimeout: number
+
   constructor (components: RPCComponents, init: RPCInit) {
     this.metrics = {
       operations: components.metrics?.registerCounterGroup(`${init.metricsPrefix}_inbound_rpc_requests_total`),
-      errors: components.metrics?.registerCounterGroup(`${init.metricsPrefix}_inbound_rpc_errors_total`)
+      errors: components.metrics?.registerCounterGroup(`${init.metricsPrefix}_inbound_rpc_errors_total`),
+      rpcTime: components.metrics?.registerMetricGroup(`${init.metricsPrefix}_inbound_rpc_time_seconds`, { label: 'operation' })
     }
 
     this.log = components.logger.forComponent(`${init.logPrefix}:rpc`)
-    this.routingTable = init.routingTable
+    this.incomingMessageTimeout = init.incomingMessageTimeout ?? 10_000
     this.handlers = {
       [MessageType.GET_VALUE.toString()]: new GetValueHandler(components, init),
       [MessageType.PUT_VALUE.toString()]: new PutValueHandler(components, init),
@@ -92,34 +96,61 @@ export class RPC {
    * Handle incoming streams on the dht protocol
    */
   onIncomingStream (data: IncomingStreamData): void {
-    let message = 'unknown'
+    const message = 'unknown'
 
     Promise.resolve().then(async () => {
       const { stream, connection } = data
-      const peerId = connection.remotePeer
 
-      const self = this
+      const abortListener = (): void => {
+        stream.abort(new TimeoutError())
+      }
+
+      let signal = AbortSignal.timeout(this.incomingMessageTimeout)
+      signal.addEventListener('abort', abortListener)
+
+      const messages = pbStream(stream).pb(Message)
+
+      try {
+        while (true) {
+          const message = await messages.read({
+            signal
+          })
 
-      await pipe(
-        stream,
-        (source) => lp.decode(source),
-        async function * (source) {
-          for await (const msg of source) {
+          const stopSuccessTimer = this.metrics?.rpcTime?.timer(message.type.toString())
+          const stopErrorTimer = this.metrics?.rpcTime?.timer(message.type.toString())
+          let errored = false
+
+          try {
             // handle the message
-            const desMessage = Message.decode(msg)
-            message = desMessage.type
-            self.log('incoming %s from %p', desMessage.type, peerId)
-            const res = await self.handleMessage(peerId, desMessage)
+            this.log('incoming %s from %p', message.type, connection.remotePeer)
+            const res = await this.handleMessage(connection.remotePeer, message)
 
             // Not all handlers will return a response
             if (res != null) {
-              yield Message.encode(res)
+              await messages.write(res, {
+                signal
+              })
+            }
+          } catch (err) {
+            errored = true
+            stopErrorTimer?.()
+
+            throw err
+          } finally {
+            if (!errored) {
+              stopSuccessTimer?.()
             }
           }
-        },
-        (source) => lp.encode(source),
-        stream
-      )
+
+          // we have received a message so reset the timeout controller to
+          // allow the remote to send another
+          signal.removeEventListener('abort', abortListener)
+          signal = AbortSignal.timeout(this.incomingMessageTimeout)
+          signal.addEventListener('abort', abortListener)
+        }
+      } catch (err: any) {
+        stream.abort(err)
+      }
     })
       .catch(err => {
         this.log.error('error handling %s RPC message from %p - %e', message, data.connection.remotePeer, err)

package/src/topology-listener.ts

@@ -1,4 +1,4 @@
-import { TypedEventEmitter } from '@libp2p/interface'
+import { TypedEventEmitter } from 'main-event'
 import type { KadDHTComponents } from './index.js'
 import type { Logger, PeerId, Startable } from '@libp2p/interface'
 

package/src/utils.ts

@@ -11,7 +11,7 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import type { Operation, OperationMetrics } from './kad-dht.js'
-import type { PeerId, PeerInfo } from '@libp2p/interface'
+import type { AbortOptions, PeerId, PeerInfo } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 // const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
@@ -90,8 +90,9 @@ export function passthroughMapper (info: PeerInfo): PeerInfo {
 /**
  * Creates a DHT ID by hashing a given Uint8Array
  */
-export async function convertBuffer (buf: Uint8Array): Promise<Uint8Array> {
+export async function convertBuffer (buf: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
   const multihash = await sha256.digest(buf)
+  options?.signal?.throwIfAborted()
 
   return multihash.digest
 }
@@ -99,8 +100,8 @@ export async function convertBuffer (buf: Uint8Array): Promise<Uint8Array> {
 /**
  * Creates a DHT ID by hashing a Peer ID
  */
-export async function convertPeerId (peerId: PeerId): Promise<Uint8Array> {
-  return convertBuffer(peerId.toMultihash().bytes)
+export async function convertPeerId (peerId: PeerId, options?: AbortOptions): Promise<Uint8Array> {
+  return convertBuffer(peerId.toMultihash().bytes, options)
 }
 
 /**

package/dist/typedoc-urls.json

@@ -1,63 +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.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",
-  "DisjointPath": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DisjointPath.html",
-  ".:DisjointPath": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DisjointPath.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",
-  "PathEndedEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PathEndedEvent.html",
-  ".:PathEndedEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PathEndedEvent.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",
-  ".: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",
-  "ReProvideInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ReProvideInit.html",
-  ".:ReProvideInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ReProvideInit.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.html",
-  ".:kadDHT": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad-dht.kadDHT.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"
-}