@libp2p/kad-dht 15.1.1 → 15.1.2-3528df829

package/src/peer-routing/index.ts

@@ -23,6 +23,7 @@ import type { QueryFunc } from '../query/types.js'
 import type { RoutingTable } from '../routing-table/index.js'
 import type { ComponentLogger, Logger, Metrics, PeerId, PeerInfo, PeerStore, RoutingOptions } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
+import type { AbortOptions } from 'it-pushable'
 
 export interface PeerRoutingComponents {
   peerId: PeerId
@@ -68,15 +69,15 @@ export class PeerRouting {
    * Look if we are connected to a peer with the given id.
    * Returns its id and addresses, if found, otherwise `undefined`.
    */
-  async findPeerLocal (peer: PeerId): Promise<PeerInfo | undefined> {
+  async findPeerLocal (peer: PeerId, options?: AbortOptions): Promise<PeerInfo | undefined> {
     let peerData
-    const p = await this.routingTable.find(peer)
+    const p = await this.routingTable.find(peer, options)
 
     if (p != null) {
       this.log('findPeerLocal found %p in routing table', peer)
 
       try {
-        peerData = await this.components.peerStore.get(p)
+        peerData = await this.components.peerStore.get(p, options)
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err
@@ -86,7 +87,7 @@ export class PeerRouting {
 
     if (peerData == null) {
       try {
-        peerData = await this.components.peerStore.get(peer)
+        peerData = await this.components.peerStore.get(peer, options)
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err
@@ -168,7 +169,7 @@ export class PeerRouting {
 
     if (options.useCache !== false) {
       // Try to find locally
-      const pi = await this.findPeerLocal(id)
+      const pi = await this.findPeerLocal(id, options)
 
       // already got it
       if (pi != null) {
@@ -240,7 +241,7 @@ export class PeerRouting {
    */
   async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     this.log('getClosestPeers to %b', key)
-    const kadId = await convertBuffer(key)
+    const kadId = await convertBuffer(key, options)
     const peers = new PeerDistanceList(kadId, this.routingTable.kBucketSize)
     const self = this
 
@@ -268,7 +269,7 @@ export class PeerRouting {
     for (let { peer, path } of peers.peers) {
       try {
         if (peer.multiaddrs.length === 0) {
-          peer = await self.components.peerStore.getInfo(peer.id)
+          peer = await self.components.peerStore.getInfo(peer.id, options)
         }
 
         if (peer.multiaddrs.length === 0) {
@@ -277,7 +278,7 @@ export class PeerRouting {
 
         yield finalPeerEvent({
           from: this.components.peerId,
-          peer: await self.components.peerStore.getInfo(peer.id),
+          peer: await self.components.peerStore.getInfo(peer.id, options),
           path: {
             index: path.index,
             queued: 0,
@@ -303,7 +304,7 @@ export class PeerRouting {
         if (event.record != null) {
           // We have a record
           try {
-            await this._verifyRecordOnline(event.record)
+            await this._verifyRecordOnline(event.record, options)
           } catch (err: any) {
             const errMsg = 'invalid record received, discarded'
             this.log(errMsg)
@@ -326,19 +327,19 @@ export class PeerRouting {
    * Verify a record, fetching missing public keys from the network.
    * Throws an error if the record is invalid.
    */
-  async _verifyRecordOnline (record: DHTRecord): Promise<void> {
+  async _verifyRecordOnline (record: DHTRecord, options?: AbortOptions): Promise<void> {
     if (record.timeReceived == null) {
       throw new InvalidRecordError('invalid record received')
     }
 
-    await verifyRecord(this.validators, new Libp2pRecord(record.key, record.value, record.timeReceived))
+    await verifyRecord(this.validators, new Libp2pRecord(record.key, record.value, record.timeReceived), options)
   }
 
   /**
    * Get the peers in our routing table that are closer than the passed PeerId
    * to the passed key
    */
-  async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId): Promise<PeerInfo[]> {
+  async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId, options?: AbortOptions): Promise<PeerInfo[]> {
     const output: PeerInfo[] = []
 
     // try getting the peer directly
@@ -346,7 +347,7 @@ export class PeerRouting {
       const multihash = Digest.decode(key)
       const targetPeerId = peerIdFromMultihash(multihash)
 
-      const peer = await this.components.peerStore.get(targetPeerId)
+      const peer = await this.components.peerStore.get(targetPeerId, options)
 
       output.push({
         id: peer.id,
@@ -354,13 +355,13 @@ export class PeerRouting {
       })
     } catch {}
 
-    const keyKadId = await convertBuffer(key)
+    const keyKadId = await convertBuffer(key, options)
     const ids = this.routingTable.closestPeers(keyKadId)
-    const closerThanKadId = await convertPeerId(closerThan)
+    const closerThanKadId = await convertPeerId(closerThan, options)
     const requesterXor = uint8ArrayXor(closerThanKadId, keyKadId)
 
     for (const peerId of ids) {
-      const peerKadId = await convertPeerId(peerId)
+      const peerKadId = await convertPeerId(peerId, options)
       const peerXor = uint8ArrayXor(peerKadId, keyKadId)
 
       // only include if peer is closer than requester
@@ -369,7 +370,7 @@ export class PeerRouting {
       }
 
       try {
-        output.push(await this.components.peerStore.getInfo(peerId))
+        output.push(await this.components.peerStore.getInfo(peerId, options))
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err

package/src/providers.ts

@@ -18,6 +18,10 @@ export interface ProvidersComponents {
   metrics?: Metrics
 }
 
+interface WriteProviderEntryOptions extends AbortOptions {
+  time?: Date
+}
+
 /**
  * Provides a mechanism to add and remove provider records from the datastore
  */
@@ -38,11 +42,11 @@ export class Providers {
    * Add a new provider for the given CID
    */
   async addProvider (cid: CID, provider: PeerId, options?: AbortOptions): Promise<void> {
-    const release = await this.lock.readLock()
+    const release = await this.lock.readLock(options)
 
     try {
       this.log.trace('%p provides %s', provider, cid)
-      await this.writeProviderEntry(cid, provider)
+      await this.writeProviderEntry(cid, provider, options)
     } finally {
       release()
     }
@@ -52,7 +56,7 @@ export class Providers {
    * Remove a provider for the given CID
    */
   async removeProvider (cid: CID, provider: PeerId, options?: AbortOptions): Promise<void> {
-    const release = await this.lock.writeLock()
+    const release = await this.lock.writeLock(options)
 
     try {
       const key = toProviderKey(this.datastorePrefix, cid, provider)
@@ -67,7 +71,7 @@ export class Providers {
    * Get a list of providers for the given CID
    */
   async getProviders (cid: CID, options?: AbortOptions): Promise<PeerId[]> {
-    const release = await this.lock.readLock()
+    const release = await this.lock.readLock(options)
 
     try {
       this.log.trace('get providers for %c', cid)
@@ -83,9 +87,9 @@ export class Providers {
   /**
    * 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

@@ -165,7 +165,9 @@ export class QueryManager implements Startable {
 
       log('query:start')
 
-      const id = await convertBuffer(key)
+      const id = await convertBuffer(key, {
+        signal
+      })
       const peers = this.routingTable.closestPeers(id, this.routingTable.kBucketSize)
 
       // split peers into d buckets evenly(ish)

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

@@ -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

@@ -2,7 +2,7 @@ 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 { 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'
@@ -103,7 +103,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,8 +122,8 @@ 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> {
+    const release = await this.lock.writeLock(options)
 
     try {
       this.safeDispatchEvent('reprovide:start')
@@ -165,7 +167,9 @@ export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
 
       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 +177,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

@@ -139,7 +139,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 +148,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,7 +185,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     this.running = true
 
-    await start(this.closestPeerTagger)
+    await start(this.closestPeerTagger, this.kb)
     await this.kb.addSelfPeer(this.components.peerId)
   }
 
@@ -232,12 +233,12 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
   async stop (): Promise<void> {
     this.running = false
-    await stop(this.closestPeerTagger)
+    await stop(this.closestPeerTagger, this.kb)
     this.pingOldContactQueue.abort()
     this.pingNewContactQueue.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 +246,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
             value: this.peerTagValue
           }
         }
-      })
+      }, options)
     }
 
     this.updateMetrics()
@@ -253,13 +254,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()
@@ -408,8 +409,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
   }
 
@@ -451,14 +452,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 {

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,25 @@ 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 {
+  metrics?: Metrics
 }
 
 export interface KBucketOptions {
@@ -97,6 +101,7 @@ export interface KBucketOptions {
   verify: VerifyFunction
   onAdd?: OnAddCallback
   onRemove?: OnRemoveCallback
+  metricsPrefix?: string
 }
 
 export interface Peer {
@@ -143,7 +148,7 @@ export class KBucket {
   private readonly onMove?: OnMoveCallback
   private readonly addingPeerMap: PeerMap<Promise<void>>
 
-  constructor (options: KBucketOptions) {
+  constructor (components: KBucketComponents, options: KBucketOptions) {
     this.prefixLength = options.prefixLength ?? PREFIX_LENGTH
     this.kBucketSize = options.kBucketSize ?? KBUCKET_SIZE
     this.splitThreshold = options.splitThreshold ?? this.kBucketSize
@@ -153,7 +158,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 +170,14 @@ export class KBucket {
     }
   }
 
-  async addSelfPeer (peerId: PeerId): Promise<void> {
+  stop (): void {
+    this.addingPeerMap.clear()
+  }
+
+  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 +188,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 +218,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 +231,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 +286,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
@@ -351,14 +363,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 +451,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 +470,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)
       }
     }