@libp2p/kad-dht 11.0.8 → 12.0.0-4e0135c7d

package/src/peer-routing/index.ts

@@ -2,7 +2,7 @@ import { keys } from '@libp2p/crypto'
 import { CodeError } from '@libp2p/interface'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { Message, MESSAGE_TYPE } from '../message/index.js'
+import { MessageType } from '../message/dht.js'
 import { PeerDistanceList } from '../peer-list/peer-distance-list.js'
 import {
   queryErrorEvent,
@@ -13,18 +13,19 @@ import { Libp2pRecord } from '../record/index.js'
 import { verifyRecord } from '../record/validators.js'
 import * as utils from '../utils.js'
 import type { KadDHTComponents, DHTRecord, DialPeerEvent, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
+import type { Message } from '../message/dht.js'
 import type { Network } 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 { AbortOptions, Logger, PeerId, PeerInfo, PeerStore } from '@libp2p/interface'
+import type { Logger, PeerId, PeerInfo, PeerStore, RoutingOptions } from '@libp2p/interface'
 
 export interface PeerRoutingInit {
   routingTable: RoutingTable
   network: Network
   validators: Validators
   queryManager: QueryManager
-  lan: boolean
+  logPrefix: string
 }
 
 export class PeerRouting {
@@ -37,7 +38,7 @@ export class PeerRouting {
   private readonly peerId: PeerId
 
   constructor (components: KadDHTComponents, init: PeerRoutingInit) {
-    const { routingTable, network, validators, queryManager, lan } = init
+    const { routingTable, network, validators, queryManager, logPrefix } = init
 
     this.routingTable = routingTable
     this.network = network
@@ -45,7 +46,7 @@ export class PeerRouting {
     this.queryManager = queryManager
     this.peerStore = components.peerStore
     this.peerId = components.peerId
-    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:peer-routing`)
+    this.log = components.logger.forComponent(`${logPrefix}:peer-routing`)
   }
 
   /**
@@ -93,15 +94,19 @@ export class PeerRouting {
   /**
    * Get a value via rpc call for the given parameters
    */
-  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
-    const msg = new Message(MESSAGE_TYPE.GET_VALUE, key, 0)
+  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
+    const msg: Partial<Message> = {
+      type: MessageType.GET_VALUE,
+      key
+    }
+
     yield * this.network.sendRequest(peer, msg, options)
   }
 
   /**
    * Get the public key directly from a node
    */
-  async * getPublicKeyFromNode (peer: PeerId, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
+  async * getPublicKeyFromNode (peer: PeerId, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
     const pkKey = utils.keyForPublicKey(peer)
 
     for await (const event of this._getValueSingle(peer, pkKey, options)) {
@@ -129,52 +134,59 @@ export class PeerRouting {
   /**
    * Search for a peer with the given ID
    */
-  async * findPeer (id: PeerId, options: QueryOptions = {}): AsyncGenerator<FinalPeerEvent | QueryEvent> {
+  async * findPeer (id: PeerId, options: RoutingOptions = {}): AsyncGenerator<FinalPeerEvent | QueryEvent> {
     this.log('findPeer %p', id)
 
-    // Try to find locally
-    const pi = await this.findPeerLocal(id)
-
-    // already got it
-    if (pi != null) {
-      this.log('found local')
-      yield finalPeerEvent({
-        from: this.peerId,
-        peer: pi
-      }, options)
-      return
+    if (options.useCache !== false) {
+      // Try to find locally
+      const pi = await this.findPeerLocal(id)
+
+      // already got it
+      if (pi != null) {
+        this.log('found local')
+        yield finalPeerEvent({
+          from: this.peerId,
+          peer: pi
+        }, options)
+        return
+      }
     }
 
-    const self = this // eslint-disable-line @typescript-eslint/no-this-alias
+    let foundPeer = false
 
-    const findPeerQuery: QueryFunc = async function * ({ peer, signal }) {
-      const request = new Message(MESSAGE_TYPE.FIND_NODE, id.toBytes(), 0)
+    if (options.useNetwork !== false) {
+      const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
-      for await (const event of self.network.sendRequest(peer, request, {
-        ...options,
-        signal
-      })) {
-        yield event
+      const findPeerQuery: QueryFunc = async function * ({ peer, signal }) {
+        const request: Partial<Message> = {
+          type: MessageType.FIND_NODE,
+          key: id.toBytes()
+        }
+
+        for await (const event of self.network.sendRequest(peer, request, {
+          ...options,
+          signal
+        })) {
+          yield event
 
-        if (event.name === 'PEER_RESPONSE') {
-          const match = event.closer.find((p) => p.id.equals(id))
+          if (event.name === 'PEER_RESPONSE') {
+            const match = event.closer.find((p) => p.id.equals(id))
 
-          // found the peer
-          if (match != null) {
-            yield finalPeerEvent({ from: event.from, peer: match }, options)
+            // found the peer
+            if (match != null) {
+              yield finalPeerEvent({ from: event.from, peer: match }, options)
+            }
           }
         }
       }
-    }
 
-    let foundPeer = false
+      for await (const event of this.queryManager.run(id.toBytes(), findPeerQuery, options)) {
+        if (event.name === 'FINAL_PEER') {
+          foundPeer = true
+        }
 
-    for await (const event of this.queryManager.run(id.toBytes(), findPeerQuery, options)) {
-      if (event.name === 'FINAL_PEER') {
-        foundPeer = true
+        yield event
       }
-
-      yield event
     }
 
     if (!foundPeer) {
@@ -197,7 +209,10 @@ export class PeerRouting {
 
     const getCloserPeersQuery: QueryFunc = async function * ({ peer, signal }) {
       self.log('closerPeersSingle %s from %p', uint8ArrayToString(key, 'base32'), peer)
-      const request = new Message(MESSAGE_TYPE.FIND_NODE, key, 0)
+      const request: Partial<Message> = {
+        type: MessageType.FIND_NODE,
+        key
+      }
 
       yield * self.network.sendRequest(peer, request, {
         ...options,
@@ -240,7 +255,7 @@ export class PeerRouting {
    *
    * Note: The peerStore is updated with new addresses found for the given peer.
    */
-  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: AbortOptions = {}): AsyncGenerator<DialPeerEvent | QueryEvent> {
+  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: RoutingOptions = {}): AsyncGenerator<DialPeerEvent | QueryEvent> {
     for await (const event of this._getValueSingle(peer, key, options)) {
       if (event.name === 'PEER_RESPONSE') {
         if (event.record != null) {

package/src/providers.ts

@@ -15,13 +15,20 @@ import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats'
 
 export interface ProvidersInit {
+  /**
+   * @default 256
+   */
   cacheSize?: number
   /**
    * How often invalid records are cleaned. (in seconds)
+   *
+   * @default 5400
    */
   cleanupInterval?: number
   /**
    * How long is a provider valid for. (in seconds)
+   *
+   * @default 86400
    */
   provideValidity?: number
 }

package/src/query/events.ts

@@ -1,22 +1,22 @@
 import { CustomEvent } from '@libp2p/interface'
-import { MESSAGE_TYPE_LOOKUP } from '../message/index.js'
-import type { SendQueryEvent, PeerResponseEvent, DialPeerEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent, QueryOptions } from '../index.js'
-import type { Message } from '../message/dht.js'
+import { MessageType } from '../message/dht.js'
+import type { SendQueryEvent, PeerResponseEvent, DialPeerEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '../index.js'
 import type { Libp2pRecord } from '../record/index.js'
 import type { PeerId, PeerInfo } from '@libp2p/interface'
+import type { ProgressOptions } from 'progress-events'
 
 export interface QueryEventFields {
   to: PeerId
-  type: Message.MessageType
+  type: MessageType
 }
 
-export function sendQueryEvent (fields: QueryEventFields, options: QueryOptions = {}): SendQueryEvent {
+export function sendQueryEvent (fields: QueryEventFields, options: ProgressOptions = {}): SendQueryEvent {
   const event: SendQueryEvent = {
     ...fields,
     name: 'SEND_QUERY',
     type: 0,
     messageName: fields.type,
-    messageType: MESSAGE_TYPE_LOOKUP.indexOf(fields.type.toString())
+    messageType: MessageType[fields.type]
   }
 
   options.onProgress?.(new CustomEvent('kad-dht:query:send-query', { detail: event }))
@@ -26,13 +26,13 @@ export function sendQueryEvent (fields: QueryEventFields, options: QueryOptions
 
 export interface PeerResponseEventField {
   from: PeerId
-  messageType: Message.MessageType
+  messageType: MessageType
   closer?: PeerInfo[]
   providers?: PeerInfo[]
   record?: Libp2pRecord
 }
 
-export function peerResponseEvent (fields: PeerResponseEventField, options: QueryOptions = {}): PeerResponseEvent {
+export function peerResponseEvent (fields: PeerResponseEventField, options: ProgressOptions = {}): PeerResponseEvent {
   const event: PeerResponseEvent = {
     ...fields,
     name: 'PEER_RESPONSE',
@@ -52,7 +52,7 @@ export interface FinalPeerEventFields {
   peer: PeerInfo
 }
 
-export function finalPeerEvent (fields: FinalPeerEventFields, options: QueryOptions = {}): FinalPeerEvent {
+export function finalPeerEvent (fields: FinalPeerEventFields, options: ProgressOptions = {}): FinalPeerEvent {
   const event: FinalPeerEvent = {
     ...fields,
     name: 'FINAL_PEER',
@@ -69,7 +69,7 @@ export interface ErrorEventFields {
   error: Error
 }
 
-export function queryErrorEvent (fields: ErrorEventFields, options: QueryOptions = {}): QueryErrorEvent {
+export function queryErrorEvent (fields: ErrorEventFields, options: ProgressOptions = {}): QueryErrorEvent {
   const event: QueryErrorEvent = {
     ...fields,
     name: 'QUERY_ERROR',
@@ -86,7 +86,7 @@ export interface ProviderEventFields {
   providers: PeerInfo[]
 }
 
-export function providerEvent (fields: ProviderEventFields, options: QueryOptions = {}): ProviderEvent {
+export function providerEvent (fields: ProviderEventFields, options: ProgressOptions = {}): ProviderEvent {
   const event: ProviderEvent = {
     ...fields,
     name: 'PROVIDER',
@@ -103,7 +103,7 @@ export interface ValueEventFields {
   value: Uint8Array
 }
 
-export function valueEvent (fields: ValueEventFields, options: QueryOptions = {}): ValueEvent {
+export function valueEvent (fields: ValueEventFields, options: ProgressOptions = {}): ValueEvent {
   const event: ValueEvent = {
     ...fields,
     name: 'VALUE',
@@ -119,7 +119,7 @@ export interface PeerEventFields {
   peer: PeerId
 }
 
-export function addPeerEvent (fields: PeerEventFields, options: QueryOptions = {}): AddPeerEvent {
+export function addPeerEvent (fields: PeerEventFields, options: ProgressOptions = {}): AddPeerEvent {
   const event: AddPeerEvent = {
     ...fields,
     name: 'ADD_PEER',
@@ -135,7 +135,7 @@ export interface DialPeerEventFields {
   peer: PeerId
 }
 
-export function dialPeerEvent (fields: DialPeerEventFields, options: QueryOptions = {}): DialPeerEvent {
+export function dialPeerEvent (fields: DialPeerEventFields, options: ProgressOptions = {}): DialPeerEvent {
   const event: DialPeerEvent = {
     ...fields,
     name: 'DIAL_PEER',

package/src/query/manager.ts

@@ -9,9 +9,9 @@ import {
 import { convertBuffer } from '../utils.js'
 import { queryPath } from './query-path.js'
 import type { QueryFunc } from './types.js'
-import type { QueryEvent, QueryOptions as RootQueryOptions } from '../index.js'
+import type { QueryEvent } from '../index.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { ComponentLogger, Metric, Metrics, PeerId, Startable } from '@libp2p/interface'
+import type { ComponentLogger, Metric, Metrics, PeerId, RoutingOptions, Startable } from '@libp2p/interface'
 import type { DeferredPromise } from 'p-defer'
 
 export interface CleanUpEvents {
@@ -19,7 +19,7 @@ export interface CleanUpEvents {
 }
 
 export interface QueryManagerInit {
-  lan?: boolean
+  logPrefix: string
   disjointPaths?: number
   alpha?: number
   initialQuerySelfHasRun: DeferredPromise<void>
@@ -32,8 +32,12 @@ export interface QueryManagerComponents {
   logger: ComponentLogger
 }
 
-export interface QueryOptions extends RootQueryOptions {
+export interface QueryOptions extends RoutingOptions {
+  /**
+   * A timeout for subqueries executed as part of the main query
+   */
   queryFuncTimeout?: number
+
   isSelfQuery?: boolean
 }
 
@@ -41,7 +45,6 @@ export interface QueryOptions extends RootQueryOptions {
  * Keeps track of all running queries
  */
 export class QueryManager implements Startable {
-  private readonly lan: boolean
   public disjointPaths: number
   private readonly alpha: number
   private readonly shutDownController: AbortController
@@ -51,18 +54,19 @@ export class QueryManager implements Startable {
   private readonly peerId: PeerId
   private readonly routingTable: RoutingTable
   private initialQuerySelfHasRun?: DeferredPromise<void>
+  private readonly logPrefix: string
   private readonly metrics?: {
     runningQueries: Metric
     queryTime: Metric
   }
 
   constructor (components: QueryManagerComponents, init: QueryManagerInit) {
-    const { lan = false, disjointPaths = K, alpha = ALPHA } = init
+    const { disjointPaths = K, alpha = ALPHA, logPrefix } = init
 
+    this.logPrefix = logPrefix
     this.disjointPaths = disjointPaths ?? K
     this.running = false
     this.alpha = alpha ?? ALPHA
-    this.lan = lan
     this.queries = 0
     this.initialQuerySelfHasRun = init.initialQuerySelfHasRun
     this.routingTable = init.routingTable
@@ -71,8 +75,8 @@ export class QueryManager implements Startable {
 
     if (components.metrics != null) {
       this.metrics = {
-        runningQueries: components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_running_queries`),
-        queryTime: components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_query_time_seconds`)
+        runningQueries: components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_running_queries`),
+        queryTime: components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_query_time_seconds`)
       }
     }
 
@@ -129,7 +133,7 @@ export class QueryManager implements Startable {
     // so make sure we don't make a lot of noise in the logs
     setMaxListeners(Infinity, signal)
 
-    const log = this.logger.forComponent(`libp2p:kad-dht:${this.lan ? 'lan' : 'wan'}:query:` + uint8ArrayToString(key, 'base58btc'))
+    const log = this.logger.forComponent(`${this.logPrefix}:query:` + uint8ArrayToString(key, 'base58btc'))
 
     // query a subset of peers up to `kBucketSize / 2` in length
     const startTime = Date.now()

package/src/query/query-path.ts

@@ -6,14 +6,14 @@ import { convertPeerId, convertBuffer } from '../utils.js'
 import { queryErrorEvent } from './events.js'
 import { queueToGenerator } from './utils.js'
 import type { CleanUpEvents } from './manager.js'
-import type { QueryEvent, QueryOptions } from '../index.js'
+import type { QueryEvent } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
-import type { Logger, TypedEventTarget, PeerId } from '@libp2p/interface'
+import type { Logger, TypedEventTarget, PeerId, RoutingOptions } from '@libp2p/interface'
 import type { PeerSet } from '@libp2p/peer-collections'
 
 const MAX_XOR = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
 
-export interface QueryPathOptions extends QueryOptions {
+export interface QueryPathOptions extends RoutingOptions {
   /**
    * What are we trying to find
    */

package/src/query-self.ts

@@ -12,7 +12,7 @@ import type { ComponentLogger, Logger, PeerId, Startable } from '@libp2p/interfa
 import type { DeferredPromise } from 'p-defer'
 
 export interface QuerySelfInit {
-  lan: boolean
+  logPrefix: string
   peerRouting: PeerRouting
   routingTable: RoutingTable
   count?: number
@@ -46,10 +46,10 @@ export class QuerySelf implements Startable {
   private querySelfPromise?: DeferredPromise<void>
 
   constructor (components: QuerySelfComponents, init: QuerySelfInit) {
-    const { peerRouting, lan, count, interval, queryTimeout, routingTable } = init
+    const { peerRouting, logPrefix, count, interval, queryTimeout, routingTable } = init
 
     this.peerId = components.peerId
-    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:query-self`)
+    this.log = components.logger.forComponent(`${logPrefix}:query-self`)
     this.started = false
     this.peerRouting = peerRouting
     this.routingTable = routingTable

package/src/routing-table/index.ts

@@ -1,9 +1,11 @@
-import { TypedEventEmitter } from '@libp2p/interface'
+import { CodeError, TypedEventEmitter } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
-import Queue from 'p-queue'
+import { PeerJobQueue } from '@libp2p/utils/peer-job-queue'
+import { pbStream } from 'it-protobuf-stream'
+import { Message, MessageType } from '../message/dht.js'
 import * as utils from '../utils.js'
 import { KBucket, type PingEventDetails } from './k-bucket.js'
-import type { ComponentLogger, Logger, Metric, Metrics, PeerId, PeerStore, Startable } from '@libp2p/interface'
+import type { ComponentLogger, Logger, Metric, Metrics, PeerId, PeerStore, Startable, Stream } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 
 export const KAD_CLOSE_TAG_NAME = 'kad-close'
@@ -13,7 +15,7 @@ export const PING_TIMEOUT = 10000
 export const PING_CONCURRENCY = 10
 
 export interface RoutingTableInit {
-  lan: boolean
+  logPrefix: string
   protocol: string
   kBucketSize?: number
   pingTimeout?: number
@@ -42,18 +44,17 @@ export interface RoutingTableEvents {
 export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implements Startable {
   public kBucketSize: number
   public kb?: KBucket
-  public pingQueue: Queue
+  public pingQueue: PeerJobQueue
 
   private readonly log: Logger
   private readonly components: RoutingTableComponents
-  private readonly lan: boolean
   private readonly pingTimeout: number
   private readonly pingConcurrency: number
   private running: boolean
   private readonly protocol: string
   private readonly tagName: string
   private readonly tagValue: number
-  private metrics?: {
+  private readonly metrics?: {
     routingTableSize: Metric
     pingQueueSize: Metric
     pingRunning: Metric
@@ -62,14 +63,13 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   constructor (components: RoutingTableComponents, init: RoutingTableInit) {
     super()
 
-    const { kBucketSize, pingTimeout, lan, pingConcurrency, protocol, tagName, tagValue } = init
+    const { kBucketSize, pingTimeout, logPrefix, pingConcurrency, protocol, tagName, tagValue } = init
 
     this.components = components
-    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table`)
+    this.log = components.logger.forComponent(`${logPrefix}:routing-table`)
     this.kBucketSize = kBucketSize ?? KBUCKET_SIZE
     this.pingTimeout = pingTimeout ?? PING_TIMEOUT
     this.pingConcurrency = pingConcurrency ?? PING_CONCURRENCY
-    this.lan = lan
     this.running = false
     this.protocol = protocol
     this.tagName = tagName ?? KAD_CLOSE_TAG_NAME
@@ -80,11 +80,20 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
       this.metrics?.pingRunning.update(this.pingQueue.pending)
     }
 
-    this.pingQueue = new Queue({ concurrency: this.pingConcurrency })
+    this.pingQueue = new PeerJobQueue({ concurrency: this.pingConcurrency })
     this.pingQueue.addListener('add', updatePingQueueSizeMetric)
     this.pingQueue.addListener('next', updatePingQueueSizeMetric)
+    this.pingQueue.addListener('error', err => {
+      this.log.error('error pinging peer', err)
+    })
 
-    this._onPing = this._onPing.bind(this)
+    if (this.components.metrics != null) {
+      this.metrics = {
+        routingTableSize: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_routing_table_size`),
+        pingQueueSize: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_ping_queue_size`),
+        pingRunning: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_ping_running`)
+      }
+    }
   }
 
   isStarted (): boolean {
@@ -94,14 +103,6 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   async start (): Promise<void> {
     this.running = true
 
-    if (this.components.metrics != null) {
-      this.metrics = {
-        routingTableSize: this.components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_routing_table_size`),
-        pingQueueSize: this.components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_ping_queue_size`),
-        pingRunning: this.components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_ping_running`)
-      }
-    }
-
     const kBuck = new KBucket({
       localNodeId: await utils.convertPeerId(this.components.peerId),
       numberOfNodesPerKBucket: this.kBucketSize,
@@ -110,7 +111,11 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.kb = kBuck
 
     // test whether to evict peers
-    kBuck.addEventListener('ping', this._onPing)
+    kBuck.addEventListener('ping', (evt) => {
+      this._onPing(evt).catch(err => {
+        this.log.error('could not process k-bucket ping event', err)
+      })
+    })
 
     // tag kad-close peers
     this._tagPeers(kBuck)
@@ -186,60 +191,77 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
    * `oldContacts` will not be empty and is the list of contacts that
    * have not been contacted for the longest.
    */
-  _onPing (evt: CustomEvent<PingEventDetails>): void {
+  async _onPing (evt: CustomEvent<PingEventDetails>): Promise<void> {
+    if (!this.running) {
+      return
+    }
+
     const {
       oldContacts,
       newContact
     } = evt.detail
 
-    // add to a queue so multiple ping requests do not overlap and we don't
-    // flood the network with ping requests if lots of newContact requests
-    // are received
-    this.pingQueue.add(async () => {
-      if (!this.running) {
-        return
-      }
+    const results = await Promise.all(
+      oldContacts.map(async oldContact => {
+        // if a previous ping wants us to ping this contact, re-use the result
+        if (this.pingQueue.hasJob(oldContact.peer)) {
+          return this.pingQueue.joinJob(oldContact.peer)
+        }
 
-      let responded = 0
+        return this.pingQueue.add(async () => {
+          let stream: Stream | undefined
 
-      try {
-        await Promise.all(
-          oldContacts.map(async oldContact => {
-            try {
-              const options = {
-                signal: AbortSignal.timeout(this.pingTimeout)
-              }
+          try {
+            const options = {
+              signal: AbortSignal.timeout(this.pingTimeout)
+            }
 
-              this.log('pinging old contact %p', oldContact.peer)
-              const connection = await this.components.connectionManager.openConnection(oldContact.peer, options)
-              const stream = await connection.newStream(this.protocol, options)
-              await stream.close()
-              responded++
-            } catch (err: any) {
-              if (this.running && this.kb != null) {
-                // only evict peers if we are still running, otherwise we evict when dialing is
-                // cancelled due to shutdown in progress
-                this.log.error('could not ping peer %p', oldContact.peer, err)
-                this.log('evicting old contact after ping failed %p', oldContact.peer)
-                this.kb.remove(oldContact.id)
-              }
-            } finally {
-              this.metrics?.routingTableSize.update(this.size)
+            this.log('pinging old contact %p', oldContact.peer)
+            const connection = await this.components.connectionManager.openConnection(oldContact.peer, options)
+            stream = await connection.newStream(this.protocol, options)
+
+            const pb = pbStream(stream)
+            await pb.write({
+              type: MessageType.PING
+            }, Message, options)
+            const response = await pb.read(Message, options)
+
+            await pb.unwrap().close()
+
+            if (response.type !== MessageType.PING) {
+              throw new CodeError(`Incorrect message type received, expected PING got ${response.type}`, 'ERR_BAD_PING_RESPONSE')
             }
-          })
-        )
 
-        if (this.running && responded < oldContacts.length && this.kb != null) {
-          this.log('adding new contact %p', newContact.peer)
-          this.kb.add(newContact)
-        }
-      } catch (err: any) {
-        this.log.error('could not process k-bucket ping event', err)
-      }
-    })
-      .catch(err => {
-        this.log.error('could not process k-bucket ping event', err)
+            return true
+          } catch (err: any) {
+            if (this.running && this.kb != null) {
+              // only evict peers if we are still running, otherwise we evict
+              // when dialing is cancelled due to shutdown in progress
+              this.log.error('could not ping peer %p', oldContact.peer, err)
+              this.log('evicting old contact after ping failed %p', oldContact.peer)
+              this.kb.remove(oldContact.id)
+            }
+
+            stream?.abort(err)
+
+            return false
+          } finally {
+            this.metrics?.routingTableSize.update(this.size)
+          }
+        }, {
+          peerId: oldContact.peer
+        })
       })
+    )
+
+    const responded = results
+      .filter(res => res)
+      .length
+
+    if (this.running && responded < oldContacts.length && this.kb != null) {
+      this.log('adding new contact %p', newContact.peer)
+      this.kb.add(newContact)
+    }
   }
 
   // -- Public Interface