@libp2p/kad-dht 9.1.4 → 9.2.0

package/src/peer-routing/index.ts

@@ -13,7 +13,7 @@ import {
   valueEvent
 } from '../query/events.js'
 import * as utils from '../utils.js'
-import type { KadDHTComponents, DHTRecord, DialingPeerEvent, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
+import type { KadDHTComponents, DHTRecord, DialPeerEvent, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
 import type { Network } from '../network.js'
 import type { QueryManager, QueryOptions } from '../query/manager.js'
 import type { QueryFunc } from '../query/types.js'
@@ -122,7 +122,7 @@ export class PeerRouting {
           throw new CodeError('public key missing', 'ERR_PUBLIC_KEY_MISSING')
         }
 
-        yield valueEvent({ from: peer, value: recPeer.publicKey })
+        yield valueEvent({ from: peer, value: recPeer.publicKey }, options)
       }
     }
 
@@ -144,44 +144,19 @@ export class PeerRouting {
       yield finalPeerEvent({
         from: this.components.peerId,
         peer: pi
-      })
+      }, options)
       return
     }
 
-    const key = await utils.convertPeerId(id)
-    const peers = this.routingTable.closestPeers(key)
-
-    // sanity check
-    const match = peers.find((p) => p.equals(id))
-
-    if (match != null) {
-      try {
-        const peer = await this.components.peerStore.get(id)
-
-        this.log('found in peerStore')
-        yield finalPeerEvent({
-          from: this.components.peerId,
-          peer: {
-            id: peer.id,
-            multiaddrs: peer.addresses.map((address) => address.multiaddr),
-            protocols: []
-          }
-        })
-
-        return
-      } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
-          throw err
-        }
-      }
-    }
-
     const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
     const findPeerQuery: QueryFunc = async function * ({ peer, signal }) {
       const request = new Message(MESSAGE_TYPE.FIND_NODE, id.toBytes(), 0)
 
-      for await (const event of self.network.sendRequest(peer, request, { signal })) {
+      for await (const event of self.network.sendRequest(peer, request, {
+        ...options,
+        signal
+      })) {
         yield event
 
         if (event.name === 'PEER_RESPONSE') {
@@ -189,7 +164,7 @@ export class PeerRouting {
 
           // found the peer
           if (match != null) {
-            yield finalPeerEvent({ from: event.from, peer: match })
+            yield finalPeerEvent({ from: event.from, peer: match }, options)
           }
         }
       }
@@ -197,7 +172,7 @@ export class PeerRouting {
 
     let foundPeer = false
 
-    for await (const event of this.queryManager.run(id.toBytes(), peers, findPeerQuery, options)) {
+    for await (const event of this.queryManager.run(id.toBytes(), findPeerQuery, options)) {
       if (event.name === 'FINAL_PEER') {
         foundPeer = true
       }
@@ -206,7 +181,7 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({ from: this.components.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') })
+      yield queryErrorEvent({ from: this.components.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') }, options)
     }
   }
 
@@ -214,7 +189,7 @@ export class PeerRouting {
    * Kademlia 'node lookup' operation on a key, which could be a the
    * bytes from a multihash or a peer ID
    */
-  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<DialingPeerEvent | QueryEvent> {
+  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<DialPeerEvent | QueryEvent> {
     this.log('getClosestPeers to %b', key)
     const id = await utils.convertBuffer(key)
     const tablePeers = this.routingTable.closestPeers(id)
@@ -227,10 +202,13 @@ export class PeerRouting {
       self.log('closerPeersSingle %s from %p', uint8ArrayToString(key, 'base32'), peer)
       const request = new Message(MESSAGE_TYPE.FIND_NODE, key, 0)
 
-      yield * self.network.sendRequest(peer, request, { signal })
+      yield * self.network.sendRequest(peer, request, {
+        ...options,
+        signal
+      })
     }
 
-    for await (const event of this.queryManager.run(key, tablePeers, getCloserPeersQuery, options)) {
+    for await (const event of this.queryManager.run(key, getCloserPeersQuery, options)) {
       yield event
 
       if (event.name === 'PEER_RESPONSE') {
@@ -251,7 +229,7 @@ export class PeerRouting {
             multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr),
             protocols: peer.protocols
           }
-        })
+        }, options)
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
           throw err
@@ -266,7 +244,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<DialingPeerEvent | QueryEvent> {
+  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: AbortOptions = {}): AsyncGenerator<DialPeerEvent | QueryEvent> {
     for await (const event of this._getValueSingle(peer, key, options)) {
       if (event.name === 'PEER_RESPONSE') {
         if (event.record != null) {
@@ -277,7 +255,7 @@ export class PeerRouting {
             const errMsg = 'invalid record received, discarded'
             this.log(errMsg)
 
-            yield queryErrorEvent({ from: event.from, error: new CodeError(errMsg, 'ERR_INVALID_RECORD') })
+            yield queryErrorEvent({ from: event.from, error: new CodeError(errMsg, 'ERR_INVALID_RECORD') }, options)
             continue
           }
         }

package/src/query/events.ts

@@ -1,5 +1,6 @@
+import { CustomEvent } from '@libp2p/interfaces/events'
 import { MESSAGE_TYPE_LOOKUP } from '../message/index.js'
-import type { SendingQueryEvent, PeerResponseEvent, DialingPeerEvent, AddingPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '../index.js'
+import type { SendQueryEvent, PeerResponseEvent, DialPeerEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent, QueryOptions } from '../index.js'
 import type { Message } from '../message/dht.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
@@ -10,14 +11,18 @@ export interface QueryEventFields {
   type: Message.MessageType
 }
 
-export function sendingQueryEvent (fields: QueryEventFields): SendingQueryEvent {
-  return {
+export function sendQueryEvent (fields: QueryEventFields, options: QueryOptions = {}): SendQueryEvent {
+  const event: SendQueryEvent = {
     ...fields,
-    name: 'SENDING_QUERY',
+    name: 'SEND_QUERY',
     type: 0,
     messageName: fields.type,
     messageType: MESSAGE_TYPE_LOOKUP.indexOf(fields.type.toString())
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:send-query', { detail: event }))
+
+  return event
 }
 
 export interface PeerResponseEventField {
@@ -28,8 +33,8 @@ export interface PeerResponseEventField {
   record?: Libp2pRecord
 }
 
-export function peerResponseEvent (fields: PeerResponseEventField): PeerResponseEvent {
-  return {
+export function peerResponseEvent (fields: PeerResponseEventField, options: QueryOptions = {}): PeerResponseEvent {
+  const event: PeerResponseEvent = {
     ...fields,
     name: 'PEER_RESPONSE',
     type: 1,
@@ -37,6 +42,10 @@ export function peerResponseEvent (fields: PeerResponseEventField): PeerResponse
     closer: (fields.closer != null) ? fields.closer : [],
     providers: (fields.providers != null) ? fields.providers : []
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:peer-response', { detail: event }))
+
+  return event
 }
 
 export interface FinalPeerEventFields {
@@ -44,12 +53,16 @@ export interface FinalPeerEventFields {
   peer: PeerInfo
 }
 
-export function finalPeerEvent (fields: FinalPeerEventFields): FinalPeerEvent {
-  return {
+export function finalPeerEvent (fields: FinalPeerEventFields, options: QueryOptions = {}): FinalPeerEvent {
+  const event: FinalPeerEvent = {
     ...fields,
     name: 'FINAL_PEER',
     type: 2
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:final-peer', { detail: event }))
+
+  return event
 }
 
 export interface ErrorEventFields {
@@ -57,12 +70,16 @@ export interface ErrorEventFields {
   error: Error
 }
 
-export function queryErrorEvent (fields: ErrorEventFields): QueryErrorEvent {
-  return {
+export function queryErrorEvent (fields: ErrorEventFields, options: QueryOptions = {}): QueryErrorEvent {
+  const event: QueryErrorEvent = {
     ...fields,
     name: 'QUERY_ERROR',
     type: 3
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:query-error', { detail: event }))
+
+  return event
 }
 
 export interface ProviderEventFields {
@@ -70,12 +87,16 @@ export interface ProviderEventFields {
   providers: PeerInfo[]
 }
 
-export function providerEvent (fields: ProviderEventFields): ProviderEvent {
-  return {
+export function providerEvent (fields: ProviderEventFields, options: QueryOptions = {}): ProviderEvent {
+  const event: ProviderEvent = {
     ...fields,
     name: 'PROVIDER',
     type: 4
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:provider', { detail: event }))
+
+  return event
 }
 
 export interface ValueEventFields {
@@ -83,34 +104,46 @@ export interface ValueEventFields {
   value: Uint8Array
 }
 
-export function valueEvent (fields: ValueEventFields): ValueEvent {
-  return {
+export function valueEvent (fields: ValueEventFields, options: QueryOptions = {}): ValueEvent {
+  const event: ValueEvent = {
     ...fields,
     name: 'VALUE',
     type: 5
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:value', { detail: event }))
+
+  return event
 }
 
 export interface PeerEventFields {
   peer: PeerId
 }
 
-export function addingPeerEvent (fields: PeerEventFields): AddingPeerEvent {
-  return {
+export function addPeerEvent (fields: PeerEventFields, options: QueryOptions = {}): AddPeerEvent {
+  const event: AddPeerEvent = {
     ...fields,
-    name: 'ADDING_PEER',
+    name: 'ADD_PEER',
     type: 6
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:add-peer', { detail: event }))
+
+  return event
 }
 
-export interface DialingPeerEventFields {
+export interface DialPeerEventFields {
   peer: PeerId
 }
 
-export function dialingPeerEvent (fields: DialingPeerEventFields): DialingPeerEvent {
-  return {
+export function dialPeerEvent (fields: DialPeerEventFields, options: QueryOptions = {}): DialPeerEvent {
+  const event: DialPeerEvent = {
     ...fields,
-    name: 'DIALING_PEER',
+    name: 'DIAL_PEER',
     type: 7
   }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:dial-peer', { detail: event }))
+
+  return event
 }

package/src/query/manager.ts

@@ -9,12 +9,13 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import {
   ALPHA, K, DEFAULT_QUERY_TIMEOUT
 } from '../constants.js'
+import { convertBuffer } from '../utils.js'
 import { queryPath } from './query-path.js'
 import type { QueryFunc } from './types.js'
-import type { QueryEvent } from '../index.js'
+import type { QueryEvent, QueryOptions as RootQueryOptions } from '../index.js'
+import type { RoutingTable } from '../routing-table/index.js'
 import type { Metric, Metrics } from '@libp2p/interface-metrics'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { DeferredPromise } from 'p-defer'
 
@@ -27,6 +28,7 @@ export interface QueryManagerInit {
   disjointPaths?: number
   alpha?: number
   initialQuerySelfHasRun: DeferredPromise<void>
+  routingTable: RoutingTable
 }
 
 export interface QueryManagerComponents {
@@ -34,7 +36,7 @@ export interface QueryManagerComponents {
   metrics?: Metrics
 }
 
-export interface QueryOptions extends AbortOptions {
+export interface QueryOptions extends RootQueryOptions {
   queryFuncTimeout?: number
   isSelfQuery?: boolean
 }
@@ -55,6 +57,7 @@ export class QueryManager implements Startable {
     queryTime: Metric
   }
 
+  private readonly routingTable: RoutingTable
   private initialQuerySelfHasRun?: DeferredPromise<void>
 
   constructor (components: QueryManagerComponents, init: QueryManagerInit) {
@@ -67,6 +70,7 @@ export class QueryManager implements Startable {
     this.lan = lan
     this.queries = 0
     this.initialQuerySelfHasRun = init.initialQuerySelfHasRun
+    this.routingTable = init.routingTable
 
     // allow us to stop queries on shut down
     this.shutDownController = new AbortController()
@@ -105,7 +109,7 @@ export class QueryManager implements Startable {
     this.shutDownController.abort()
   }
 
-  async * run (key: Uint8Array, peers: PeerId[], queryFunc: QueryFunc, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
+  async * run (key: Uint8Array, queryFunc: QueryFunc, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       throw new Error('QueryManager not started')
     }
@@ -138,7 +142,6 @@ export class QueryManager implements Startable {
     const log = logger(`libp2p:kad-dht:${this.lan ? 'lan' : 'wan'}:query:` + uint8ArrayToString(key, 'base58btc'))
 
     // query a subset of peers up to `kBucketSize / 2` in length
-    const peersToQuery = peers.slice(0, Math.min(this.disjointPaths, peers.length))
     const startTime = Date.now()
     const cleanUp = new EventEmitter<CleanUpEvents>()
 
@@ -162,6 +165,10 @@ export class QueryManager implements Startable {
       this.queries++
       this.metrics?.runningQueries.update(this.queries)
 
+      const id = await convertBuffer(key)
+      const peers = this.routingTable.closestPeers(id)
+      const peersToQuery = peers.slice(0, Math.min(this.disjointPaths, peers.length))
+
       if (peers.length === 0) {
         log.error('Running query with no peers')
         return
@@ -184,7 +191,8 @@ export class QueryManager implements Startable {
           cleanUp,
           queryFuncTimeout: options.queryFuncTimeout,
           log,
-          peersSeen
+          peersSeen,
+          onProgress: options.onProgress
         })
       })
 

package/src/query/query-path.ts

@@ -7,7 +7,7 @@ import { xor } from 'uint8arrays/xor'
 import { convertPeerId, convertBuffer } from '../utils.js'
 import { queryErrorEvent } from './events.js'
 import type { CleanUpEvents } from './manager.js'
-import type { QueryEvent } from '../index.js'
+import type { QueryEvent, QueryOptions } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { EventEmitter } from '@libp2p/interfaces/events'
@@ -16,7 +16,7 @@ import type { PeerSet } from '@libp2p/peer-collections'
 
 const MAX_XOR = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
 
-export interface QueryPathOptions {
+export interface QueryPathOptions extends QueryOptions {
   /**
    * What are we trying to find
    */
@@ -160,7 +160,7 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
           return queryErrorEvent({
             from: peer,
             error: err
-          })
+          }, options)
         }
       } finally {
         compoundSignal.clear()

package/src/routing-table/index.ts

@@ -244,7 +244,7 @@ export class RoutingTable implements Startable {
                 // 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)
+                this.log('evicting old contact after ping failed %p', oldContact.peer)
                 this.kb.remove(oldContact.id)
               }
             } finally {