@libp2p/kad-dht 7.0.0 → 7.0.2

package/src/query/query-path.ts

@@ -2,7 +2,7 @@ import Queue from 'p-queue'
 import { xor } from 'uint8arrays/xor'
 import { toString } from 'uint8arrays/to-string'
 import defer from 'p-defer'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { convertPeerId, convertBuffer } from '../utils.js'
 import { TimeoutController } from 'timeout-abort-controller'
 import { anySignal } from 'any-signal'
@@ -83,7 +83,7 @@ export interface QueryPathOptions {
  * Walks a path through the DHT, calling the passed query function for
  * every peer encountered that we have not seen before
  */
-export async function * queryPath (options: QueryPathOptions) {
+export async function * queryPath (options: QueryPathOptions): AsyncGenerator<QueryEvent, void, undefined> {
   const { key, startingPeer, ourPeerId, signal, query, alpha, pathIndex, numPaths, cleanUp, queryFuncTimeout, log, peersSeen } = options
   // Only ALPHA node/value lookups are allowed at any given time for each process
   // https://github.com/libp2p/specs/tree/master/kad-dht#alpha-concurrency-parameter-%CE%B1
@@ -98,7 +98,7 @@ export async function * queryPath (options: QueryPathOptions) {
    * Adds the passed peer to the query queue if it's not us and no
    * other path has passed through this peer
    */
-  function queryPeer (peer: PeerId, peerKadId: Uint8Array) {
+  function queryPeer (peer: PeerId, peerKadId: Uint8Array): void {
     if (peer == null) {
       return
     }
@@ -196,12 +196,12 @@ export async function * queryPath (options: QueryPathOptions) {
   yield * toGenerator(queue, signal, cleanUp, log)
 }
 
-async function * toGenerator (queue: Queue, signal: AbortSignal, cleanUp: EventEmitter<CleanUpEvents>, log: Logger) {
+async function * toGenerator (queue: Queue, signal: AbortSignal, cleanUp: EventEmitter<CleanUpEvents>, log: Logger): AsyncGenerator<QueryEvent, void, undefined> {
   let deferred = defer()
   let running = true
   const results: QueryEvent[] = []
 
-  const cleanup = () => {
+  const cleanup = (): void => {
     if (!running) {
       return
     }
@@ -235,7 +235,7 @@ async function * toGenerator (queue: Queue, signal: AbortSignal, cleanUp: EventE
     cleanup()
 
     if (wasRunning) {
-      deferred.reject(errCode(new Error('Query aborted'), 'ERR_QUERY_ABORTED'))
+      deferred.reject(new CodeError('Query aborted', 'ERR_QUERY_ABORTED'))
     }
   })
 

package/src/query-self.ts

@@ -44,11 +44,11 @@ export class QuerySelf implements Startable {
     this.queryTimeout = queryTimeout ?? QUERY_SELF_TIMEOUT
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
-  async start () {
+  async start (): Promise<void> {
     if (this.running) {
       return
     }
@@ -57,7 +57,7 @@ export class QuerySelf implements Startable {
     this._querySelf()
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     this.running = false
 
     if (this.timeoutId != null) {
@@ -69,7 +69,7 @@ export class QuerySelf implements Startable {
     }
   }
 
-  _querySelf () {
+  _querySelf (): void {
     Promise.resolve().then(async () => {
       const timeoutController = new TimeoutController(this.queryTimeout)
 

package/src/routing-table/index.ts

@@ -51,7 +51,7 @@ export interface KBucketTree {
   add: (peer: KBucketPeer) => void
   get: (key: Uint8Array) => Uint8Array
   count: () => number
-  toIterable: () => Iterable<KBucket>
+  toIterable: () => Iterable<KBucketPeer>
 }
 
 export interface RoutingTableInit {
@@ -109,7 +109,7 @@ export class RoutingTable implements Startable {
     this.tagName = tagName ?? KAD_CLOSE_TAG_NAME
     this.tagValue = tagValue ?? KAD_CLOSE_TAG_VALUE
 
-    const updatePingQueueSizeMetric = () => {
+    const updatePingQueueSizeMetric = (): void => {
       this.metrics?.pingQueueSize.update(this.pingQueue.size)
       this.metrics?.pingRunning.update(this.pingQueue.pending)
     }
@@ -121,11 +121,11 @@ export class RoutingTable implements Startable {
     this._onPing = this._onPing.bind(this)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.running = true
 
     if (this.components.metrics != null) {
@@ -150,7 +150,7 @@ export class RoutingTable implements Startable {
     this._tagPeers(kBuck)
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     this.running = false
     this.pingQueue.clear()
     this.kb = undefined
@@ -161,7 +161,7 @@ export class RoutingTable implements Startable {
    * - this will lower the chances that connections to them get closed when
    * we reach connection limits
    */
-  _tagPeers (kBuck: KBucketTree) {
+  _tagPeers (kBuck: KBucketTree): void {
     let kClosest = new PeerSet()
 
     const updatePeerTags = utils.debounce(() => {
@@ -208,7 +208,7 @@ export class RoutingTable implements Startable {
    * `oldContacts` will not be empty and is the list of contacts that
    * have not been contacted for the longest.
    */
-  _onPing (oldContacts: KBucketPeer[], newContact: KBucketPeer) {
+  _onPing (oldContacts: KBucketPeer[], newContact: KBucketPeer): void {
     // 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
@@ -272,7 +272,7 @@ export class RoutingTable implements Startable {
   /**
    * Amount of currently stored peers
    */
-  get size () {
+  get size (): number {
     if (this.kb == null) {
       return 0
     }
@@ -323,14 +323,14 @@ export class RoutingTable implements Startable {
   /**
    * Add or update the routing table with the given peer
    */
-  async add (peer: PeerId) {
+  async add (peer: PeerId): Promise<void> {
     if (this.kb == null) {
       throw new Error('RoutingTable is not started')
     }
 
     const id = await utils.convertPeerId(peer)
 
-    this.kb.add({ id: id, peer: peer })
+    this.kb.add({ id, peer })
 
     this.log('added %p with kad id %b', peer, id)
 
@@ -340,7 +340,7 @@ export class RoutingTable implements Startable {
   /**
    * Remove a given peer from the table
    */
-  async remove (peer: PeerId) {
+  async remove (peer: PeerId): Promise<void> {
     if (this.kb == null) {
       throw new Error('RoutingTable is not started')
     }

package/src/routing-table/refresh.ts

@@ -10,6 +10,7 @@ import { TABLE_REFRESH_INTERVAL, TABLE_REFRESH_QUERY_TIMEOUT } from '../constant
 import type { RoutingTable } from './index.js'
 import type { Logger } from '@libp2p/logger'
 import type { PeerRouting } from '../peer-routing/index.js'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 /**
  * Cannot generate random KadIds longer than this + 1
@@ -49,12 +50,12 @@ export class RoutingTableRefresh {
     this.refreshTable = this.refreshTable.bind(this)
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.log(`refreshing routing table every ${this.refreshInterval}ms`)
     this.refreshTable(true)
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     if (this.refreshTimeoutId != null) {
       clearTimeout(this.refreshTimeoutId)
     }
@@ -66,7 +67,7 @@ export class RoutingTableRefresh {
    * that is close to the requested peer ID and query that, then network
    * peers will tell us who they know who is close to the fake ID
    */
-  refreshTable (force: boolean = false) {
+  refreshTable (force: boolean = false): void {
     this.log('refreshing routing table')
 
     const prefixLength = this._maxCommonPrefix()
@@ -123,7 +124,7 @@ export class RoutingTableRefresh {
     })
   }
 
-  async _refreshCommonPrefixLength (cpl: number, lastRefresh: Date, force: boolean) {
+  async _refreshCommonPrefixLength (cpl: number, lastRefresh: Date, force: boolean): Promise<void> {
     if (!force && lastRefresh.getTime() > (Date.now() - this.refreshInterval)) {
       this.log('not running refresh for cpl %s as time since last refresh not above interval', cpl)
       return
@@ -146,7 +147,7 @@ export class RoutingTableRefresh {
     }
   }
 
-  _getTrackedCommonPrefixLengthsForRefresh (maxCommonPrefix: number) {
+  _getTrackedCommonPrefixLengthsForRefresh (maxCommonPrefix: number): Date[] {
     if (maxCommonPrefix > MAX_COMMON_PREFIX_LENGTH) {
       maxCommonPrefix = MAX_COMMON_PREFIX_LENGTH
     }
@@ -161,7 +162,7 @@ export class RoutingTableRefresh {
     return dates
   }
 
-  async _generateRandomPeerId (targetCommonPrefixLength: number) {
+  async _generateRandomPeerId (targetCommonPrefixLength: number): Promise<PeerId> {
     if (this.routingTable.kb == null) {
       throw new Error('Routing table not started')
     }
@@ -174,7 +175,7 @@ export class RoutingTableRefresh {
     return peerIdFromBytes(key)
   }
 
-  async _makePeerId (localKadId: Uint8Array, randomPrefix: number, targetCommonPrefixLength: number) {
+  async _makePeerId (localKadId: Uint8Array, randomPrefix: number, targetCommonPrefixLength: number): Promise<Uint8Array> {
     if (targetCommonPrefixLength > MAX_COMMON_PREFIX_LENGTH) {
       throw new Error(`Cannot generate peer ID for common prefix length greater than ${MAX_COMMON_PREFIX_LENGTH}`)
     }
@@ -208,7 +209,7 @@ export class RoutingTableRefresh {
    * returns the maximum common prefix length between any peer in the table
    * and the current peer
    */
-  _maxCommonPrefix () {
+  _maxCommonPrefix (): number {
     // xor our KadId with every KadId in the k-bucket tree,
     // return the longest id prefix that is the same
     let prefixLength = 0
@@ -225,7 +226,7 @@ export class RoutingTableRefresh {
   /**
    * Returns the number of peers in the table with a given prefix length
    */
-  _numPeersForCpl (prefixLength: number) {
+  _numPeersForCpl (prefixLength: number): number {
     let count = 0
 
     for (const length of this._prefixLengths()) {
@@ -240,7 +241,7 @@ export class RoutingTableRefresh {
   /**
    * Yields the common prefix length of every peer in the table
    */
-  * _prefixLengths () {
+  * _prefixLengths (): Generator<number> {
     if (this.routingTable.kb == null) {
       return
     }

package/src/rpc/handlers/add-provider.ts

@@ -1,5 +1,5 @@
 import { CID } from 'multiformats/cid'
-import errcode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { logger } from '@libp2p/logger'
 import type { Providers } from '../../providers'
 import type { PeerId } from '@libp2p/interface-peer-id'
@@ -20,11 +20,11 @@ export class AddProviderHandler implements DHTMessageHandler {
     this.providers = providers
   }
 
-  async handle (peerId: PeerId, msg: Message) {
+  async handle (peerId: PeerId, msg: Message): Promise<Message | undefined> {
     log('start')
 
     if (msg.key == null || msg.key.length === 0) {
-      throw errcode(new Error('Missing key'), 'ERR_MISSING_KEY')
+      throw new CodeError('Missing key', 'ERR_MISSING_KEY')
     }
 
     let cid: CID
@@ -32,7 +32,7 @@ export class AddProviderHandler implements DHTMessageHandler {
       // this is actually just the multihash, not the whole CID
       cid = CID.decode(msg.key)
     } catch (err: any) {
-      throw errcode(new Error('Invalid CID'), 'ERR_INVALID_CID')
+      throw new CodeError('Invalid CID', 'ERR_INVALID_CID')
     }
 
     if (msg.providerPeers == null || msg.providerPeers.length === 0) {

package/src/rpc/handlers/find-node.ts

@@ -40,7 +40,7 @@ export class FindNodeHandler implements DHTMessageHandler {
   /**
    * Process `FindNode` DHT messages
    */
-  async handle (peerId: PeerId, msg: Message) {
+  async handle (peerId: PeerId, msg: Message): Promise<Message> {
     log('incoming request from %p for peers closer to %b', peerId, msg.key)
 
     let closer: PeerInfo[] = []

package/src/rpc/handlers/get-providers.ts

@@ -1,5 +1,5 @@
 import { CID } from 'multiformats/cid'
-import errcode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { Message } from '../../message/index.js'
 import {
   removePrivateAddresses,
@@ -12,6 +12,7 @@ import type { PeerRouting } from '../../peer-routing/index.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-providers')
 
@@ -40,12 +41,12 @@ export class GetProvidersHandler implements DHTMessageHandler {
     this.lan = Boolean(lan)
   }
 
-  async handle (peerId: PeerId, msg: Message) {
+  async handle (peerId: PeerId, msg: Message): Promise<Message> {
     let cid
     try {
       cid = CID.decode(msg.key)
     } catch (err: any) {
-      throw errcode(new Error('Invalid CID'), 'ERR_INVALID_CID')
+      throw new CodeError('Invalid CID', 'ERR_INVALID_CID')
     }
 
     log('%p asking for providers for %s', peerId, cid)
@@ -71,13 +72,13 @@ export class GetProvidersHandler implements DHTMessageHandler {
     return response
   }
 
-  async _getAddresses (peerId: PeerId) {
+  async _getAddresses (peerId: PeerId): Promise<Multiaddr[]> {
     const addrs = await this.components.peerStore.addressBook.get(peerId)
 
     return addrs.map(address => address.multiaddr)
   }
 
-  async _getPeers (peerIds: PeerId[]) {
+  async _getPeers (peerIds: PeerId[]): Promise<PeerInfo[]> {
     const output: PeerInfo[] = []
     const addrFilter = this.lan ? removePublicAddresses : removePrivateAddresses
 

package/src/rpc/handlers/get-value.ts

@@ -1,5 +1,5 @@
 import { Libp2pRecord } from '@libp2p/record'
-import errcode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { Message, MESSAGE_TYPE } from '../../message/index.js'
 import {
   MAX_RECORD_AGE
@@ -34,13 +34,13 @@ export class GetValueHandler implements DHTMessageHandler {
     this.peerRouting = peerRouting
   }
 
-  async handle (peerId: PeerId, msg: Message) {
+  async handle (peerId: PeerId, msg: Message): Promise<Message> {
     const key = msg.key
 
     log('%p asked for key %b', peerId, key)
 
     if (key == null || key.length === 0) {
-      throw errcode(new Error('Invalid key'), 'ERR_INVALID_KEY')
+      throw new CodeError('Invalid key', 'ERR_INVALID_KEY')
     }
 
     const response = new Message(MESSAGE_TYPE.GET_VALUE, key, msg.clusterLevel)
@@ -54,7 +54,7 @@ export class GetValueHandler implements DHTMessageHandler {
         const key = await this.components.peerStore.keyBook.get(idFromKey)
 
         if (key == null) {
-          throw errcode(new Error('No public key found in key book'), 'ERR_NOT_FOUND')
+          throw new CodeError('No public key found in key book', 'ERR_NOT_FOUND')
         }
 
         pubKey = key
@@ -91,11 +91,11 @@ export class GetValueHandler implements DHTMessageHandler {
 
   /**
    * Try to fetch a given record by from the local datastore.
-   * Returns the record iff it is still valid, meaning
+   * Returns the record if it is still valid, meaning
    * - it was either authored by this node, or
    * - it was received less than `MAX_RECORD_AGE` ago.
    */
-  async _checkLocalDatastore (key: Uint8Array) {
+  async _checkLocalDatastore (key: Uint8Array): Promise<Libp2pRecord | undefined> {
     log('checkLocalDatastore looking for %b', key)
     const dsKey = bufferToRecordKey(key)
 
@@ -114,7 +114,7 @@ export class GetValueHandler implements DHTMessageHandler {
     const record = Libp2pRecord.deserialize(rawRecord)
 
     if (record == null) {
-      throw errcode(new Error('Invalid record'), 'ERR_INVALID_RECORD')
+      throw new CodeError('Invalid record', 'ERR_INVALID_RECORD')
     }
 
     // Check validity: compare time received with max record age

package/src/rpc/handlers/ping.ts

@@ -6,7 +6,7 @@ import type { PeerId } from '@libp2p/interface-peer-id'
 const log = logger('libp2p:kad-dht:rpc:handlers:ping')
 
 export class PingHandler implements DHTMessageHandler {
-  async handle (peerId: PeerId, msg: Message) {
+  async handle (peerId: PeerId, msg: Message): Promise<Message> {
     log('ping from %p', peerId)
     return msg
   }

package/src/rpc/handlers/put-value.ts

@@ -1,5 +1,5 @@
 import { bufferToRecordKey } from '../../utils.js'
-import errcode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { verifyRecord } from '@libp2p/record/validators'
 import { Logger, logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
@@ -29,7 +29,7 @@ export class PutValueHandler implements DHTMessageHandler {
     this.validators = validators
   }
 
-  async handle (peerId: PeerId, msg: Message) {
+  async handle (peerId: PeerId, msg: Message): Promise<Message> {
     const key = msg.key
     this.log('%p asked us to store value for key %b', peerId, key)
 
@@ -39,7 +39,7 @@ export class PutValueHandler implements DHTMessageHandler {
       const errMsg = `Empty record from: ${peerId.toString()}`
 
       this.log.error(errMsg)
-      throw errcode(new Error(errMsg), 'ERR_EMPTY_RECORD')
+      throw new CodeError(errMsg, 'ERR_EMPTY_RECORD')
     }
 
     try {

package/src/rpc/index.ts

@@ -54,7 +54,7 @@ export class RPC {
   /**
    * Process incoming DHT messages
    */
-  async handleMessage (peerId: PeerId, msg: Message) {
+  async handleMessage (peerId: PeerId, msg: Message): Promise<Message | undefined> {
     try {
       await this.routingTable.add(peerId)
     } catch (err: any) {
@@ -75,7 +75,7 @@ export class RPC {
   /**
    * Handle incoming streams on the dht protocol
    */
-  onIncomingStream (data: IncomingStreamData) {
+  onIncomingStream (data: IncomingStreamData): void {
     Promise.resolve().then(async () => {
       const { stream, connection } = data
       const peerId = connection.remotePeer

package/src/topology-listener.ts

@@ -36,14 +36,14 @@ export class TopologyListener extends EventEmitter<TopologyListenerEvents> imple
     this.protocol = protocol
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Start the network
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.running) {
       return
     }
@@ -65,7 +65,7 @@ export class TopologyListener extends EventEmitter<TopologyListenerEvents> imple
   /**
    * Stop all network activity
    */
-  stop () {
+  async stop (): Promise<void> {
     this.running = false
 
     // unregister protocol and handlers

package/src/utils.ts

@@ -82,7 +82,7 @@ export function removePublicAddresses (peer: PeerInfo): PeerInfo {
 /**
  * Creates a DHT ID by hashing a given Uint8Array
  */
-export async function convertBuffer (buf: Uint8Array) {
+export async function convertBuffer (buf: Uint8Array): Promise<Uint8Array> {
   const multihash = await sha256.digest(buf)
 
   return multihash.digest
@@ -91,61 +91,61 @@ export async function convertBuffer (buf: Uint8Array) {
 /**
  * Creates a DHT ID by hashing a Peer ID
  */
-export async function convertPeerId (peerId: PeerId) {
+export async function convertPeerId (peerId: PeerId): Promise<Uint8Array> {
   return await convertBuffer(peerId.toBytes())
 }
 
 /**
  * Convert a Uint8Array to their SHA2-256 hash
  */
-export function bufferToKey (buf: Uint8Array) {
+export function bufferToKey (buf: Uint8Array): Key {
   return new Key('/' + uint8ArrayToString(buf, 'base32'), false)
 }
 
 /**
  * Convert a Uint8Array to their SHA2-256 hash
  */
-export function bufferToRecordKey (buf: Uint8Array) {
+export function bufferToRecordKey (buf: Uint8Array): Key {
   return new Key(`${RECORD_KEY_PREFIX}/${uint8ArrayToString(buf, 'base32')}`, false)
 }
 
 /**
  * Generate the key for a public key.
  */
-export function keyForPublicKey (peer: PeerId) {
+export function keyForPublicKey (peer: PeerId): Uint8Array {
   return uint8ArrayConcat([
     PK_PREFIX,
     peer.toBytes()
   ])
 }
 
-export function isPublicKeyKey (key: Uint8Array) {
+export function isPublicKeyKey (key: Uint8Array): boolean {
   return uint8ArrayToString(key.subarray(0, 4)) === '/pk/'
 }
 
-export function isIPNSKey (key: Uint8Array) {
+export function isIPNSKey (key: Uint8Array): boolean {
   return uint8ArrayToString(key.subarray(0, 4)) === '/ipns/'
 }
 
-export function fromPublicKeyKey (key: Uint8Array) {
+export function fromPublicKeyKey (key: Uint8Array): PeerId {
   return peerIdFromBytes(key.subarray(4))
 }
 
 /**
  * Create a new put record, encodes and signs it if enabled
  */
-export function createPutRecord (key: Uint8Array, value: Uint8Array) {
+export function createPutRecord (key: Uint8Array, value: Uint8Array): Uint8Array {
   const timeReceived = new Date()
   const rec = new Libp2pRecord(key, value, timeReceived)
 
   return rec.serialize()
 }
 
-export function debounce (callback: () => void, wait: number = 100) {
+export function debounce (callback: () => void, wait: number = 100): () => void {
   let timeout: ReturnType<typeof setTimeout>
 
-  return () => {
+  return (): void => {
     clearTimeout(timeout)
-    timeout = setTimeout(() => callback(), wait)
+    timeout = setTimeout(() => { callback() }, wait)
   }
 }