@libp2p/kad-dht 7.0.0 → 7.0.2

package/src/kad-dht.ts

@@ -14,7 +14,7 @@ import {
   removePublicAddresses
 } from './utils.js'
 import { Logger, logger } from '@libp2p/logger'
-import type { QueryOptions, Validators, Selectors, DHT } from '@libp2p/interface-dht'
+import type { QueryOptions, Validators, Selectors, DHT, QueryEvent } from '@libp2p/interface-dht'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { PeerId } from '@libp2p/interface-peer-id'
@@ -207,11 +207,11 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
     return true
   }
 
-  get [Symbol.toStringTag] () {
+  get [Symbol.toStringTag] (): '@libp2p/kad-dht' {
     return '@libp2p/kad-dht'
   }
 
-  async onPeerConnect (peerData: PeerInfo) {
+  async onPeerConnect (peerData: PeerInfo): Promise<void> {
     this.log('peer %p connected with protocols %s', peerData.id, peerData.protocols)
 
     if (this.lan) {
@@ -235,21 +235,21 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
   /**
    * Is this DHT running.
    */
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * If 'server' this node will respond to DHT queries, if 'client' this node will not
    */
-  async getMode () {
+  async getMode (): Promise<'client' | 'server'> {
     return this.clientMode ? 'client' : 'server'
   }
 
   /**
    * If 'server' this node will respond to DHT queries, if 'client' this node will not
    */
-  async setMode (mode: 'client' | 'server') {
+  async setMode (mode: 'client' | 'server'): Promise<void> {
     await this.components.registrar.unhandle(this.protocol)
 
     if (mode === 'client') {
@@ -268,7 +268,7 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
   /**
    * Start listening to incoming connections.
    */
-  async start () {
+  async start (): Promise<void> {
     this.running = true
 
     // Only respond to queries when not in client mode
@@ -290,7 +290,7 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
    * Stop accepting incoming connections and sending outgoing
    * messages.
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.running = false
 
     await Promise.all([
@@ -307,14 +307,14 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
   /**
    * Store the given key/value pair in the DHT
    */
-  async * put (key: Uint8Array, value: Uint8Array, options: QueryOptions = {}) { // eslint-disable-line require-await
+  async * put (key: Uint8Array, value: Uint8Array, options: QueryOptions = {}): AsyncGenerator<any, void, undefined> {
     yield * this.contentFetching.put(key, value, options)
   }
 
   /**
    * Get the value that corresponds to the passed key
    */
-  async * get (key: Uint8Array, options: QueryOptions = {}) { // eslint-disable-line require-await
+  async * get (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent, void, undefined> {
     yield * this.contentFetching.get(key, options)
   }
 
@@ -323,14 +323,14 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
   /**
    * Announce to the network that we can provide given key's value
    */
-  async * provide (key: CID, options: QueryOptions = {}) { // eslint-disable-line require-await
+  async * provide (key: CID, options: QueryOptions = {}): AsyncGenerator<QueryEvent, void, undefined> {
     yield * this.contentRouting.provide(key, this.components.addressManager.getAddresses(), options)
   }
 
   /**
    * Search the dht for providers of the given CID
    */
-  async * findProviders (key: CID, options: QueryOptions = {}) {
+  async * findProviders (key: CID, options: QueryOptions = {}): AsyncGenerator<QueryEvent, any, unknown> {
     yield * this.contentRouting.findProviders(key, options)
   }
 
@@ -339,18 +339,18 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
   /**
    * Search for a peer with the given ID
    */
-  async * findPeer (id: PeerId, options: QueryOptions = {}) { // eslint-disable-line require-await
+  async * findPeer (id: PeerId, options: QueryOptions = {}): AsyncGenerator<QueryEvent, any, unknown> {
     yield * this.peerRouting.findPeer(id, options)
   }
 
   /**
    * Kademlia 'node lookup' operation
    */
-  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}) {
+  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent, any, unknown> {
     yield * this.peerRouting.getClosestPeers(key, options)
   }
 
-  async refreshRoutingTable () {
-    await this.routingTableRefresh.refreshTable(true)
+  async refreshRoutingTable (): Promise<void> {
+    this.routingTableRefresh.refreshTable(true)
   }
 }

package/src/message/dht.ts

@@ -126,7 +126,7 @@ export namespace Message {
   }
 
   export namespace MessageType {
-    export const codec = () => {
+    export const codec = (): Codec<MessageType> => {
       return enumeration<MessageType>(__MessageTypeValues)
     }
   }
@@ -146,7 +146,7 @@ export namespace Message {
   }
 
   export namespace ConnectionType {
-    export const codec = () => {
+    export const codec = (): Codec<ConnectionType> => {
       return enumeration<ConnectionType>(__ConnectionTypeValues)
     }
   }

package/src/message/index.ts

@@ -42,7 +42,7 @@ export class Message {
   /**
    * @type {number}
    */
-  get clusterLevel () {
+  get clusterLevel (): number {
     const level = this.clusterLevelRaw - 1
     if (level < 0) {
       return 0
@@ -58,7 +58,7 @@ export class Message {
   /**
    * Encode into protobuf
    */
-  serialize () {
+  serialize (): Uint8Array {
     return PBMessage.encode({
       key: this.key,
       type: this.type,
@@ -72,7 +72,7 @@ export class Message {
   /**
    * Decode from protobuf
    */
-  static deserialize (raw: Uint8ArrayList | Uint8Array) {
+  static deserialize (raw: Uint8ArrayList | Uint8Array): Message {
     const dec = PBMessage.decode(raw)
 
     const msg = new Message(dec.type ?? PBMessage.MessageType.PUT_VALUE, dec.key ?? Uint8Array.from([]), dec.clusterLevelRaw ?? 0)
@@ -87,7 +87,7 @@ export class Message {
   }
 }
 
-function toPbPeer (peer: PeerInfo) {
+function toPbPeer (peer: PeerInfo): PBPeer {
   const output: PBPeer = {
     id: peer.id.toBytes(),
     addrs: (peer.multiaddrs ?? []).map((m) => m.bytes),
@@ -97,7 +97,7 @@ function toPbPeer (peer: PeerInfo) {
   return output
 }
 
-function fromPbPeer (peer: PBMessage.Peer) {
+function fromPbPeer (peer: PBMessage.Peer): PeerInfo {
   if (peer.id == null) {
     throw new Error('Invalid peer in message')
   }

package/src/network.ts

@@ -1,4 +1,4 @@
-import errcode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { pipe } from 'it-pipe'
 import * as lp from 'it-length-prefixed'
 import drain from 'it-drain'
@@ -22,6 +22,7 @@ import type { Stream } from '@libp2p/interface-connection'
 import { abortableDuplex } from 'abortable-iterator'
 import type { Uint8ArrayList } from 'uint8arraylist'
 import type { KadDHTComponents } from './index.js'
+import type { QueryEvent } from '@libp2p/interface-dht'
 
 export interface NetworkInit {
   protocol: string
@@ -57,7 +58,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Start the network
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.running) {
       return
     }
@@ -68,21 +69,21 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Stop all network activity
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.running = false
   }
 
   /**
    * Is the network online?
    */
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Send a request and record RTT for latency measurements
    */
-  async * sendRequest (to: PeerId, msg: Message, options: AbortOptions = {}) {
+  async * sendRequest (to: PeerId, msg: Message, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       return
     }
@@ -118,7 +119,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Sends a message without expecting an answer
    */
-  async * sendMessage (to: PeerId, msg: Message, options: AbortOptions = {}) {
+  async * sendMessage (to: PeerId, msg: Message, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       return
     }
@@ -148,7 +149,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Write a message to the given stream
    */
-  async _writeMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
+  async _writeMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<void> {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }
@@ -166,7 +167,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
    * If no response is received after the specified timeout
    * this will error out.
    */
-  async _writeReadMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
+  async _writeReadMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<Message> {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }
@@ -183,7 +184,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
           return buf
         }
 
-        throw errcode(new Error('No message received'), 'ERR_NO_MESSAGE_RECEIVED')
+        throw new CodeError('No message received', 'ERR_NO_MESSAGE_RECEIVED')
       }
     )
 

package/src/peer-list/index.ts

@@ -13,7 +13,7 @@ export class PeerList {
   /**
    * Add a new peer. Returns `true` if it was a new one
    */
-  push (peerId: PeerId) {
+  push (peerId: PeerId): boolean {
     if (!this.has(peerId)) {
       this.list.push(peerId)
 
@@ -26,7 +26,7 @@ export class PeerList {
   /**
    * Check if this PeerInfo is already in here
    */
-  has (peerId: PeerId) {
+  has (peerId: PeerId): boolean {
     const match = this.list.find((i) => i.equals(peerId))
     return Boolean(match)
   }
@@ -34,21 +34,21 @@ export class PeerList {
   /**
    * Get the list as an array
    */
-  toArray () {
+  toArray (): PeerId[] {
     return this.list.slice()
   }
 
   /**
    * Remove the last element
    */
-  pop () {
+  pop (): PeerId | undefined {
     return this.list.pop()
   }
 
   /**
    * The length of the list
    */
-  get length () {
+  get length (): number {
     return this.list.length
   }
 }

package/src/peer-list/peer-distance-list.ts

@@ -33,21 +33,21 @@ export class PeerDistanceList {
   /**
    * The length of the list
    */
-  get length () {
+  get length (): number {
     return this.peerDistances.length
   }
 
   /**
    * The peerIds in the list, in order of distance from the origin key
    */
-  get peers () {
+  get peers (): PeerId[] {
     return this.peerDistances.map(pd => pd.peerId)
   }
 
   /**
    * Add a peerId to the list.
    */
-  async add (peerId: PeerId) {
+  async add (peerId: PeerId): Promise<void> {
     if (this.peerDistances.find(pd => pd.peerId.equals(peerId)) != null) {
       return
     }
@@ -67,7 +67,7 @@ export class PeerDistanceList {
    * Indicates whether any of the peerIds passed as a parameter are closer
    * to the origin key than the furthest peerId in the PeerDistanceList.
    */
-  async anyCloser (peerIds: PeerId[]) {
+  async anyCloser (peerIds: PeerId[]): Promise<boolean> {
     if (peerIds.length === 0) {
       return false
     }

package/src/peer-routing/index.ts

@@ -1,4 +1,4 @@
-import errcode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { verifyRecord } from '@libp2p/record/validators'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { Message, MESSAGE_TYPE } from '../message/index.js'
@@ -13,7 +13,7 @@ import { Libp2pRecord } from '@libp2p/record'
 import { logger } from '@libp2p/logger'
 import { keys } from '@libp2p/crypto'
 import { peerIdFromKeys } from '@libp2p/peer-id'
-import type { DHTRecord, QueryOptions, Validators } from '@libp2p/interface-dht'
+import type { DHTRecord, DialingPeerEvent, FinalPeerEvent, QueryEvent, QueryOptions, Validators } from '@libp2p/interface-dht'
 import type { RoutingTable } from '../routing-table/index.js'
 import type { QueryManager } from '../query/manager.js'
 import type { Network } from '../network.js'
@@ -97,7 +97,7 @@ export class PeerRouting {
   /**
    * Get a value via rpc call for the given parameters
    */
-  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: AbortOptions = {}) { // eslint-disable-line require-await
+  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     const msg = new Message(MESSAGE_TYPE.GET_VALUE, key, 0)
     yield * this.network.sendRequest(peer, msg, options)
   }
@@ -105,7 +105,7 @@ export class PeerRouting {
   /**
    * Get the public key directly from a node
    */
-  async * getPublicKeyFromNode (peer: PeerId, options: AbortOptions = {}) {
+  async * getPublicKeyFromNode (peer: PeerId, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     const pkKey = utils.keyForPublicKey(peer)
 
     for await (const event of this._getValueSingle(peer, pkKey, options)) {
@@ -116,24 +116,24 @@ export class PeerRouting {
 
         // compare hashes of the pub key
         if (!recPeer.equals(peer)) {
-          throw errcode(new Error('public key does not match id'), 'ERR_PUBLIC_KEY_DOES_NOT_MATCH_ID')
+          throw new CodeError('public key does not match id', 'ERR_PUBLIC_KEY_DOES_NOT_MATCH_ID')
         }
 
         if (recPeer.publicKey == null) {
-          throw errcode(new Error('public key missing'), 'ERR_PUBLIC_KEY_MISSING')
+          throw new CodeError('public key missing', 'ERR_PUBLIC_KEY_MISSING')
         }
 
         yield valueEvent({ from: peer, value: recPeer.publicKey })
       }
     }
 
-    throw errcode(new Error(`Node not responding with its public key: ${peer.toString()}`), 'ERR_INVALID_RECORD')
+    throw new CodeError(`Node not responding with its public key: ${peer.toString()}`, 'ERR_INVALID_RECORD')
   }
 
   /**
    * Search for a peer with the given ID
    */
-  async * findPeer (id: PeerId, options: QueryOptions = {}) {
+  async * findPeer (id: PeerId, options: QueryOptions = {}): AsyncGenerator<FinalPeerEvent | QueryEvent> {
     this.log('findPeer %p', id)
 
     // Try to find locally
@@ -207,7 +207,7 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({ from: this.components.peerId, error: errcode(new Error('Not found'), 'ERR_NOT_FOUND') })
+      yield queryErrorEvent({ from: this.components.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') })
     }
   }
 
@@ -215,14 +215,14 @@ 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 = {}) {
+  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<DialingPeerEvent | QueryEvent> {
     this.log('getClosestPeers to %b', key)
     const id = await utils.convertBuffer(key)
     const tablePeers = this.routingTable.closestPeers(id)
     const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
     const peers = new PeerDistanceList(id, this.routingTable.kBucketSize)
-    await Promise.all(tablePeers.map(async peer => await peers.add(peer)))
+    await Promise.all(tablePeers.map(async peer => { await peers.add(peer) }))
 
     const getCloserPeersQuery: QueryFunc = async function * ({ peer, signal }) {
       self.log('closerPeersSingle %s from %p', uint8ArrayToString(key, 'base32'), peer)
@@ -235,7 +235,7 @@ export class PeerRouting {
       yield event
 
       if (event.name === 'PEER_RESPONSE') {
-        await Promise.all(event.closer.map(async peerData => await peers.add(peerData.id)))
+        await Promise.all(event.closer.map(async peerData => { await peers.add(peerData.id) }))
       }
     }
 
@@ -259,7 +259,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 = {}) {
+  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: AbortOptions = {}): AsyncGenerator<DialingPeerEvent | QueryEvent> {
     for await (const event of this._getValueSingle(peer, key, options)) {
       if (event.name === 'PEER_RESPONSE') {
         if (event.record != null) {
@@ -270,7 +270,7 @@ export class PeerRouting {
             const errMsg = 'invalid record received, discarded'
             this.log(errMsg)
 
-            yield queryErrorEvent({ from: event.from, error: errcode(new Error(errMsg), 'ERR_INVALID_RECORD') })
+            yield queryErrorEvent({ from: event.from, error: new CodeError(errMsg, 'ERR_INVALID_RECORD') })
             continue
           }
         }
@@ -284,9 +284,9 @@ export class PeerRouting {
    * Verify a record, fetching missing public keys from the network.
    * Throws an error if the record is invalid.
    */
-  async _verifyRecordOnline (record: DHTRecord) {
+  async _verifyRecordOnline (record: DHTRecord): Promise<void> {
     if (record.timeReceived == null) {
-      throw errcode(new Error('invalid record received'), 'ERR_INVALID_RECORD')
+      throw new CodeError('invalid record received', 'ERR_INVALID_RECORD')
     }
 
     await verifyRecord(this.validators, new Libp2pRecord(record.key, record.value, record.timeReceived))
@@ -296,7 +296,7 @@ export class PeerRouting {
    * Get the nearest peers to the given query, but if closer
    * than self
    */
-  async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId) {
+  async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId): Promise<PeerInfo[]> {
     const id = await utils.convertBuffer(key)
     const ids = this.routingTable.closestPeers(id)
     const output: PeerInfo[] = []

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)
 
@@ -216,6 +216,11 @@ export class Providers implements Startable {
       return [...provs.keys()].map(peerIdStr => {
         return peerIdFromString(peerIdStr)
       })
+    }, {
+      // no timeout is specified for this queue so it will not
+      // throw, but this is required to get the right return
+      // type since p-queue@7.3.4
+      throwOnTimeout: true
     })
   }
 }
@@ -223,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}`
@@ -232,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),
     '/',
@@ -242,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) {
@@ -264,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) })
 
@@ -276,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')
     }