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

package/src/providers.ts

@@ -3,13 +3,11 @@ import * as varint from 'uint8-varint'
 import { parseProviderKey, readProviderTime, toProviderKey } from './utils.js'
 import type { AbortOptions, ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
-import type { Mortice } from 'mortice'
 import type { CID } from 'multiformats'
 
 export interface ProvidersInit {
   logPrefix: string
   datastorePrefix: string
-  lock: Mortice
 }
 
 export interface ProvidersComponents {
@@ -18,6 +16,10 @@ export interface ProvidersComponents {
   metrics?: Metrics
 }
 
+interface WriteProviderEntryOptions extends AbortOptions {
+  time?: Date
+}
+
 /**
  * Provides a mechanism to add and remove provider records from the datastore
  */
@@ -25,67 +27,47 @@ export class Providers {
   private readonly log: Logger
   private readonly datastore: Datastore
   private readonly datastorePrefix: string
-  private readonly lock: Mortice
 
   constructor (components: ProvidersComponents, init: ProvidersInit) {
     this.log = components.logger.forComponent(`${init.logPrefix}:providers`)
     this.datastorePrefix = `${init.datastorePrefix}/provider`
     this.datastore = components.datastore
-    this.lock = init.lock
   }
 
   /**
    * Add a new provider for the given CID
    */
   async addProvider (cid: CID, provider: PeerId, options?: AbortOptions): Promise<void> {
-    const release = await this.lock.readLock()
-
-    try {
-      this.log.trace('%p provides %s', provider, cid)
-      await this.writeProviderEntry(cid, provider)
-    } finally {
-      release()
-    }
+    this.log.trace('%p provides %s', provider, cid)
+    await this.writeProviderEntry(cid, provider, options)
   }
 
   /**
    * Remove a provider for the given CID
    */
   async removeProvider (cid: CID, provider: PeerId, options?: AbortOptions): Promise<void> {
-    const release = await this.lock.writeLock()
-
-    try {
-      const key = toProviderKey(this.datastorePrefix, cid, provider)
-      this.log.trace('%p no longer provides %s', provider, cid)
-      await this.datastore.delete(key)
-    } finally {
-      release()
-    }
+    const key = toProviderKey(this.datastorePrefix, cid, provider)
+    this.log.trace('%p no longer provides %s', provider, cid)
+    await this.datastore.delete(key, options)
   }
 
   /**
    * Get a list of providers for the given CID
    */
   async getProviders (cid: CID, options?: AbortOptions): Promise<PeerId[]> {
-    const release = await this.lock.readLock()
+    this.log.trace('get providers for %c', cid)
+    const provs = await this.loadProviders(cid, options)
+    this.log.trace('got %d providers for %c', provs.size, cid)
 
-    try {
-      this.log.trace('get providers for %c', cid)
-      const provs = await this.loadProviders(cid, options)
-      this.log.trace('got %d providers for %c', provs.size, cid)
-
-      return [...provs.keys()]
-    } finally {
-      release()
-    }
+    return [...provs.keys()]
   }
 
   /**
    * Write a provider into the given store
    */
-  private async writeProviderEntry (cid: CID, peerId: PeerId, time: Date = new Date(), options?: AbortOptions): Promise<void> {
+  private async writeProviderEntry (cid: CID, peerId: PeerId, options?: WriteProviderEntryOptions): Promise<void> {
     const key = toProviderKey(this.datastorePrefix, cid, peerId)
-    const buffer = varint.encode(time.getTime())
+    const buffer = varint.encode(options?.time?.getTime() ?? Date.now())
 
     await this.datastore.put(key, buffer, options)
   }

package/src/query/manager.ts

@@ -1,7 +1,7 @@
-import { setMaxListeners } from '@libp2p/interface'
 import { createScalableCuckooFilter } from '@libp2p/utils/filters'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
+import { setMaxListeners } from 'main-event'
 import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
@@ -165,8 +165,12 @@ export class QueryManager implements Startable {
 
       log('query:start')
 
-      const id = await convertBuffer(key)
-      const peers = this.routingTable.closestPeers(id, this.routingTable.kBucketSize)
+      const id = await convertBuffer(key, {
+        signal
+      })
+      const peers = this.routingTable.closestPeers(id, {
+        count: this.routingTable.kBucketSize
+      })
 
       // split peers into d buckets evenly(ish)
       const peersToQuery = peers.sort(() => {

package/src/query/query-path.ts

@@ -1,8 +1,8 @@
+import { AbortError } from '@libp2p/interface'
 import { Queue } from '@libp2p/utils/queue'
 import { pushable } from 'it-pushable'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
-import { QueryAbortedError } from '../errors.js'
 import { convertPeerId, convertBuffer } from '../utils.js'
 import { pathEndedEvent, queryErrorEvent } from './events.js'
 import type { QueryEvent } from '../index.js'
@@ -106,11 +106,13 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
 
   signal.addEventListener('abort', () => {
     queue.abort()
-    events.end(new QueryAbortedError())
+    events.end(new AbortError())
   })
 
   // perform lookups on kadId, not the actual value
-  const kadId = await convertBuffer(key)
+  const kadId = await convertBuffer(key, {
+    signal
+  })
 
   /**
    * Adds the passed peer to the query queue if it's not us and no other path
@@ -159,7 +161,9 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
                 continue
               }
 
-              const closerPeerKadId = await convertPeerId(closerPeer.id)
+              const closerPeerKadId = await convertPeerId(closerPeer.id, {
+                signal
+              })
               const closerPeerXor = uint8ArrayXor(closerPeerKadId, kadId)
 
               // only continue query if closer peer is actually closer
@@ -206,7 +210,9 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
   // begin the query with the starting peers
   await Promise.all(
     startingPeers.map(async startingPeer => {
-      queryPeer({ id: startingPeer, multiaddrs: [] }, await convertPeerId(startingPeer))
+      queryPeer({ id: startingPeer, multiaddrs: [] }, await convertPeerId(startingPeer, {
+        signal
+      }))
     })
   )
 

package/src/query-self.ts

@@ -1,8 +1,8 @@
-import { setMaxListeners } from '@libp2p/interface'
 import { anySignal } from 'any-signal'
 import length from 'it-length'
 import { pipe } from 'it-pipe'
 import take from 'it-take'
+import { setMaxListeners } from 'main-event'
 import pDefer from 'p-defer'
 import { QUERY_SELF_INTERVAL, QUERY_SELF_TIMEOUT, K, QUERY_SELF_INITIAL_INTERVAL } from './constants.js'
 import { timeOperationMethod } from './utils.js'
@@ -133,6 +133,8 @@ export class QuerySelf implements Startable {
           async (source) => length(source)
         )
 
+        signal?.throwIfAborted()
+
         const duration = Date.now() - start
 
         this.log('self-query found %d peers in %dms', peers, duration)

package/src/record/validators.ts

@@ -4,13 +4,14 @@ import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import type { Validators } from '../index.js'
 import type { Libp2pRecord } from '@libp2p/record'
+import type { AbortOptions } from 'it-pushable'
 
 /**
  * Checks a record and ensures it is still valid.
  * It runs the needed validators.
  * If verification fails the returned Promise will reject with the error.
  */
-export async function verifyRecord (validators: Validators, record: Libp2pRecord): Promise<void> {
+export async function verifyRecord (validators: Validators, record: Libp2pRecord, options?: AbortOptions): Promise<void> {
   const key = record.key
   const keyString = uint8ArrayToString(key)
   const parts = keyString.split('/')
@@ -26,7 +27,7 @@ export async function verifyRecord (validators: Validators, record: Libp2pRecord
     throw new InvalidParametersError(`No validator available for key type "${parts[1]}"`)
   }
 
-  await validator(key, record.value)
+  await validator(key, record.value, options)
 }
 
 /**
@@ -38,7 +39,7 @@ export async function verifyRecord (validators: Validators, record: Libp2pRecord
  * @param {Uint8Array} key - A valid key is of the form `'/pk/<keymultihash>'`
  * @param {Uint8Array} publicKey - The public key to validate against (protobuf encoded).
  */
-const validatePublicKeyRecord = async (key: Uint8Array, publicKey: Uint8Array): Promise<void> => {
+const validatePublicKeyRecord = async (key: Uint8Array, publicKey: Uint8Array, options?: AbortOptions): Promise<void> => {
   if (!(key instanceof Uint8Array)) {
     throw new InvalidParametersError('"key" must be a Uint8Array')
   }

package/src/reprovider.ts

@@ -1,8 +1,8 @@
-import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
 import { Queue } from '@libp2p/utils/queue'
 import drain from 'it-drain'
-import { PROVIDERS_VALIDITY, REPROVIDE_CONCURRENCY, REPROVIDE_INTERVAL, REPROVIDE_MAX_QUEUE_SIZE, REPROVIDE_THRESHOLD } from './constants.js'
+import { TypedEventEmitter, setMaxListeners } from 'main-event'
+import { PROVIDERS_VALIDITY, REPROVIDE_CONCURRENCY, REPROVIDE_INTERVAL, REPROVIDE_MAX_QUEUE_SIZE, REPROVIDE_THRESHOLD, REPROVIDE_TIMEOUT } from './constants.js'
 import { parseProviderKey, readProviderTime, timeOperationMethod } from './utils.js'
 import type { ContentRouting } from './content-routing/index.js'
 import type { OperationMetrics } from './kad-dht.js'
@@ -10,7 +10,6 @@ import type { AbortOptions, ComponentLogger, Logger, Metrics, PeerId } from '@li
 import type { AddressManager } from '@libp2p/interface-internal'
 import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
 import type { Datastore } from 'interface-datastore'
-import type { Mortice } from 'mortice'
 import type { CID } from 'multiformats/cid'
 
 export interface ReproviderComponents {
@@ -26,7 +25,6 @@ export interface ReproviderInit {
   metricsPrefix: string
   datastorePrefix: string
   contentRouting: ContentRouting
-  lock: Mortice
   operationMetrics: OperationMetrics
   concurrency?: number
   maxQueueSize?: number
@@ -60,7 +58,6 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
   private readonly addressManager: AddressManager
   private readonly validity: number
   private readonly interval: number
-  private readonly lock: Mortice
   private readonly peerId: PeerId
 
   constructor (components: ReproviderComponents, init: ReproviderInit) {
@@ -86,7 +83,6 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
     this.validity = init.validity ?? PROVIDERS_VALIDITY
     this.interval = init.interval ?? REPROVIDE_INTERVAL
     this.contentRouting = init.contentRouting
-    this.lock = init.lock
     this.running = false
 
     this.reprovide = timeOperationMethod(this.reprovide.bind(this), init.operationMetrics, 'PROVIDE')
@@ -103,7 +99,9 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
     setMaxListeners(Infinity, this.shutdownController.signal)
 
     this.timeout = setTimeout(() => {
-      this.cleanUp().catch(err => {
+      this.cleanUp({
+        signal: AbortSignal.timeout(REPROVIDE_TIMEOUT)
+      }).catch(err => {
         this.log.error('error running reprovide/cleanup - %e', err)
       })
     }, this.interval)
@@ -120,16 +118,14 @@ 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 (): Promise<void> {
-    const release = await this.lock.writeLock()
-
+  private async cleanUp (options?: AbortOptions): Promise<void> {
     try {
       this.safeDispatchEvent('reprovide:start')
 
       // Get all provider entries from the datastore
       for await (const entry of this.datastore.query({
         prefix: this.datastorePrefix
-      })) {
+      }, options)) {
         try {
           // Add a delete to the batch for each expired entry
           const { cid, peerId } = parseProviderKey(entry.key)
@@ -142,7 +138,7 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
 
           // delete the record if it has expired
           if (expired) {
-            await this.datastore.delete(entry.key)
+            await this.datastore.delete(entry.key, options)
           }
 
           // if the provider is us and we are within the reprovide threshold,
@@ -160,12 +156,13 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
 
       this.log('reprovide/cleanup successful')
     } finally {
-      release()
       this.safeDispatchEvent('reprovide:end')
 
       if (this.running) {
         this.timeout = setTimeout(() => {
-          this.cleanUp().catch(err => {
+          this.cleanUp({
+            signal: AbortSignal.timeout(REPROVIDE_TIMEOUT)
+          }).catch(err => {
             this.log.error('error running re-provide - %e', err)
           })
         }, this.interval)
@@ -173,13 +170,13 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
     }
   }
 
-  private async queueReprovide (cid: CID): Promise<void> {
+  private async queueReprovide (cid: CID, options?: AbortOptions): Promise<void> {
     if (!this.running) {
       return
     }
 
     this.log.trace('waiting for queue capacity before adding %c to re-provide queue', cid)
-    await this.reprovideQueue.onSizeLessThan(this.maxQueueSize)
+    await this.reprovideQueue.onSizeLessThan(this.maxQueueSize, options)
 
     const existingJob = this.reprovideQueue.queue.find(job => job.options.cid.equals(cid))
 

package/src/routing-table/index.ts

@@ -1,12 +1,13 @@
-import { TypedEventEmitter, setMaxListeners, start, stop } from '@libp2p/interface'
+import { start, stop } from '@libp2p/interface'
 import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { anySignal } from 'any-signal'
 import parallel from 'it-parallel'
+import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import * as utils from '../utils.js'
 import { ClosestPeers } from './closest-peers.js'
 import { KBucket, isLeafBucket } from './k-bucket.js'
-import type { Bucket, LeafBucket, Peer } from './k-bucket.js'
+import type { Bucket, GetClosestPeersOptions, LeafBucket, Peer } from './k-bucket.js'
 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'
@@ -97,6 +98,8 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     kadBucketEvents: CounterGroup<'ping_old_contact' | 'ping_old_contact_error' | 'ping_new_contact' | 'ping_new_contact_error' | 'peer_added' | 'peer_removed'>
   }
 
+  private shutdownController: AbortController
+
   constructor (components: RoutingTableComponents, init: RoutingTableInit) {
     super()
 
@@ -114,6 +117,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.peerRemoved = this.peerRemoved.bind(this)
     this.populateFromDatastoreOnStart = init.populateFromDatastoreOnStart ?? POPULATE_FROM_DATASTORE_ON_START
     this.populateFromDatastoreLimit = init.populateFromDatastoreLimit ?? POPULATE_FROM_DATASTORE_LIMIT
+    this.shutdownController = new AbortController()
 
     this.pingOldContactQueue = new PeerQueue({
       concurrency: init.pingOldContactConcurrency ?? PING_OLD_CONTACT_CONCURRENCY,
@@ -139,7 +143,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
       metricName: `${init.metricsPrefix}_routing_table_ping_new_contact_time_milliseconds`
     })
 
-    this.kb = new KBucket({
+    this.kb = new KBucket(components, {
       kBucketSize: init.kBucketSize,
       prefixLength: init.prefixLength,
       splitThreshold: init.splitThreshold,
@@ -148,7 +152,8 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
       ping: this.pingOldContacts,
       verify: this.verifyNewContact,
       onAdd: this.peerAdded,
-      onRemove: this.peerRemoved
+      onRemove: this.peerRemoved,
+      metricsPrefix: init.metricsPrefix
     })
 
     this.closestPeerTagger = new ClosestPeers(this.components, {
@@ -184,11 +189,13 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     this.running = true
 
-    await start(this.closestPeerTagger)
-    await this.kb.addSelfPeer(this.components.peerId)
+    this.shutdownController = new AbortController()
+    await start(this.closestPeerTagger, this.kb)
   }
 
   async afterStart (): Promise<void> {
+    let peerStorePeers = 0
+
     // do this async to not block startup but iterate serially to not overwhelm
     // the ping queue
     Promise.resolve().then(async () => {
@@ -196,48 +203,60 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
         return
       }
 
-      let peerStorePeers = 0
-
-      // add existing peers from the peer store to routing table
-      for (const peer of await this.components.peerStore.all({
-        filters: [(peer) => {
-          return peer.protocols.includes(this.protocol) && peer.tags.has(KAD_PEER_TAG_NAME)
-        }],
-        limit: this.populateFromDatastoreLimit
-      })) {
-        if (!this.running) {
-          // bail if we've been shut down
-          return
-        }
+      const signal = anySignal([
+        this.shutdownController.signal,
+        AbortSignal.timeout(20_000)
+      ])
+      setMaxListeners(Infinity, signal)
+
+      try {
+        // add existing peers from the peer store to routing table
+        for (const peer of await this.components.peerStore.all({
+          filters: [(peer) => {
+            return peer.protocols.includes(this.protocol) && peer.tags.has(KAD_PEER_TAG_NAME)
+          }],
+          limit: this.populateFromDatastoreLimit,
+          signal
+        })) {
+          if (!this.running) {
+            // bail if we've been shut down
+            return
+          }
 
-        try {
-          await this.add(peer.id)
-          peerStorePeers++
-        } catch (err) {
-          this.log('failed to add peer %p to routing table, removing kad-dht peer tags - %e')
-          await this.components.peerStore.merge(peer.id, {
-            tags: {
-              [this.peerTagName]: undefined
-            }
-          })
+          try {
+            await this.add(peer.id, {
+              signal
+            })
+            peerStorePeers++
+          } catch (err) {
+            this.log('failed to add peer %p to routing table, removing kad-dht peer tags - %e')
+            await this.components.peerStore.merge(peer.id, {
+              tags: {
+                [this.peerTagName]: undefined
+              }
+            })
+          }
         }
+      } finally {
+        signal.clear()
       }
 
       this.log('added %d peer store peers to the routing table', peerStorePeers)
     })
       .catch(err => {
-        this.log.error('error adding peer store peers to the routing table %e', err)
+        this.log.error('error adding %d, peer store peers to the routing table - %e', peerStorePeers, err)
       })
   }
 
   async stop (): Promise<void> {
     this.running = false
-    await stop(this.closestPeerTagger)
+    await stop(this.closestPeerTagger, this.kb)
     this.pingOldContactQueue.abort()
     this.pingNewContactQueue.abort()
+    this.shutdownController.abort()
   }
 
-  private async peerAdded (peer: Peer, bucket: LeafBucket): Promise<void> {
+  private async peerAdded (peer: Peer, bucket: LeafBucket, options?: AbortOptions): Promise<void> {
     if (!this.components.peerId.equals(peer.peerId)) {
       await this.components.peerStore.merge(peer.peerId, {
         tags: {
@@ -245,7 +264,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
             value: this.peerTagValue
           }
         }
-      })
+      }, options)
     }
 
     this.updateMetrics()
@@ -253,13 +272,13 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.safeDispatchEvent('peer:add', { detail: peer.peerId })
   }
 
-  private async peerRemoved (peer: Peer, bucket: LeafBucket): Promise<void> {
+  private async peerRemoved (peer: Peer, bucket: LeafBucket, options?: AbortOptions): Promise<void> {
     if (!this.components.peerId.equals(peer.peerId)) {
       await this.components.peerStore.merge(peer.peerId, {
         tags: {
           [this.peerTagName]: undefined
         }
-      })
+      }, options)
     }
 
     this.updateMetrics()
@@ -309,7 +328,11 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
         const result = await this.pingOldContactQueue.add(async (options) => {
           const signal = this.pingOldContactTimeout.getTimeoutSignal()
-          const signals = anySignal([signal, options?.signal])
+          const signals = anySignal([
+            signal,
+            this.shutdownController.signal,
+            options?.signal
+          ])
           setMaxListeners(Infinity, signal, signals)
 
           try {
@@ -341,7 +364,11 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
   async verifyNewContact (contact: Peer, options?: AbortOptions): Promise<boolean> {
     const signal = this.pingNewContactTimeout.getTimeoutSignal()
-    const signals = anySignal([signal, options?.signal])
+    const signals = anySignal([
+      signal,
+      this.shutdownController.signal,
+      options?.signal
+    ])
     setMaxListeners(Infinity, signal, signals)
 
     try {
@@ -408,8 +435,8 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   /**
    * Find a specific peer by id
    */
-  async find (peer: PeerId): Promise<PeerId | undefined> {
-    const kadId = await utils.convertPeerId(peer)
+  async find (peer: PeerId, options?: AbortOptions): Promise<PeerId | undefined> {
+    const kadId = await utils.convertPeerId(peer, options)
     return this.kb.get(kadId)?.peerId
   }
 
@@ -417,7 +444,9 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
    * Retrieve the closest peers to the given kadId
    */
   closestPeer (kadId: Uint8Array): PeerId | undefined {
-    const res = this.closestPeers(kadId, 1)
+    const res = this.closestPeers(kadId, {
+      count: 1
+    })
 
     if (res.length > 0) {
       return res[0]
@@ -429,12 +458,12 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   /**
    * Retrieve the `count`-closest peers to the given kadId
    */
-  closestPeers (kadId: Uint8Array, count = this.kBucketSize): PeerId[] {
+  closestPeers (kadId: Uint8Array, options?: GetClosestPeersOptions): PeerId[] {
     if (this.kb == null) {
       return []
     }
 
-    return [...this.kb.closest(kadId, count)]
+    return [...this.kb.closest(kadId, options)]
   }
 
   /**
@@ -451,14 +480,14 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   /**
    * Remove a given peer from the table
    */
-  async remove (peer: PeerId): Promise<void> {
+  async remove (peer: PeerId, options?: AbortOptions): Promise<void> {
     if (this.kb == null) {
       throw new Error('RoutingTable is not started')
     }
 
-    const kadId = await utils.convertPeerId(peer)
+    const kadId = await utils.convertPeerId(peer, options)
 
-    await this.kb.remove(kadId)
+    await this.kb.remove(kadId, options)
   }
 
   private updateMetrics (): void {