@libp2p/kad-dht 15.0.2-32627c876 → 15.0.2-3df5bf2da

package/src/network.ts

@@ -7,9 +7,10 @@ import { fromPbPeerInfo } from './message/utils.js'
 import {
   sendQueryEvent,
   peerResponseEvent,
-  queryErrorEvent
+  queryErrorEvent,
+  dialPeerEvent
 } from './query/events.js'
-import type { KadDHTComponents, QueryEvent } from './index.js'
+import type { DisjointPath, KadDHTComponents, QueryEvent } from './index.js'
 import type { AbortOptions, Logger, Stream, PeerId, PeerInfo, Startable, RoutingOptions, CounterGroup } from '@libp2p/interface'
 
 export interface NetworkInit {
@@ -29,7 +30,7 @@ export interface SendMessageOptions extends RoutingOptions {
    * this option is which index within `k` this message is for, and it
    * allows observers to collate events together on a per-path basis
    */
-  path: number
+  path: DisjointPath
 }
 
 /**
@@ -161,9 +162,6 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       throw new InvalidParametersError('Message type was missing')
     }
 
-    this.log('sending %s to %p', msg.type, to)
-    yield sendQueryEvent({ to, type, path: options.path }, options)
-
     let stream: Stream | undefined
     const signal = this.timeout.getTimeoutSignal(options)
 
@@ -175,8 +173,15 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
     try {
       this.metrics.operations?.increment({ [type]: true })
 
+      this.log('dialling %p', to)
+      yield dialPeerEvent({ peer: to, path: options.path }, options)
+
       const connection = await this.components.connectionManager.openConnection(to, options)
       stream = await connection.newStream(this.protocol, options)
+
+      this.log('sending %s to %p', msg.type, to)
+      yield sendQueryEvent({ to, type, path: options.path }, options)
+
       const response = await this._writeReadMessage(stream, msg, options)
 
       stream.close(options)
@@ -224,9 +229,6 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       throw new InvalidParametersError('Message type was missing')
     }
 
-    this.log('sending %s to %p', msg.type, to)
-    yield sendQueryEvent({ to, type, path: options.path }, options)
-
     let stream: Stream | undefined
     const signal = this.timeout.getTimeoutSignal(options)
 
@@ -238,9 +240,15 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
     try {
       this.metrics.operations?.increment({ [type]: true })
 
+      this.log('dialling %p', to)
+      yield dialPeerEvent({ peer: to, path: options.path }, options)
+
       const connection = await this.components.connectionManager.openConnection(to, options)
       stream = await connection.newStream(this.protocol, options)
 
+      this.log('sending %s to %p', msg.type, to)
+      yield sendQueryEvent({ to, type, path: options.path }, options)
+
       await this._writeMessage(stream, msg, options)
 
       stream.close(options)
@@ -269,9 +277,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   }
 
   /**
-   * Write a message and read its response.
-   * If no response is received after the specified timeout
-   * this will error out.
+   * Write a message and read a response
    */
   async _writeReadMessage (stream: Stream, msg: Partial<Message>, options: AbortOptions): Promise<Message> {
     const pb = pbStream(stream)

package/src/peer-distance-list.ts

@@ -1,12 +1,13 @@
 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'
 
 interface PeerDistance {
   peer: PeerInfo
   distance: Uint8Array
-  path: number
+  path: DisjointPath
 }
 
 /**
@@ -48,7 +49,7 @@ export class PeerDistanceList {
   /**
    * Add a peerId to the list.
    */
-  async add (peer: PeerInfo, path: number = -1): Promise<void> {
+  async add (peer: PeerInfo, path: DisjointPath = { index: -1, queued: 0, running: 0, total: 0 }): Promise<void> {
     const dhtKey = await convertPeerId(peer.id)
 
     this.addWithKadId(peer, dhtKey, path)
@@ -57,7 +58,7 @@ export class PeerDistanceList {
   /**
    * Add a peerId to the list.
    */
-  addWithKadId (peer: PeerInfo, kadId: Uint8Array, path: number = -1): void {
+  addWithKadId (peer: PeerInfo, kadId: Uint8Array, path: DisjointPath = { index: -1, queued: 0, running: 0, total: 0 }): void {
     if (this.peerDistances.find(pd => pd.peer.id.equals(peer.id)) != null) {
       return
     }
@@ -68,6 +69,15 @@ export class PeerDistanceList {
       path
     }
 
+    if (this.peerDistances.length === this.capacity) {
+      const lastPeer = this.peerDistances[this.peerDistances.length - 1]
+
+      // only add if it's closer than our furthest peer
+      if (lastPeer != null && uint8ArrayXorCompare(el.distance, lastPeer.distance) !== -1) {
+        return
+      }
+    }
+
     let added = false
 
     for (let j = 0; j < this.peerDistances.length; j++) {

package/src/peer-routing/index.ts

@@ -3,7 +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 { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
 import { QueryError, InvalidRecordError } from '../errors.js'
@@ -23,12 +22,14 @@ 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 { ComponentLogger, Logger, Metrics, PeerId, PeerInfo, PeerStore, RoutingOptions } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
 
 export interface PeerRoutingComponents {
   peerId: PeerId
   peerStore: PeerStore
   logger: ComponentLogger
   metrics?: Metrics
+  connectionManager: ConnectionManager
 }
 
 export interface PeerRoutingInit {
@@ -45,16 +46,14 @@ export class PeerRouting {
   private readonly network: Network
   private readonly validators: Validators
   private readonly queryManager: QueryManager
-  private readonly peerStore: PeerStore
-  private readonly peerId: PeerId
+  private readonly components: PeerRoutingComponents
 
   constructor (components: PeerRoutingComponents, init: PeerRoutingInit) {
     this.routingTable = init.routingTable
     this.network = init.network
     this.validators = init.validators
     this.queryManager = init.queryManager
-    this.peerStore = components.peerStore
-    this.peerId = components.peerId
+    this.components = components
     this.log = components.logger.forComponent(`${init.logPrefix}:peer-routing`)
 
     this.findPeer = components.metrics?.traceFunction('libp2p.kadDHT.findPeer', this.findPeer.bind(this), {
@@ -77,7 +76,7 @@ export class PeerRouting {
       this.log('findPeerLocal found %p in routing table', peer)
 
       try {
-        peerData = await this.peerStore.get(p)
+        peerData = await this.components.peerStore.get(p)
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err
@@ -87,7 +86,7 @@ export class PeerRouting {
 
     if (peerData == null) {
       try {
-        peerData = await this.peerStore.get(peer)
+        peerData = await this.components.peerStore.get(peer)
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err
@@ -124,10 +123,16 @@ export class PeerRouting {
    */
   async * getPublicKeyFromNode (peer: PeerId, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
     const pkKey = keyForPublicKey(peer)
+    const path = {
+      index: -1,
+      queued: 0,
+      running: 0,
+      total: 0
+    }
 
     for await (const event of this._getValueSingle(peer, pkKey, {
       ...options,
-      path: -1
+      path
     })) {
       yield event
 
@@ -146,7 +151,8 @@ export class PeerRouting {
 
         yield valueEvent({
           from: peer,
-          value: event.record.value
+          value: event.record.value,
+          path
         }, options)
       }
     }
@@ -168,9 +174,14 @@ export class PeerRouting {
       if (pi != null) {
         this.log('found local')
         yield finalPeerEvent({
-          from: this.peerId,
+          from: this.components.peerId,
           peer: pi,
-          path: -1
+          path: {
+            index: -1,
+            queued: 0,
+            running: 0,
+            total: 0
+          }
         }, options)
         return
       }
@@ -187,7 +198,7 @@ export class PeerRouting {
           key: id.toMultihash().bytes
         }
 
-        for await (const event of self.network.sendRequest(peer, request, {
+        for await (const event of self.network.sendRequest(peer.id, request, {
           ...options,
           signal,
           path
@@ -219,58 +230,64 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({
-        from: this.peerId,
-        error: new NotFoundError('Not found')
-      }, options)
+      throw new NotFoundError('Not found')
     }
   }
 
   /**
-   * Kademlia 'FIND_NODE' operation on a key, which could be the bytes from
-   * a multihash or a peer ID
+   * Kademlia 'FIND_NODE' operation on a key, which could be the bytes from a
+   * multihash or a peer ID
    */
   async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     this.log('getClosestPeers to %b', key)
     const kadId = await convertBuffer(key)
-    const tablePeers = this.routingTable.closestPeers(kadId)
-    const self = this // eslint-disable-line @typescript-eslint/no-this-alias
-
     const peers = new PeerDistanceList(kadId, this.routingTable.kBucketSize)
-    await Promise.all(tablePeers.map(async peer => { await peers.add({ id: peer, multiaddrs: [] }, -1) }))
+    const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
-    const getCloserPeersQuery: QueryFunc = async function * ({ peer, signal, path }) {
-      self.log('closerPeersSingle %s from %p', uint8ArrayToString(key, 'base32'), peer)
+    const getCloserPeersQuery: QueryFunc = async function * ({ peer, path, peerKadId, signal }) {
+      self.log('getClosestPeers asking %p', peer)
       const request: Partial<Message> = {
         type: MessageType.FIND_NODE,
         key
       }
 
-      yield * self.network.sendRequest(peer, request, {
+      yield * self.network.sendRequest(peer.id, request, {
         ...options,
         signal,
         path
       })
-    }
-
-    for await (const event of this.queryManager.run(key, getCloserPeersQuery, options)) {
-      if (event.name === 'PEER_RESPONSE') {
-        await Promise.all(event.closer.map(async peerData => {
-          await peers.add(peerData, event.path)
-        }))
-      }
 
-      yield event
+      // add the peer to the list if we've managed to contact it successfully
+      peers.addWithKadId(peer, peerKadId, path)
     }
 
+    yield * this.queryManager.run(key, getCloserPeersQuery, options)
+
     this.log('found %d peers close to %b', peers.length, key)
 
-    for (const { peer, path } of peers.peers) {
-      yield finalPeerEvent({
-        from: this.peerId,
-        peer,
-        path
-      }, options)
+    for (let { peer, path } of peers.peers) {
+      try {
+        if (peer.multiaddrs.length === 0) {
+          peer = await self.components.peerStore.getInfo(peer.id)
+        }
+
+        if (peer.multiaddrs.length === 0) {
+          continue
+        }
+
+        yield finalPeerEvent({
+          from: this.components.peerId,
+          peer: await self.components.peerStore.getInfo(peer.id),
+          path: {
+            index: path.index,
+            queued: 0,
+            running: 0,
+            total: 0
+          }
+        }, options)
+      } catch {
+        continue
+      }
     }
   }
 
@@ -318,7 +335,8 @@ export class PeerRouting {
   }
 
   /**
-   * Get the nearest peers to the given query, but if closer than self
+   * 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[]> {
     const output: PeerInfo[] = []
@@ -328,7 +346,7 @@ export class PeerRouting {
       const multihash = Digest.decode(key)
       const targetPeerId = peerIdFromMultihash(multihash)
 
-      const peer = await this.peerStore.get(targetPeerId)
+      const peer = await this.components.peerStore.get(targetPeerId)
 
       output.push({
         id: peer.id,
@@ -351,12 +369,7 @@ export class PeerRouting {
       }
 
       try {
-        const peer = await this.peerStore.get(peerId)
-
-        output.push({
-          id: peerId,
-          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
-        })
+        output.push(await this.components.peerStore.getInfo(peerId))
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err

package/src/providers.ts

@@ -41,7 +41,7 @@ export class Providers {
     const release = await this.lock.readLock()
 
     try {
-      this.log('%p provides %s', provider, cid)
+      this.log.trace('%p provides %s', provider, cid)
       await this.writeProviderEntry(cid, provider)
     } finally {
       release()
@@ -56,7 +56,7 @@ export class Providers {
 
     try {
       const key = toProviderKey(this.datastorePrefix, cid, provider)
-      this.log('%p no longer provides %s', provider, cid)
+      this.log.trace('%p no longer provides %s', provider, cid)
       await this.datastore.delete(key)
     } finally {
       release()
@@ -70,9 +70,9 @@ export class Providers {
     const release = await this.lock.readLock()
 
     try {
-      this.log('get providers for %c', cid)
+      this.log.trace('get providers for %c', cid)
       const provs = await this.loadProviders(cid, options)
-      this.log('got %d providers for %c', provs.size, cid)
+      this.log.trace('got %d providers for %c', provs.size, cid)
 
       return [...provs.keys()]
     } finally {

package/src/query/events.ts

@@ -1,4 +1,4 @@
-import type { MessageType, SendQueryEvent, PeerResponseEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '../index.js'
+import type { MessageType, SendQueryEvent, PeerResponseEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent, DisjointPath, PathEndedEvent, DialPeerEvent } from '../index.js'
 import type { PeerId, PeerInfo } from '@libp2p/interface'
 import type { Libp2pRecord } from '@libp2p/record'
 import type { ProgressOptions } from 'progress-events'
@@ -6,7 +6,7 @@ import type { ProgressOptions } from 'progress-events'
 export interface QueryEventFields {
   to: PeerId
   type: MessageType
-  path: number
+  path: DisjointPath
 }
 
 export function sendQueryEvent (fields: QueryEventFields, options: ProgressOptions = {}): SendQueryEvent {
@@ -26,7 +26,7 @@ export function sendQueryEvent (fields: QueryEventFields, options: ProgressOptio
 export interface PeerResponseEventFields {
   from: PeerId
   messageType: MessageType
-  path: number
+  path: DisjointPath
   closer?: PeerInfo[]
   providers?: PeerInfo[]
   record?: Libp2pRecord
@@ -50,7 +50,7 @@ export function peerResponseEvent (fields: PeerResponseEventFields, options: Pro
 export interface FinalPeerEventFields {
   from: PeerId
   peer: PeerInfo
-  path: number
+  path: DisjointPath
 }
 
 export function finalPeerEvent (fields: FinalPeerEventFields, options: ProgressOptions = {}): FinalPeerEvent {
@@ -68,7 +68,7 @@ export function finalPeerEvent (fields: FinalPeerEventFields, options: ProgressO
 export interface ErrorEventFields {
   from: PeerId
   error: Error
-  path?: number
+  path: DisjointPath
 }
 
 export function queryErrorEvent (fields: ErrorEventFields, options: ProgressOptions = {}): QueryErrorEvent {
@@ -86,6 +86,7 @@ export function queryErrorEvent (fields: ErrorEventFields, options: ProgressOpti
 export interface ProviderEventFields {
   from: PeerId
   providers: PeerInfo[]
+  path: DisjointPath
 }
 
 export function providerEvent (fields: ProviderEventFields, options: ProgressOptions = {}): ProviderEvent {
@@ -103,6 +104,7 @@ export function providerEvent (fields: ProviderEventFields, options: ProgressOpt
 export interface ValueEventFields {
   from: PeerId
   value: Uint8Array
+  path: DisjointPath
 }
 
 export function valueEvent (fields: ValueEventFields, options: ProgressOptions = {}): ValueEvent {
@@ -119,7 +121,7 @@ export function valueEvent (fields: ValueEventFields, options: ProgressOptions =
 
 export interface AddPeerEventFields {
   peer: PeerId
-  path: number
+  path: DisjointPath
 }
 
 export function addPeerEvent (fields: AddPeerEventFields, options: ProgressOptions = {}): AddPeerEvent {
@@ -133,3 +135,36 @@ export function addPeerEvent (fields: AddPeerEventFields, options: ProgressOptio
 
   return event
 }
+
+export interface DialPeerEventFields {
+  peer: PeerId
+  path: DisjointPath
+}
+
+export function dialPeerEvent (fields: DialPeerEventFields, options: ProgressOptions = {}): DialPeerEvent {
+  const event: DialPeerEvent = {
+    ...fields,
+    name: 'DIAL_PEER',
+    type: 7
+  }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:dial-peer', { detail: event }))
+
+  return event
+}
+
+export interface PathEndedEventFields {
+  path: DisjointPath
+}
+
+export function pathEndedEvent (fields: PathEndedEventFields, options: ProgressOptions = {}): PathEndedEvent {
+  const event: PathEndedEvent = {
+    ...fields,
+    name: 'PATH_ENDED',
+    type: 8
+  }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:path-ended', { detail: event }))
+
+  return event
+}

package/src/query/manager.ts

@@ -1,5 +1,6 @@
+/* eslint-disable complexity */
 import { setMaxListeners } from '@libp2p/interface'
-import { PeerSet } from '@libp2p/peer-collections'
+import { createScalableCuckooFilter } from '@libp2p/utils/filters'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
 import { pEvent } from 'p-event'
@@ -39,11 +40,6 @@ export interface QueryManagerComponents {
 }
 
 export interface QueryOptions extends RoutingOptions {
-  /**
-   * A timeout for subqueries executed as part of the main query
-   */
-  queryFuncTimeout?: number
-
   isSelfQuery?: boolean
 }
 
@@ -161,7 +157,7 @@ export class QueryManager implements Startable {
       }
 
       if (options.isSelfQuery !== true && this.initialQuerySelfHasRun != null) {
-        log('waiting for initial query-self query before continuing')
+        log('waiting for initial self query before continuing')
 
         await raceSignal(this.initialQuerySelfHasRun.promise, signal)
 
@@ -171,8 +167,22 @@ export class QueryManager implements Startable {
       log('query:start')
 
       const id = await convertBuffer(key)
-      const peers = this.routingTable.closestPeers(id)
-      const peersToQuery = peers.slice(0, Math.min(this.disjointPaths, peers.length))
+      const peers = this.routingTable.closestPeers(id, this.routingTable.kBucketSize)
+
+      // split peers into d buckets evenly(ish)
+      const peersToQuery = peers.sort(() => {
+        if (Math.random() > 0.5) {
+          return 1
+        }
+
+        return -1
+      })
+        .reduce((acc: PeerId[][], curr, index) => {
+          acc[index % this.disjointPaths].push(curr)
+
+          return acc
+        }, new Array(this.disjointPaths).fill(0).map(() => []))
+        .filter(peers => peers.length > 0)
 
       if (peers.length === 0) {
         log.error('running query with no peers')
@@ -180,21 +190,20 @@ export class QueryManager implements Startable {
       }
 
       // make sure we don't get trapped in a loop
-      const peersSeen = new PeerSet()
+      const peersSeen = createScalableCuckooFilter(1024)
 
       // Create query paths from the starting peers
       const paths = peersToQuery.map((peer, index) => {
         return queryPath({
           ...options,
           key,
-          startingPeer: peer,
+          startingPeers: peer,
           ourPeerId: this.peerId,
           signal,
           query: queryFunc,
           path: index,
           numPaths: peersToQuery.length,
           alpha: this.alpha,
-          queryFuncTimeout: options.queryFuncTimeout,
           log,
           peersSeen,
           onProgress: options.onProgress,
@@ -223,8 +232,8 @@ export class QueryManager implements Startable {
           }
         }
 
-        yield event
         signal.throwIfAborted()
+        yield event
       }
 
       queryFinished = true
@@ -241,7 +250,7 @@ export class QueryManager implements Startable {
 
       signal.clear()
 
-      log('query:done')
+      log('query finished')
     }
   }
 }