@libp2p/kad-dht 15.1.10 → 15.1.11-a02cb0461

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/kad-dht",
-  "version": "15.1.10",
+  "version": "15.1.11-a02cb0461",
   "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",
@@ -47,61 +47,58 @@
     "doc-check": "aegir doc-check"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.1.7",
-    "@libp2p/interface": "^2.10.5",
-    "@libp2p/interface-internal": "^2.3.18",
-    "@libp2p/peer-collections": "^6.0.34",
-    "@libp2p/peer-id": "^5.1.8",
-    "@libp2p/ping": "^2.0.36",
-    "@libp2p/record": "^4.0.7",
-    "@libp2p/utils": "^6.7.1",
-    "@multiformats/multiaddr": "^12.4.4",
+    "@libp2p/crypto": "5.1.8-a02cb0461",
+    "@libp2p/interface": "2.11.0-a02cb0461",
+    "@libp2p/interface-internal": "2.3.19-a02cb0461",
+    "@libp2p/peer-collections": "6.0.35-a02cb0461",
+    "@libp2p/peer-id": "5.1.9-a02cb0461",
+    "@libp2p/ping": "2.0.37-a02cb0461",
+    "@libp2p/record": "4.0.7-a02cb0461",
+    "@libp2p/utils": "6.7.2-a02cb0461",
+    "@multiformats/multiaddr": "^12.5.1",
     "any-signal": "^4.1.1",
-    "interface-datastore": "^8.3.1",
-    "it-all": "^3.0.8",
-    "it-drain": "^3.0.9",
-    "it-length": "^3.0.8",
-    "it-map": "^3.1.3",
-    "it-merge": "^3.0.11",
-    "it-parallel": "^3.0.11",
+    "interface-datastore": "^8.3.2",
+    "it-all": "^3.0.9",
+    "it-drain": "^3.0.10",
+    "it-length": "^3.0.9",
+    "it-map": "^3.1.4",
+    "it-merge": "^3.0.12",
+    "it-parallel": "^3.0.13",
     "it-pipe": "^3.0.1",
-    "it-protobuf-stream": "^2.0.2",
     "it-pushable": "^3.2.3",
-    "it-take": "^3.0.8",
+    "it-take": "^3.0.9",
     "main-event": "^1.0.1",
-    "multiformats": "^13.3.6",
+    "multiformats": "^13.4.0",
     "p-defer": "^4.0.1",
     "p-event": "^6.0.1",
     "progress-events": "^1.0.1",
-    "protons-runtime": "^5.5.0",
-    "race-signal": "^1.1.3",
+    "protons-runtime": "^5.6.0",
+    "race-signal": "^2.0.0",
     "uint8-varint": "^2.0.4",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/interface-compliance-tests": "^6.4.16",
-    "@libp2p/logger": "^5.1.21",
-    "@libp2p/peer-store": "^11.2.6",
+    "@libp2p/logger": "5.2.0-a02cb0461",
+    "@libp2p/peer-store": "11.2.7-a02cb0461",
     "@types/lodash.random": "^3.2.9",
     "@types/lodash.range": "^3.2.9",
     "@types/sinon": "^17.0.4",
     "@types/which": "^3.0.4",
-    "aegir": "^47.0.14",
+    "aegir": "^47.0.21",
     "benchmark": "^2.1.4",
-    "datastore-core": "^10.0.2",
+    "datastore-core": "^10.0.4",
     "delay": "^6.0.0",
-    "execa": "^9.5.3",
-    "it-filter": "^3.1.3",
-    "it-last": "^3.0.8",
+    "execa": "^9.6.0",
+    "it-filter": "^3.1.4",
+    "it-first": "^3.0.9",
+    "it-last": "^3.0.9",
     "it-length-prefixed": "^10.0.1",
-    "it-pair": "^2.0.6",
-    "it-stream-types": "^2.0.2",
     "lodash.random": "^3.2.0",
     "lodash.range": "^3.2.0",
-    "p-retry": "^6.2.1",
-    "protons": "^7.6.1",
-    "sinon": "^20.0.0",
+    "p-retry": "^7.0.0",
+    "protons": "^7.7.0",
+    "sinon": "^21.0.0",
     "sinon-ts": "^2.0.0",
     "which": "^5.0.0"
   },

package/src/constants.ts

@@ -4,8 +4,6 @@ export const second = 1000
 export const minute = 60 * second
 export const hour = 60 * minute
 
-export const MAX_RECORD_AGE = 36 * hour
-
 export const PROTOCOL = '/ipfs/kad/1.0.0'
 
 /**

package/src/content-routing/index.ts

@@ -1,5 +1,5 @@
 import { PeerSet } from '@libp2p/peer-collections'
-import { Queue } from '@libp2p/utils/queue'
+import { Queue } from '@libp2p/utils'
 import { pushable } from 'it-pushable'
 import { ALPHA } from '../constants.js'
 import { MessageType } from '../message/dht.js'
@@ -134,8 +134,8 @@ export class ContentRouting {
     queue.addEventListener('idle', () => {
       events.end()
     })
-    queue.addEventListener('error', (err) => {
-      this.log.error('error publishing provider record to peer - %e', err)
+    queue.addEventListener('failure', (event) => {
+      this.log.error('error publishing provider record to peer - %e', event.detail.error)
     })
 
     queue.add(async () => {

package/src/index.ts

@@ -138,7 +138,7 @@ import { removePrivateAddressesMapper, removePublicAddressesMapper, passthroughM
 import type { Libp2pEvents, ComponentLogger, Metrics, PeerId, PeerInfo, PeerStore, RoutingOptions, PrivateKey, AbortOptions } from '@libp2p/interface'
 import type { AddressManager, ConnectionManager, Registrar } from '@libp2p/interface-internal'
 import type { Ping } from '@libp2p/ping'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 import type { Datastore } from 'interface-datastore'
 import type { TypedEventTarget } from 'main-event'
 import type { CID } from 'multiformats/cid'

package/src/kad-dht.ts

@@ -387,7 +387,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
   }
 
   async onPeerConnect (peerData: PeerInfo): Promise<void> {
-    this.log.trace('peer %p connected', peerData.id)
+    this.log.trace('peer %p connected', peerData.id, peerData.multiaddrs)
 
     peerData = this.peerInfoMapper(peerData)
 

package/src/network.ts

@@ -1,7 +1,6 @@
 import { InvalidParametersError } from '@libp2p/interface'
 import { Libp2pRecord } from '@libp2p/record'
-import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
-import { pbStream } from 'it-protobuf-stream'
+import { AdaptiveTimeout, pbStream } from '@libp2p/utils'
 import { TypedEventEmitter } from 'main-event'
 import { Message } from './message/dht.js'
 import { fromPbPeerInfo } from './message/utils.js'
@@ -13,7 +12,7 @@ import {
 } from './query/events.js'
 import type { DisjointPath, KadDHTComponents, QueryEvent } from './index.js'
 import type { AbortOptions, Logger, Stream, PeerId, PeerInfo, Startable, RoutingOptions, CounterGroup } from '@libp2p/interface'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 
 export interface NetworkInit {
   protocol: string
@@ -178,8 +177,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       this.log('dialling %p', to)
       yield dialPeerEvent({ peer: to, path: options.path }, options)
 
-      const connection = await this.components.connectionManager.openConnection(to, options)
-      stream = await connection.newStream(this.protocol, options)
+      stream = await this.components.connectionManager.openStream(to, this.protocol, options)
 
       this.log('sending %s to %p', msg.type, to)
       yield sendQueryEvent({ to, type, path: options.path }, options)
@@ -245,8 +243,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       this.log('dialling %p', to)
       yield dialPeerEvent({ peer: to, path: options.path }, options)
 
-      const connection = await this.components.connectionManager.openConnection(to, options)
-      stream = await connection.newStream(this.protocol, options)
+      stream = await this.components.connectionManager.openStream(to, this.protocol, options)
 
       this.log('sending %s to %p', msg.type, to)
       yield sendQueryEvent({ to, type, path: options.path }, options)

package/src/peer-routing/index.ts

@@ -367,7 +367,7 @@ export class PeerRouting {
     }
 
     if (output.length > 0) {
-      this.log('getClosestPeersOffline returning the %d closest peer(s) %b we know', output.length, key)
+      this.log('getClosestPeersOffline returning the %d closest peer(s) we know to %b', output.length, key)
     } else {
       this.log('getClosestPeersOffline could not any peers close to %b with %d peers in the routing table', key, this.routingTable.size)
     }

package/src/query/manager.ts

@@ -1,4 +1,4 @@
-import { createScalableCuckooFilter } from '@libp2p/utils/filters'
+import { createScalableCuckooFilter } from '@libp2p/utils'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
 import { setMaxListeners } from 'main-event'

package/src/query/query-path.ts

@@ -1,5 +1,5 @@
 import { AbortError } from '@libp2p/interface'
-import { Queue } from '@libp2p/utils/queue'
+import { Queue } from '@libp2p/utils'
 import { pushable } from 'it-pushable'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
@@ -9,7 +9,7 @@ import type { QueryEvent } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
 import type { Logger, PeerId, RoutingOptions, AbortOptions, PeerInfo } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
-import type { Filter } from '@libp2p/utils/filters'
+import type { Filter } from '@libp2p/utils'
 
 export interface QueryPathOptions extends RoutingOptions {
   /**
@@ -100,8 +100,8 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
 
     events.end()
   })
-  queue.addEventListener('error', (evt) => {
-    log.error('error during query - %e', evt.detail)
+  queue.addEventListener('failure', (evt) => {
+    log.error('error during query - %e', evt.detail.error)
   })
 
   const onAbort = (): void => {
@@ -171,7 +171,7 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
 
                 // only continue query if closer peer is actually closer
                 if (uint8ArrayXorCompare(closerPeerXor, peerXor) !== -1) { // eslint-disable-line max-depth
-                  log('skipping %p as they are not closer to %b than %p', closerPeer.id, key, peer)
+                  log('skipping %p as they are not closer to %b than %p', closerPeer.id, key, peer.id)
                   continue
                 }
 

package/src/reprovider.ts

@@ -1,5 +1,4 @@
-import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
-import { Queue } from '@libp2p/utils/queue'
+import { AdaptiveTimeout, Queue } from '@libp2p/utils'
 import drain from 'it-drain'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { PROVIDERS_VALIDITY, REPROVIDE_CONCURRENCY, REPROVIDE_INTERVAL, REPROVIDE_MAX_QUEUE_SIZE, REPROVIDE_THRESHOLD, REPROVIDE_TIMEOUT } from './constants.js'
@@ -8,7 +7,7 @@ import type { ContentRouting } from './content-routing/index.js'
 import type { OperationMetrics } from './kad-dht.js'
 import type { AbortOptions, ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { AddressManager } from '@libp2p/interface-internal'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats/cid'
 
@@ -99,10 +98,10 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
     setMaxListeners(Infinity, this.shutdownController.signal)
 
     this.timeout = setTimeout(() => {
-      this.cleanUp({
+      this.processRecords({
         signal: AbortSignal.timeout(REPROVIDE_TIMEOUT)
       }).catch(err => {
-        this.log.error('error running reprovide/cleanup - %e', err)
+        this.log.error('error running process to reprovide/cleanup - %e', err)
       })
     }, this.interval)
   }
@@ -118,10 +117,10 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
    * Check all provider records. Delete them if they have expired, reprovide
    * them if the provider is us and the expiry is within the reprovide window.
    */
-  private async cleanUp (options?: AbortOptions): Promise<void> {
+  private async processRecords (options?: AbortOptions): Promise<void> {
     try {
       this.safeDispatchEvent('reprovide:start')
-
+      this.log('starting reprovide/cleanup')
       // Get all provider entries from the datastore
       for await (const entry of this.datastore.query({
         prefix: this.datastorePrefix
@@ -133,17 +132,20 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
           const expires = created + this.validity
           const now = Date.now()
           const expired = now > expires
+          const isSelf = this.peerId.equals(peerId)
 
-          this.log.trace('comparing: %d < %d = %s %s', created, now - this.validity, expired, expired ? '(expired)' : '')
+          this.log.trace('comparing: %d (now) < %d (expires) = %s %s', now, expires, expired, expired ? '(expired)' : '(valid)')
 
-          // delete the record if it has expired
-          if (expired) {
+          // delete the record if it has expired and isn't us
+          // so that if user node is down for a while, we still persist provide intent
+          if (expired && !isSelf) {
             await this.datastore.delete(entry.key, options)
           }
 
           // if the provider is us and we are within the reprovide threshold,
           // reprovide the record
-          if (this.peerId.equals(peerId) && (now - expires) < this.reprovideThreshold) {
+          if (this.shouldReprovide(isSelf, expires)) {
+            this.log('reproviding %c as it is within the reprovide threshold (%d)', cid, this.reprovideThreshold)
             this.queueReprovide(cid)
               .catch(err => {
                 this.log.error('could not reprovide %c - %e', cid, err)
@@ -159,8 +161,9 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
       this.safeDispatchEvent('reprovide:end')
 
       if (this.running) {
+        this.log('queuing next re-provide/cleanup run in %d ms', this.interval)
         this.timeout = setTimeout(() => {
-          this.cleanUp({
+          this.processRecords({
             signal: AbortSignal.timeout(REPROVIDE_TIMEOUT)
           }).catch(err => {
             this.log.error('error running re-provide - %e', err)
@@ -170,6 +173,24 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
     }
   }
 
+  /**
+   * Determines if a record should be reprovided
+   */
+  private shouldReprovide (isSelf: boolean, expires: number): boolean {
+    if (!isSelf) {
+      return false
+    }
+    const now = Date.now()
+
+    if (expires < now) {
+      // If the record has already expired, reprovide irrespective of the threshold
+      return true
+    }
+
+    // if the record is approaching expiration within the reprovide threshold
+    return expires - now < this.reprovideThreshold
+  }
+
   private async queueReprovide (cid: CID, options?: AbortOptions): Promise<void> {
     if (!this.running) {
       return

package/src/routing-table/index.ts

@@ -1,6 +1,5 @@
 import { start, stop } from '@libp2p/interface'
-import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
-import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { AdaptiveTimeout, PeerQueue } from '@libp2p/utils'
 import { anySignal } from 'any-signal'
 import parallel from 'it-parallel'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
@@ -11,7 +10,7 @@ import type { Bucket, GetClosestPeersOptions, LeafBucket, Peer } from './k-bucke
 import type { Network } from '../network.js'
 import type { AbortOptions, ComponentLogger, CounterGroup, Logger, Metric, Metrics, PeerId, PeerStore, Startable, Stream } from '@libp2p/interface'
 import type { Ping } from '@libp2p/ping'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 
 export const KBUCKET_SIZE = 20
 export const PREFIX_LENGTH = 6
@@ -118,6 +117,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.populateFromDatastoreOnStart = init.populateFromDatastoreOnStart ?? POPULATE_FROM_DATASTORE_ON_START
     this.populateFromDatastoreLimit = init.populateFromDatastoreLimit ?? POPULATE_FROM_DATASTORE_LIMIT
     this.shutdownController = new AbortController()
+    setMaxListeners(Infinity, this.shutdownController.signal)
 
     this.pingOldContactQueue = new PeerQueue({
       concurrency: init.pingOldContactConcurrency ?? PING_OLD_CONTACT_CONCURRENCY,
@@ -190,6 +190,8 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.running = true
 
     this.shutdownController = new AbortController()
+    setMaxListeners(Infinity, this.shutdownController.signal)
+
     await start(this.closestPeerTagger, this.kb)
   }
 

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

@@ -2,7 +2,7 @@ import { publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import { InvalidMessageError, NotFoundError } from '@libp2p/interface'
 import { Libp2pRecord } from '@libp2p/record'
 import {
-  MAX_RECORD_AGE
+  PROVIDERS_VALIDITY
 } from '../../constants.js'
 import { MessageType } from '../../message/dht.js'
 import { bufferToRecordKey, isPublicKeyKey, fromPublicKeyKey } from '../../utils.js'
@@ -107,7 +107,7 @@ export class GetValueHandler implements DHTMessageHandler {
    * Try to fetch a given record by from the local datastore.
    * Returns the record if it is still valid, meaning
    * - it was either authored by this node, or
-   * - it was received less than `MAX_RECORD_AGE` ago.
+   * - it was received less than `PROVIDERS_VALIDITY` ago.
    */
   async _checkLocalDatastore (key: Uint8Array): Promise<Libp2pRecord | undefined> {
     this.log('checkLocalDatastore looking for %b', key)
@@ -129,7 +129,7 @@ export class GetValueHandler implements DHTMessageHandler {
 
     // Check validity: compare time received with max record age
     if (record.timeReceived == null ||
-      Date.now() - record.timeReceived.getTime() > MAX_RECORD_AGE) {
+      Date.now() - record.timeReceived.getTime() > PROVIDERS_VALIDITY) {
       // If record is bad delete it and return
       await this.datastore.delete(dsKey)
       return undefined

package/src/rpc/index.ts

@@ -1,5 +1,5 @@
 import { TimeoutError } from '@libp2p/interface'
-import { pbStream } from 'it-protobuf-stream'
+import { pbStream } from '@libp2p/utils'
 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, MetricGroup } from '@libp2p/interface'
+import type { CounterGroup, Logger, Metrics, PeerId, MetricGroup, Connection, Stream } from '@libp2p/interface'
 
 export interface DHTMessageHandler {
   handle(peerId: PeerId, msg: Message): Promise<Message | undefined>
@@ -95,65 +95,61 @@ export class RPC {
   /**
    * Handle incoming streams on the dht protocol
    */
-  onIncomingStream (data: IncomingStreamData): void {
-    const message = 'unknown'
+  async onIncomingStream (stream: Stream, connection: Connection): Promise<void> {
+    const abortListener = (): void => {
+      stream.abort(new TimeoutError())
+    }
+
+    let signal = AbortSignal.timeout(this.incomingMessageTimeout)
+    signal.addEventListener('abort', abortListener)
+
+    const messages = pbStream(stream).pb(Message)
 
-    Promise.resolve().then(async () => {
-      const { stream, connection } = data
+    while (true) {
+      // the remote will not send any more data
+      if (stream.readStatus !== 'readable') {
+        await stream.close({
+          signal
+        })
 
-      const abortListener = (): void => {
-        stream.abort(new TimeoutError())
+        break
       }
 
-      let signal = AbortSignal.timeout(this.incomingMessageTimeout)
-      signal.addEventListener('abort', abortListener)
+      const message = await messages.read({
+        signal
+      })
 
-      const messages = pbStream(stream).pb(Message)
+      const stopSuccessTimer = this.metrics?.rpcTime?.timer(message.type.toString())
+      const stopErrorTimer = this.metrics?.rpcTime?.timer(message.type.toString())
+      let errored = false
 
       try {
-        while (true) {
-          const message = await messages.read({
+        // handle the message
+        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) {
+          await messages.write(res, {
             signal
           })
-
-          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
-            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) {
-              await messages.write(res, {
-                signal
-              })
-            }
-          } catch (err) {
-            errored = true
-            stopErrorTimer?.()
-
-            throw err
-          } finally {
-            if (!errored) {
-              stopSuccessTimer?.()
-            }
-          }
-
-          // 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) {
+        errored = true
+        stopErrorTimer?.()
+
+        throw err
+      } finally {
+        if (!errored) {
+          stopSuccessTimer?.()
+        }
       }
-    })
-      .catch(err => {
-        this.log.error('error handling %s RPC message from %p - %e', message, data.connection.remotePeer, err)
-      })
+
+      // 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)
+    }
   }
 }

package/src/utils.ts

@@ -1,6 +1,6 @@
 import { peerIdFromMultihash, peerIdFromString } from '@libp2p/peer-id'
 import { Libp2pRecord } from '@libp2p/record'
-import { isPrivateIp } from '@libp2p/utils/private-ip'
+import { isPrivateIp } from '@libp2p/utils'
 import { Key } from 'interface-datastore/key'
 import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
@@ -160,15 +160,6 @@ export function createPutRecord (key: Uint8Array, value: Uint8Array): Uint8Array
   return rec.serialize()
 }
 
-export function debounce (callback: () => void, wait: number = 100): () => void {
-  let timeout: ReturnType<typeof setTimeout>
-
-  return (): void => {
-    clearTimeout(timeout)
-    timeout = setTimeout(() => { callback() }, wait)
-  }
-}
-
 // see https://github.com/multiformats/multiaddr/blob/master/protocols.csv
 const P2P_CIRCUIT_CODE = 290
 const DNS4_CODE = 54

package/dist/typedoc-urls.json

@@ -1,65 +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",
-  "SetModeOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SetModeOptions.html",
-  ".:SetModeOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SetModeOptions.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"
-}