@libp2p/kad-dht 7.0.1 → 7.0.2

package/src/providers.ts

@@ -66,14 +66,14 @@ export class Providers implements Startable {
     this.started = false
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
   /**
    * Start the provider cleanup service
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.started) {
       return
     }
@@ -93,7 +93,7 @@ export class Providers implements Startable {
   /**
    * Release any resources.
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
 
     if (this.cleaner != null) {
@@ -105,8 +105,8 @@ export class Providers implements Startable {
   /**
    * Check all providers if they are still valid, and if not delete them
    */
-  async _cleanup () {
-    return await this.syncQueue.add(async () => {
+  async _cleanup (): Promise<void> {
+    await this.syncQueue.add(async () => {
       const start = Date.now()
 
       let count = 0
@@ -174,7 +174,7 @@ export class Providers implements Startable {
   /**
    * Get the currently known provider peer ids for a given CID
    */
-  async _getProvidersMap (cid: CID) {
+  async _getProvidersMap (cid: CID): Promise<Map<string, Date>> {
     const cacheKey = makeProviderKey(cid)
     let provs: Map<string, Date> = this.cache.get(cacheKey)
 
@@ -189,8 +189,8 @@ export class Providers implements Startable {
   /**
    * Add a new provider for the given CID
    */
-  async addProvider (cid: CID, provider: PeerId) {
-    return await this.syncQueue.add(async () => {
+  async addProvider (cid: CID, provider: PeerId): Promise<void> {
+    await this.syncQueue.add(async () => {
       log('%p provides %s', provider, cid)
       const provs = await this._getProvidersMap(cid)
 
@@ -228,7 +228,7 @@ export class Providers implements Startable {
 /**
  * Encode the given key its matching datastore key
  */
-function makeProviderKey (cid: CID | string) {
+function makeProviderKey (cid: CID | string): string {
   const cidStr = typeof cid === 'string' ? cid : uint8ArrayToString(cid.multihash.bytes, 'base32')
 
   return `${PROVIDER_KEY_PREFIX}/${cidStr}`
@@ -237,7 +237,7 @@ function makeProviderKey (cid: CID | string) {
 /**
  * Write a provider into the given store
  */
-async function writeProviderEntry (store: Datastore, cid: CID, peer: PeerId, time: Date) { // eslint-disable-line require-await
+async function writeProviderEntry (store: Datastore, cid: CID, peer: PeerId, time: Date): Promise<void> {
   const dsKey = [
     makeProviderKey(cid),
     '/',
@@ -247,13 +247,13 @@ async function writeProviderEntry (store: Datastore, cid: CID, peer: PeerId, tim
   const key = new Key(dsKey)
   const buffer = Uint8Array.from(varint.encode(time.getTime()))
 
-  return await store.put(key, buffer)
+  await store.put(key, buffer)
 }
 
 /**
  * Parse the CID and provider peer id from the key
  */
-function parseProviderKey (key: Key) {
+function parseProviderKey (key: Key): { cid: string, peerId: string } {
   const parts = key.toString().split('/')
 
   if (parts.length !== 5) {
@@ -269,7 +269,7 @@ function parseProviderKey (key: Key) {
 /**
  * Load providers for the given CID from the store
  */
-async function loadProviders (store: Datastore, cid: CID) {
+async function loadProviders (store: Datastore, cid: CID): Promise<Map<string, Date>> {
   const providers = new Map<string, Date>()
   const query = store.query({ prefix: makeProviderKey(cid) })
 
@@ -281,6 +281,6 @@ async function loadProviders (store: Datastore, cid: CID) {
   return providers
 }
 
-function readTime (buf: Uint8Array) {
+function readTime (buf: Uint8Array): Date {
   return new Date(varint.decode(buf))
 }

package/src/query/manager.ts

@@ -12,7 +12,7 @@ import { logger } from '@libp2p/logger'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { QueryFunc } from './types.js'
-import type { QueryOptions } from '@libp2p/interface-dht'
+import type { QueryEvent, QueryOptions } from '@libp2p/interface-dht'
 import { PeerSet } from '@libp2p/peer-collections'
 import type { Metric, Metrics } from '@libp2p/interface-metrics'
 
@@ -59,14 +59,14 @@ export class QueryManager implements Startable {
     this.queries = 0
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Starts the query manager
    */
-  async start () {
+  async start (): Promise<void> {
     this.running = true
 
     if (this.components.metrics != null && this.metrics == null) {
@@ -80,7 +80,7 @@ export class QueryManager implements Startable {
   /**
    * Stops all queries
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.running = false
 
     for (const controller of this.controllers) {
@@ -90,7 +90,7 @@ export class QueryManager implements Startable {
     this.controllers.clear()
   }
 
-  async * run (key: Uint8Array, peers: PeerId[], queryFunc: QueryFunc, options: QueryOptions = {}) {
+  async * run (key: Uint8Array, peers: PeerId[], queryFunc: QueryFunc, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       throw new Error('QueryManager not started')
     }

package/src/query/query-path.ts

@@ -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
     }

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

@@ -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

@@ -20,7 +20,7 @@ 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) {

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

@@ -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,7 +41,7 @@ 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)
@@ -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

@@ -34,7 +34,7 @@ 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)
@@ -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)
 

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

@@ -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)
 

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)
   }
 }