@libp2p/kad-dht 15.1.2 → 15.1.3-ae595d8db

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/kad-dht",
-  "version": "15.1.2",
+  "version": "15.1.3-ae595d8db",
   "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,21 +47,20 @@
     "doc-check": "aegir doc-check"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.1.4",
-    "@libp2p/interface": "^2.10.2",
-    "@libp2p/interface-internal": "^2.3.14",
-    "@libp2p/peer-collections": "^6.0.30",
-    "@libp2p/peer-id": "^5.1.5",
-    "@libp2p/ping": "^2.0.32",
-    "@libp2p/record": "^4.0.6",
-    "@libp2p/utils": "^6.6.5",
+    "@libp2p/crypto": "5.1.5-ae595d8db",
+    "@libp2p/interface": "2.10.3-ae595d8db",
+    "@libp2p/interface-internal": "2.3.15-ae595d8db",
+    "@libp2p/peer-collections": "6.0.31-ae595d8db",
+    "@libp2p/peer-id": "5.1.6-ae595d8db",
+    "@libp2p/ping": "2.0.33-ae595d8db",
+    "@libp2p/record": "4.0.7-ae595d8db",
+    "@libp2p/utils": "6.6.6-ae595d8db",
     "@multiformats/multiaddr": "^12.4.0",
     "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-length-prefixed": "^10.0.1",
     "it-map": "^3.1.3",
     "it-merge": "^3.0.11",
     "it-parallel": "^3.0.11",
@@ -69,8 +68,8 @@
     "it-protobuf-stream": "^2.0.2",
     "it-pushable": "^3.2.3",
     "it-take": "^3.0.8",
-    "mortice": "^3.0.6",
-    "multiformats": "^13.3.4",
+    "main-event": "^1.0.1",
+    "multiformats": "^13.3.6",
     "p-defer": "^4.0.1",
     "p-event": "^6.0.1",
     "progress-events": "^1.0.1",
@@ -81,26 +80,27 @@
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/interface-compliance-tests": "^6.4.8",
-    "@libp2p/logger": "^5.1.18",
-    "@libp2p/peer-store": "^11.2.2",
+    "@libp2p/interface-compliance-tests": "6.4.9-ae595d8db",
+    "@libp2p/logger": "5.1.19-ae595d8db",
+    "@libp2p/peer-store": "11.2.3-ae595d8db",
     "@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.6",
+    "aegir": "^47.0.14",
     "benchmark": "^2.1.4",
     "datastore-core": "^10.0.2",
     "delay": "^6.0.0",
     "execa": "^9.5.3",
     "it-filter": "^3.1.3",
     "it-last": "^3.0.8",
+    "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.0",
+    "protons": "^7.6.1",
     "sinon": "^20.0.0",
     "sinon-ts": "^2.0.0",
     "which": "^5.0.0"

package/src/constants.ts

@@ -27,8 +27,14 @@ export const REPROVIDE_MAX_QUEUE_SIZE = 16_384
 // How often to check if records need re-providing
 export const REPROVIDE_INTERVAL = hour
 
+// How long to reprovide for
+export const REPROVIDE_TIMEOUT = hour
+
 export const READ_MESSAGE_TIMEOUT = 10 * second
 
+// How long to process newly connected peers for
+export const ON_PEER_CONNECT_TIMEOUT = 10 * second
+
 // The number of records that will be retrieved on a call to getMany()
 export const GET_MANY_RECORD_COUNT = 16
 

package/src/content-fetching/index.ts

@@ -22,7 +22,7 @@ import type { Network, SendMessageOptions } from '../network.js'
 import type { PeerRouting } from '../peer-routing/index.js'
 import type { QueryManager } from '../query/manager.js'
 import type { QueryFunc } from '../query/types.js'
-import type { Logger, RoutingOptions } from '@libp2p/interface'
+import type { AbortOptions, Logger, RoutingOptions } from '@libp2p/interface'
 
 export interface ContentFetchingInit {
   validators: Validators
@@ -68,19 +68,19 @@ export class ContentFetching {
    * Attempt to retrieve the value for the given key from
    * the local datastore
    */
-  async getLocal (key: Uint8Array): Promise<Libp2pRecord> {
+  async getLocal (key: Uint8Array, options?: AbortOptions): Promise<Libp2pRecord> {
     this.log('getLocal %b', key)
 
     const dsKey = bufferToRecordKey(this.datastorePrefix, key)
 
     this.log('fetching record for key %k', dsKey)
 
-    const raw = await this.components.datastore.get(dsKey)
+    const raw = await this.components.datastore.get(dsKey, options)
     this.log('found %k in local datastore', dsKey)
 
     const rec = Libp2pRecord.deserialize(raw)
 
-    await verifyRecord(this.validators, rec)
+    await verifyRecord(this.validators, rec, options)
 
     return rec
   }
@@ -104,7 +104,7 @@ export class ContentFetching {
         try {
           const dsKey = bufferToRecordKey(this.datastorePrefix, key)
           this.log(`Storing corrected record for key ${dsKey.toString()}`)
-          await this.components.datastore.put(dsKey, fixupRec.subarray())
+          await this.components.datastore.put(dsKey, fixupRec.subarray(), options)
         } catch (err: any) {
           this.log.error('Failed error correcting self', err)
         }
@@ -148,7 +148,7 @@ export class ContentFetching {
     // store the record locally
     const dsKey = bufferToRecordKey(this.datastorePrefix, key)
     this.log(`storing record for key ${dsKey.toString()}`)
-    await this.components.datastore.put(dsKey, record.subarray())
+    await this.components.datastore.put(dsKey, record.subarray(), options)
 
     // put record to the closest peers
     yield * pipe(
@@ -265,7 +265,7 @@ export class ContentFetching {
     this.log('getMany values for %b', key)
 
     try {
-      const localRec = await this.getLocal(key)
+      const localRec = await this.getLocal(key, options)
 
       yield valueEvent({
         value: localRec.value,

package/src/content-routing/index.ts

@@ -83,7 +83,7 @@ export class ContentRouting {
     const target = key.multihash.bytes
 
     // Add peer as provider
-    await this.providers.addProvider(key, this.components.peerId)
+    await this.providers.addProvider(key, this.components.peerId, options)
 
     const msg: Partial<Message> = {
       type: MessageType.ADD_PROVIDER,
@@ -182,7 +182,7 @@ export class ContentRouting {
 
     this.log('findProviders %c', key)
 
-    const provs = await this.providers.getProviders(key)
+    const provs = await this.providers.getProviders(key, options)
 
     // yield values if we have some, also slice because maybe we got lucky and already have too many?
     if (provs.length > 0) {
@@ -190,7 +190,7 @@ export class ContentRouting {
 
       for (const peerId of provs.slice(0, toFind)) {
         try {
-          const peer = await this.components.peerStore.get(peerId)
+          const peer = await this.components.peerStore.get(peerId, options)
 
           providers.push({
             id: peerId,

package/src/errors.ts

@@ -8,16 +8,6 @@ export class QueryError extends Error {
   }
 }
 
-/**
- * A query was aborted
- */
-export class QueryAbortedError extends Error {
-  constructor (message = 'Query aborted') {
-    super(message)
-    this.name = 'QueryAbortedError'
-  }
-}
-
 /**
  * An invalid record was received
  */

package/src/index.ts

@@ -135,11 +135,12 @@
 import { KadDHT as KadDHTClass } from './kad-dht.js'
 import { MessageType } from './message/dht.js'
 import { removePrivateAddressesMapper, removePublicAddressesMapper, passthroughMapper } from './utils.js'
-import type { Libp2pEvents, ComponentLogger, TypedEventTarget, Metrics, PeerId, PeerInfo, PeerStore, RoutingOptions, PrivateKey } from '@libp2p/interface'
+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 { Datastore } from 'interface-datastore'
+import type { TypedEventTarget } from 'main-event'
 import type { CID } from 'multiformats/cid'
 import type { ProgressEvent } from 'progress-events'
 
@@ -302,6 +303,10 @@ export interface PeerInfoMapper {
   (peer: PeerInfo): PeerInfo
 }
 
+export interface SetModeOptions extends AbortOptions {
+  force?: boolean
+}
+
 export interface KadDHT {
   /**
    * This is the maximum size of the k-buckets and how many peers are looked up
@@ -350,7 +355,7 @@ export interface KadDHT {
    * Provider records must be re-published every 24 hours - pass a previously
    * provided CID here to not re-publish a record for it any more
    */
-  cancelReprovide(key: CID): Promise<void>
+  cancelReprovide(key: CID, options?: AbortOptions): Promise<void>
 
   /**
    * Store the passed value under the passed key on the DHT
@@ -366,12 +371,12 @@ export interface KadDHT {
    * If 'server' this node will respond to DHT queries, if 'client' this node
    * will not.
    */
-  setMode(mode: 'client' | 'server'): Promise<void>
+  setMode(mode: 'client' | 'server', options?: SetModeOptions): Promise<void>
 
   /**
    * Force a routing table refresh
    */
-  refreshRoutingTable(): Promise<void>
+  refreshRoutingTable(options?: AbortOptions): Promise<void>
 }
 
 export interface SingleKadDHT extends KadDHT {
@@ -388,7 +393,7 @@ export interface SelectFn { (key: Uint8Array, records: Uint8Array[]): number }
  * A validator function takes a DHT key and the value of the record for that key
  * and throws if the record is invalid
  */
-export interface ValidateFn { (key: Uint8Array, value: Uint8Array): Promise<void> }
+export interface ValidateFn { (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> }
 
 /**
  * Selectors are a map of key prefixes to selector functions
@@ -680,6 +685,23 @@ export interface KadDHTInit {
    * Dynamic network timeout settings for sending messages to peers
    */
   networkDialTimeout?: Omit<AdaptiveTimeoutInit, 'metricsName' | 'metrics'>
+
+  /**
+   * When a peer that supports the KAD-DHT protocol connects we try to add it to
+   * the routing table. This setting is how long we will try to do that for in
+   * ms.
+   *
+   * @default 10_000
+   */
+  onPeerConnectTimeout?: number
+
+  /**
+   * When acting as a DHT server, all incoming RPC requests must complete within
+   * this timeout in ms otherwise the stream will be closed.
+   *
+   * @default 10_000
+   */
+  incomingMessageTimeout?: number
 }
 
 export interface KadDHTComponents {

package/src/kad-dht.ts

@@ -1,8 +1,8 @@
-import { NotFoundError, TypedEventEmitter, contentRoutingSymbol, peerDiscoverySymbol, peerRoutingSymbol, serviceCapabilities, serviceDependencies, start, stop } from '@libp2p/interface'
+import { NotFoundError, contentRoutingSymbol, peerDiscoverySymbol, peerRoutingSymbol, serviceCapabilities, serviceDependencies, start, stop } from '@libp2p/interface'
 import drain from 'it-drain'
-import createMortice from 'mortice'
+import { setMaxListeners, TypedEventEmitter } from 'main-event'
 import pDefer from 'p-defer'
-import { ALPHA, PROTOCOL } from './constants.js'
+import { ALPHA, ON_PEER_CONNECT_TIMEOUT, PROTOCOL } from './constants.js'
 import { ContentFetching } from './content-fetching/index.js'
 import { ContentRouting as KADDHTContentRouting } from './content-routing/index.js'
 import { Network } from './network.js'
@@ -22,8 +22,9 @@ import {
   removePrivateAddressesMapper,
   timeOperationGenerator
 } from './utils.js'
-import type { KadDHTComponents, KadDHTInit, Validators, Selectors, KadDHT as KadDHTInterface, QueryEvent, PeerInfoMapper } from './index.js'
+import type { KadDHTComponents, KadDHTInit, Validators, Selectors, KadDHT as KadDHTInterface, QueryEvent, PeerInfoMapper, SetModeOptions } from './index.js'
 import type { ContentRouting, CounterGroup, Logger, MetricGroup, PeerDiscovery, PeerDiscoveryEvents, PeerId, PeerInfo, PeerRouting, RoutingOptions, Startable } from '@libp2p/interface'
+import type { AbortOptions } from 'it-pushable'
 import type { CID } from 'multiformats/cid'
 
 /**
@@ -142,6 +143,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
   private readonly dhtPeerRouting: DHTPeerRouting
   private readonly peerInfoMapper: PeerInfoMapper
   private readonly reprovider: Reprovider
+  private readonly onPeerConnectTimeout: number
 
   /**
    * Create a new KadDHT
@@ -171,14 +173,12 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
     this.maxInboundStreams = init.maxInboundStreams ?? DEFAULT_MAX_INBOUND_STREAMS
     this.maxOutboundStreams = init.maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS
     this.peerInfoMapper = init.peerInfoMapper ?? removePrivateAddressesMapper
-
-    const providerLock = createMortice()
+    this.onPeerConnectTimeout = init.onPeerConnectTimeout ?? ON_PEER_CONNECT_TIMEOUT
 
     this.providers = new Providers(components, {
       ...init.providers,
       logPrefix,
-      datastorePrefix,
-      lock: providerLock
+      datastorePrefix
     })
 
     this.validators = {
@@ -289,7 +289,6 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
       metricsPrefix,
       datastorePrefix,
       contentRouting: this.contentRouting,
-      lock: providerLock,
       operationMetrics
     })
 
@@ -366,7 +365,8 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
   readonly [serviceCapabilities]: string[] = [
     '@libp2p/content-routing',
     '@libp2p/peer-routing',
-    '@libp2p/peer-discovery'
+    '@libp2p/peer-discovery',
+    '@libp2p/kad-dht'
   ]
 
   readonly [serviceDependencies]: string[] = [
@@ -396,8 +396,13 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
       return
     }
 
+    const signal = AbortSignal.timeout(this.onPeerConnectTimeout)
+    setMaxListeners(Infinity, signal)
+
     try {
-      await this.routingTable.add(peerData.id)
+      await this.routingTable.add(peerData.id, {
+        signal
+      })
     } catch (err: any) {
       this.log.error('could not add %p to routing table', peerData.id, err)
     }
@@ -420,16 +425,16 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
   /**
    * If 'server' this node will respond to DHT queries, if 'client' this node will not
    */
-  async setMode (mode: 'client' | 'server', force = false): Promise<void> {
-    if (mode === this.getMode() && !force) {
+  async setMode (mode: 'client' | 'server', options?: SetModeOptions): Promise<void> {
+    if (mode === this.getMode() && options?.force !== true) {
       this.log('already in %s mode', mode)
       return
     }
 
-    await this.components.registrar.unhandle(this.protocol)
+    await this.components.registrar.unhandle(this.protocol, options)
 
     // check again after async work
-    if (mode === this.getMode() && !force) {
+    if (mode === this.getMode() && options?.force !== true) {
       this.log('already in %s mode', mode)
       return
     }
@@ -441,6 +446,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
       this.log('enabling server mode while in %s mode', this.getMode())
       this.clientMode = false
       await this.components.registrar.handle(this.protocol, this.rpc.onIncomingStream.bind(this.rpc), {
+        signal: options?.signal,
         maxInboundStreams: this.maxInboundStreams,
         maxOutboundStreams: this.maxOutboundStreams
       })
@@ -458,7 +464,9 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
     this.running = true
 
     // Only respond to queries when not in client mode
-    await this.setMode(this.clientMode ? 'client' : 'server', true)
+    await this.setMode(this.clientMode ? 'client' : 'server', {
+      force: true
+    })
 
     await start(
       this.routingTable,
@@ -520,8 +528,8 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
    * Provider records must be re-published every 24 hours - pass a previously
    * provided CID here to not re-publish a record for it any more
    */
-  async cancelReprovide (key: CID): Promise<void> {
-    await this.providers.removeProvider(key, this.components.peerId)
+  async cancelReprovide (key: CID, options?: AbortOptions): Promise<void> {
+    await this.providers.removeProvider(key, this.components.peerId, options)
   }
 
   /**
@@ -547,7 +555,7 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
     yield * this.peerRouting.getClosestPeers(key, options)
   }
 
-  async refreshRoutingTable (): Promise<void> {
-    this.routingTableRefresh.refreshTable(true)
+  async refreshRoutingTable (options?: AbortOptions): Promise<void> {
+    this.routingTableRefresh.refreshTable(true, options)
   }
 }

package/src/network.ts

@@ -1,7 +1,8 @@
-import { InvalidParametersError, TypedEventEmitter } from '@libp2p/interface'
+import { InvalidParametersError } from '@libp2p/interface'
 import { Libp2pRecord } from '@libp2p/record'
 import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
 import { pbStream } from 'it-protobuf-stream'
+import { TypedEventEmitter } from 'main-event'
 import { Message } from './message/dht.js'
 import { fromPbPeerInfo } from './message/utils.js'
 import {

package/src/peer-distance-list.ts

@@ -2,7 +2,7 @@ import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
 import { convertPeerId } from './utils.js'
 import type { DisjointPath } from './index.js'
-import type { PeerId, PeerInfo } from '@libp2p/interface'
+import type { AbortOptions, PeerId, PeerInfo } from '@libp2p/interface'
 
 interface PeerDistance {
   peer: PeerInfo
@@ -49,8 +49,8 @@ export class PeerDistanceList {
   /**
    * Add a peerId to the list.
    */
-  async add (peer: PeerInfo, path: DisjointPath = { index: -1, queued: 0, running: 0, total: 0 }): Promise<void> {
-    const dhtKey = await convertPeerId(peer.id)
+  async add (peer: PeerInfo, path: DisjointPath = { index: -1, queued: 0, running: 0, total: 0 }, options?: AbortOptions): Promise<void> {
+    const dhtKey = await convertPeerId(peer.id, options)
 
     this.addWithKadId(peer, dhtKey, path)
   }
@@ -100,12 +100,12 @@ export class PeerDistanceList {
    * Indicates whether any of the peerIds passed as a parameter are closer
    * to the origin key than the furthest peerId in the PeerDistanceList.
    */
-  async isCloser (peerId: PeerId): Promise<boolean> {
+  async isCloser (peerId: PeerId, options?: AbortOptions): Promise<boolean> {
     if (this.length === 0) {
       return true
     }
 
-    const dhtKey = await convertPeerId(peerId)
+    const dhtKey = await convertPeerId(peerId, options)
     const dhtKeyXor = uint8ArrayXor(dhtKey, this.originDhtKey)
     const furthestDistance = this.peerDistances[this.peerDistances.length - 1].distance
 
@@ -116,13 +116,13 @@ export class PeerDistanceList {
    * Indicates whether any of the peerIds passed as a parameter are closer
    * to the origin key than the furthest peerId in the PeerDistanceList.
    */
-  async anyCloser (peerIds: PeerId[]): Promise<boolean> {
+  async anyCloser (peerIds: PeerId[], options?: AbortOptions): Promise<boolean> {
     if (peerIds.length === 0) {
       return false
     }
 
     return Promise.any(
-      peerIds.map(async peerId => this.isCloser(peerId))
+      peerIds.map(async peerId => this.isCloser(peerId, options))
     )
   }
 }

package/src/peer-routing/index.ts

@@ -3,8 +3,6 @@ import { InvalidPublicKeyError, NotFoundError } from '@libp2p/interface'
 import { peerIdFromPublicKey, peerIdFromMultihash } from '@libp2p/peer-id'
 import { Libp2pRecord } from '@libp2p/record'
 import * as Digest from 'multiformats/hashes/digest'
-import { xor as uint8ArrayXor } from 'uint8arrays/xor'
-import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
 import { QueryError, InvalidRecordError } from '../errors.js'
 import { MessageType } from '../message/dht.js'
 import { PeerDistanceList } from '../peer-distance-list.js'
@@ -14,15 +12,17 @@ import {
   valueEvent
 } from '../query/events.js'
 import { verifyRecord } from '../record/validators.js'
-import { convertBuffer, convertPeerId, keyForPublicKey } from '../utils.js'
+import { convertBuffer, keyForPublicKey } from '../utils.js'
 import type { DHTRecord, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
 import type { Message } from '../message/dht.js'
 import type { Network, SendMessageOptions } from '../network.js'
 import type { QueryManager, QueryOptions } from '../query/manager.js'
 import type { QueryFunc } from '../query/types.js'
 import type { RoutingTable } from '../routing-table/index.js'
+import type { GetClosestPeersOptions } from '../routing-table/k-bucket.ts'
 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 +68,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 +86,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 +168,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,12 +240,12 @@ 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
 
     const getCloserPeersQuery: QueryFunc = async function * ({ peer, path, peerKadId, signal }) {
-      self.log('getClosestPeers asking %p', peer)
+      self.log('getClosestPeers asking %p', peer.id)
       const request: Partial<Message> = {
         type: MessageType.FIND_NODE,
         key
@@ -268,7 +268,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 +277,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 +303,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 +326,18 @@ 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
+   * Get the peers in our routing table that are closest to the passed key
    */
-  async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId): Promise<PeerInfo[]> {
+  async getClosestPeersOffline (key: Uint8Array, options?: GetClosestPeersOptions): Promise<PeerInfo[]> {
     const output: PeerInfo[] = []
 
     // try getting the peer directly
@@ -346,7 +345,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,22 +353,12 @@ export class PeerRouting {
       })
     } catch {}
 
-    const keyKadId = await convertBuffer(key)
-    const ids = this.routingTable.closestPeers(keyKadId)
-    const closerThanKadId = await convertPeerId(closerThan)
-    const requesterXor = uint8ArrayXor(closerThanKadId, keyKadId)
+    const keyKadId = await convertBuffer(key, options)
+    const ids = this.routingTable.closestPeers(keyKadId, options)
 
     for (const peerId of ids) {
-      const peerKadId = await convertPeerId(peerId)
-      const peerXor = uint8ArrayXor(peerKadId, keyKadId)
-
-      // only include if peer is closer than requester
-      if (uint8ArrayXorCompare(peerXor, requesterXor) !== -1) {
-        continue
-      }
-
       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
@@ -378,9 +367,9 @@ export class PeerRouting {
     }
 
     if (output.length > 0) {
-      this.log('getCloserPeersOffline found %d peer(s) closer to %b than %p', output.length, key, closerThan)
+      this.log('getClosestPeersOffline returning the %d closest peer(s) %b we know', output.length, key)
     } else {
-      this.log('getCloserPeersOffline could not find peer closer to %b than %p with %d peers in the routing table', key, closerThan, this.routingTable.size)
+      this.log('getClosestPeersOffline could not any peers close to %b with %d peers in the routing table', key, this.routingTable.size)
     }
 
     return output