@libp2p/kad-dht 7.0.1 → 7.0.2

package/src/content-fetching/index.ts

@@ -16,7 +16,7 @@ import {
 } from '../constants.js'
 import { createPutRecord, convertBuffer, bufferToRecordKey } from '../utils.js'
 import { logger } from '@libp2p/logger'
-import type { Validators, Selectors, ValueEvent, QueryOptions } from '@libp2p/interface-dht'
+import type { Validators, Selectors, ValueEvent, QueryOptions, QueryEvent } from '@libp2p/interface-dht'
 import type { PeerRouting } from '../peer-routing/index.js'
 import type { QueryManager } from '../query/manager.js'
 import type { RoutingTable } from '../routing-table/index.js'
@@ -59,7 +59,7 @@ export class ContentFetching {
     this.network = network
   }
 
-  async putLocal (key: Uint8Array, rec: Uint8Array) { // eslint-disable-line require-await
+  async putLocal (key: Uint8Array, rec: Uint8Array): Promise<void> {
     const dsKey = bufferToRecordKey(key)
     await this.components.datastore.put(dsKey, rec)
   }
@@ -68,7 +68,7 @@ export class ContentFetching {
    * Attempt to retrieve the value for the given key from
    * the local datastore
    */
-  async getLocal (key: Uint8Array) {
+  async getLocal (key: Uint8Array): Promise<Libp2pRecord> {
     this.log('getLocal %b', key)
 
     const dsKey = bufferToRecordKey(key)
@@ -88,9 +88,9 @@ export class ContentFetching {
   /**
    * Send the best record found to any peers that have an out of date record
    */
-  async * sendCorrectionRecord (key: Uint8Array, vals: ValueEvent[], best: Uint8Array, options: AbortOptions = {}) {
+  async * sendCorrectionRecord (key: Uint8Array, vals: ValueEvent[], best: Uint8Array, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     this.log('sendCorrection for %b', key)
-    const fixupRec = await createPutRecord(key, best)
+    const fixupRec = createPutRecord(key, best)
 
     for (const { value, from } of vals) {
       // no need to do anything
@@ -136,11 +136,11 @@ export class ContentFetching {
   /**
    * Store the given key/value pair in the DHT
    */
-  async * put (key: Uint8Array, value: Uint8Array, options: AbortOptions = {}) {
+  async * put (key: Uint8Array, value: Uint8Array, options: AbortOptions = {}): AsyncGenerator<unknown, void, undefined> {
     this.log('put key %b value %b', key, value)
 
     // create record in the dht format
-    const record = await createPutRecord(key, value)
+    const record = createPutRecord(key, value)
 
     // store the record locally
     const dsKey = bufferToRecordKey(key)
@@ -192,7 +192,7 @@ export class ContentFetching {
   /**
    * Get the value to the given key
    */
-  async * get (key: Uint8Array, options: QueryOptions = {}) {
+  async * get (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent | ValueEvent> {
     this.log('get %b', key)
 
     const vals: ValueEvent[] = []
@@ -236,7 +236,7 @@ export class ContentFetching {
   /**
    * Get the `n` values to the given key without sorting
    */
-  async * getMany (key: Uint8Array, options: QueryOptions = {}) {
+  async * getMany (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     this.log('getMany values for %b', key)
 
     try {

package/src/content-routing/index.ts

@@ -10,7 +10,7 @@ import {
   providerEvent
 } from '../query/events.js'
 import { logger } from '@libp2p/logger'
-import type { QueryEvent, QueryOptions } from '@libp2p/interface-dht'
+import type { PeerResponseEvent, ProviderEvent, QueryEvent, QueryOptions } from '@libp2p/interface-dht'
 import type { PeerRouting } from '../peer-routing/index.js'
 import type { QueryManager } from '../query/manager.js'
 import type { RoutingTable } from '../routing-table/index.js'
@@ -58,7 +58,7 @@ export class ContentRouting {
    * Announce to the network that we can provide the value for a given key and
    * are contactable on the given multiaddrs
    */
-  async * provide (key: CID, multiaddrs: Multiaddr[], options: AbortOptions = {}) {
+  async * provide (key: CID, multiaddrs: Multiaddr[], options: AbortOptions = {}): AsyncGenerator<QueryEvent, void, undefined> {
     this.log('provide %s', key)
 
     // Add peer as provider
@@ -124,7 +124,7 @@ export class ContentRouting {
   /**
    * Search the dht for up to `K` providers of the given CID.
    */
-  async * findProviders (key: CID, options: QueryOptions) {
+  async * findProviders (key: CID, options: QueryOptions): AsyncGenerator<PeerResponseEvent | ProviderEvent | QueryEvent> {
     const toFind = this.routingTable.kBucketSize
     const target = key.multihash.bytes
     const id = await convertBuffer(target)
@@ -147,7 +147,7 @@ export class ContentRouting {
       }
 
       yield peerResponseEvent({ from: this.components.peerId, messageType: MESSAGE_TYPE.GET_PROVIDERS, providers })
-      yield providerEvent({ from: this.components.peerId, providers: providers })
+      yield providerEvent({ from: this.components.peerId, providers })
     }
 
     // All done

package/src/dual-kad-dht.ts

@@ -3,7 +3,7 @@ import { CodeError } from '@libp2p/interfaces/errors'
 import merge from 'it-merge'
 import { queryErrorEvent } from './query/events.js'
 import type { KadDHT } from './kad-dht.js'
-import type { DualDHT, QueryOptions } from '@libp2p/interface-dht'
+import type { DualDHT, QueryEvent, QueryOptions } from '@libp2p/interface-dht'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
 import type { CID } from 'multiformats'
@@ -47,35 +47,35 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
     return true
   }
 
-  get [Symbol.toStringTag] () {
+  get [Symbol.toStringTag] (): '@libp2p/dual-kad-dht' {
     return '@libp2p/dual-kad-dht'
   }
 
   /**
    * Is this DHT running.
    */
-  isStarted () {
+  isStarted (): boolean {
     return this.wan.isStarted() && this.lan.isStarted()
   }
 
   /**
    * If 'server' this node will respond to DHT queries, if 'client' this node will not
    */
-  async getMode () {
+  async getMode (): Promise<'client' | 'server'> {
     return await this.wan.getMode()
   }
 
   /**
    * 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.wan.setMode(mode)
   }
 
   /**
    * Start listening to incoming connections.
    */
-  async start () {
+  async start (): Promise<void> {
     await Promise.all([
       this.lan.start(),
       this.wan.start()
@@ -86,7 +86,7 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
    * Stop accepting incoming connections and sending outgoing
    * messages.
    */
-  async stop () {
+  async stop (): Promise<void> {
     await Promise.all([
       this.lan.stop(),
       this.wan.stop()
@@ -96,7 +96,7 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
   /**
    * Store the given key/value pair in the DHT
    */
-  async * put (key: Uint8Array, value: Uint8Array, options: QueryOptions = {}) {
+  async * put (key: Uint8Array, value: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     for await (const event of merge(
       this.lan.put(key, value, options),
       this.wan.put(key, value, options)
@@ -108,7 +108,7 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
   /**
    * 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> {
     let queriedPeers = false
     let foundValue = false
 
@@ -152,7 +152,7 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
   /**
    * Announce to the network that we can provide given key's value
    */
-  async * provide (key: CID, options: AbortOptions = {}) { // eslint-disable-line require-await
+  async * provide (key: CID, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     let sent = 0
     let success = 0
     const errors = []
@@ -194,7 +194,7 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
   /**
    * Search the dht for up to `K` providers of the given CID
    */
-  async * findProviders (key: CID, options: QueryOptions = {}) {
+  async * findProviders (key: CID, options: QueryOptions = {}): AsyncGenerator<QueryEvent, void, undefined> {
     yield * merge(
       this.lan.findProviders(key, options),
       this.wan.findProviders(key, options)
@@ -206,7 +206,7 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
   /**
    * Search for a peer with the given ID
    */
-  async * findPeer (id: PeerId, options: QueryOptions = {}) {
+  async * findPeer (id: PeerId, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     let queriedPeers = false
 
     for await (const event of merge(
@@ -228,14 +228,14 @@ export class DualKadDHT extends EventEmitter<PeerDiscoveryEvents> implements Dua
   /**
    * Kademlia 'node lookup' operation
    */
-  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}) {
+  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent, void, undefined> {
     yield * merge(
       this.lan.getClosestPeers(key, options),
       this.wan.getClosestPeers(key, options)
     )
   }
 
-  async refreshRoutingTable () {
+  async refreshRoutingTable (): Promise<void> {
     await Promise.all([
       this.lan.refreshRoutingTable(),
       this.wan.refreshRoutingTable()

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

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

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

@@ -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)) {
@@ -133,7 +133,7 @@ export class PeerRouting {
   /**
    * 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
@@ -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) {
@@ -284,7 +284,7 @@ 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 new CodeError('invalid record received', 'ERR_INVALID_RECORD')
     }
@@ -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[] = []