From 001af1f76db17c2eabf608f0c313e161b868a055 Mon Sep 17 00:00:00 2001
From: Chad Nehemiah <chad.nehemiah94@gmail.com>
Date: Tue, 14 Mar 2023 03:50:21 -0500
Subject: [PATCH] chore: upgrade aegir (#1566)

Updates aegir, fixes all linting and dep issues.

Co-authored-by: achingbrain <alex@achingbrain.net>
---
 examples/package.json                         |  3 +-
 package.json                                  | 10 ++-----
 src/circuit/server/advert-service.ts          |  2 +-
 src/circuit/server/index.ts                   | 13 +++++----
 src/circuit/transport/index.ts                |  4 +--
 src/circuit/utils.ts                          |  2 +-
 src/components.ts                             | 14 ++++-----
 src/connection-manager/auto-dialler.ts        |  8 ++---
 src/connection-manager/dialer/dial-request.ts |  2 +-
 src/connection-manager/dialer/index.ts        | 10 +++----
 src/connection-manager/index.ts               | 28 +++++++++---------
 src/connection-manager/latency-monitor.ts     | 18 ++++++------
 .../visibility-change-emitter.ts              |  8 ++---
 src/connection/index.ts                       | 14 ++++-----
 src/content-routing/index.ts                  | 18 +++++++-----
 src/content-routing/utils.ts                  |  6 ++--
 src/dht/dht-content-routing.ts                |  5 ++--
 src/dht/dht-peer-routing.ts                   |  5 ++--
 src/dht/dummy-dht.ts                          |  2 +-
 src/fetch/index.ts                            | 14 ++++-----
 src/identify/index.ts                         | 29 ++++++++++---------
 src/insecure/index.ts                         |  3 +-
 src/libp2p.ts                                 | 22 +++++++-------
 src/nat-manager.ts                            | 16 +++++-----
 src/peer-record-updater.ts                    |  8 ++---
 src/peer-routing.ts                           |  8 ++---
 src/ping/index.ts                             |  8 ++---
 src/pnet/crypto.ts                            |  6 ++--
 src/pnet/key-generator.ts                     |  2 +-
 src/registrar.ts                              | 16 +++++-----
 src/transport-manager.ts                      | 18 ++++++------
 src/upgrader.ts                               | 16 +++++-----
 test/circuit/reservation-store.spec.ts        | 28 +++++++++---------
 test/circuit/utils.spec.ts                    |  2 +-
 test/circuit/utils.ts                         | 14 ++++-----
 test/configuration/pubsub.spec.ts             |  2 +-
 test/connection-manager/index.node.ts         | 10 +++----
 test/connection-manager/index.spec.ts         |  2 +-
 test/content-routing/content-routing.node.ts  |  6 ++--
 test/content-routing/dht/operation.node.ts    |  4 +--
 test/content-routing/dht/utils.ts             |  2 +-
 test/dialing/dial-request.spec.ts             |  6 ++--
 test/dialing/direct.node.ts                   |  2 +-
 test/dialing/direct.spec.ts                   |  2 +-
 test/dialing/resolver.spec.ts                 |  9 +++---
 test/fetch/fetch.node.ts                      |  4 +--
 test/fetch/index.spec.ts                      |  2 +-
 test/identify/index.spec.ts                   | 10 +++----
 test/identify/push.spec.ts                    |  2 +-
 test/interop.ts                               |  4 +--
 test/nat-manager/nat-manager.node.ts          |  2 +-
 test/peer-discovery/index.node.ts             |  5 ++--
 test/peer-routing/peer-routing.node.ts        |  8 ++---
 test/ping/ping.node.ts                        |  2 +-
 test/registrar/registrar.spec.ts              | 14 ++++-----
 test/upgrading/upgrader.spec.ts               | 14 ++++-----
 test/utils/creators/peer.ts                   |  2 +-
 57 files changed, 252 insertions(+), 244 deletions(-)

diff --git a/examples/package.json b/examples/package.json
index 4bc40043fc..297e5d3789 100644
--- a/examples/package.json
+++ b/examples/package.json
@@ -9,11 +9,12 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@libp2p/pubsub-peer-discovery": "^8.0.0",
     "@libp2p/floodsub": "^6.0.0",
+    "@libp2p/pubsub-peer-discovery": "^8.0.0",
     "@nodeutils/defaults-deep": "^1.1.0",
     "execa": "^6.1.0",
     "fs-extra": "^10.1.0",
+    "it-to-buffer": "^3.0.1",
     "libp2p": "../",
     "p-defer": "^4.0.0",
     "uint8arrays": "^4.0.0",
diff --git a/package.json b/package.json
index 50b883825e..86cee6cdac 100644
--- a/package.json
+++ b/package.json
@@ -116,6 +116,7 @@
     "@libp2p/interface-peer-routing": "^1.0.1",
     "@libp2p/interface-peer-store": "^1.2.2",
     "@libp2p/interface-pubsub": "^3.0.0",
+    "@libp2p/interface-record": "^2.0.6",
     "@libp2p/interface-registrar": "^2.0.3",
     "@libp2p/interface-stream-muxer": "^3.0.0",
     "@libp2p/interface-transport": "^2.1.0",
@@ -137,8 +138,6 @@
     "any-signal": "^3.0.0",
     "datastore-core": "^8.0.1",
     "err-code": "^3.0.1",
-    "events": "^3.3.0",
-    "hashlru": "^2.3.0",
     "interface-datastore": "^7.0.0",
     "it-all": "^2.0.0",
     "it-drain": "^2.0.0",
@@ -151,7 +150,6 @@
     "it-pair": "^2.0.2",
     "it-pb-stream": "^3.2.0",
     "it-pipe": "^2.0.3",
-    "it-sort": "^2.0.0",
     "it-stream-types": "^1.0.4",
     "merge-options": "^3.0.4",
     "multiformats": "^11.0.0",
@@ -188,23 +186,21 @@
     "@libp2p/mplex": "^7.0.0",
     "@libp2p/pubsub": "^6.0.0",
     "@libp2p/tcp": "^6.0.0",
-    "@libp2p/webrtc-star": "^6.0.0",
     "@libp2p/websockets": "^5.0.0",
     "@types/p-fifo": "^1.0.0",
     "@types/varint": "^6.0.0",
     "@types/xsalsa20": "^1.1.0",
-    "aegir": "^37.5.6",
+    "aegir": "^38.1.7",
     "cborg": "^1.8.1",
     "delay": "^5.0.0",
     "execa": "^7.0.0",
     "go-libp2p": "^1.0.1",
     "it-pushable": "^3.0.0",
-    "it-to-buffer": "^3.0.0",
+    "it-to-buffer": "^3.0.1",
     "npm-run-all": "^4.1.5",
     "p-event": "^5.0.1",
     "p-times": "^4.0.0",
     "p-wait-for": "^5.0.0",
-    "protons": "^7.0.2",
     "sinon": "^15.0.1",
     "sinon-ts": "^1.0.0"
   },
diff --git a/src/circuit/server/advert-service.ts b/src/circuit/server/advert-service.ts
index 3e6589f27c..e9a942870a 100644
--- a/src/circuit/server/advert-service.ts
+++ b/src/circuit/server/advert-service.ts
@@ -96,7 +96,7 @@ export class AdvertService extends EventEmitter<AdvertServiceEvents> implements
 
         if (err.code === codes.ERR_NO_ROUTERS_AVAILABLE) {
           log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)
-          await this.stop()
+          this.stop()
           return
         }
 
diff --git a/src/circuit/server/index.ts b/src/circuit/server/index.ts
index f4b20592d0..f9074d674a 100644
--- a/src/circuit/server/index.ts
+++ b/src/circuit/server/index.ts
@@ -26,6 +26,7 @@ import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { CircuitRelayService, RelayReservation } from '../index.js'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { setMaxListeners } from 'events'
+import type { PeerMap } from '@libp2p/peer-collections'
 
 const log = logger('libp2p:circuit-relay:server')
 
@@ -247,7 +248,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       return
     }
 
-    const result = await this.reservationStore.reserve(connection.remotePeer, connection.remoteAddr)
+    const result = this.reservationStore.reserve(connection.remotePeer, connection.remoteAddr)
 
     if (result.status !== Status.OK) {
       hopstr.write({ type: HopMessage.Type.STATUS, status: result.status })
@@ -266,12 +267,12 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
         type: HopMessage.Type.STATUS,
         status: Status.OK,
         reservation: await this.makeReservation(connection.remotePeer, BigInt(result.expire ?? 0)),
-        limit: (await this.reservationStore.get(connection.remotePeer))?.limit
+        limit: this.reservationStore.get(connection.remotePeer)?.limit
       })
       log('sent confirmation response to %s', connection.remotePeer)
     } catch (err) {
       log.error('failed to send confirmation response to %p', connection.remotePeer, err)
-      await this.reservationStore.removeReservation(connection.remotePeer)
+      this.reservationStore.removeReservation(connection.remotePeer)
     }
   }
 
@@ -325,7 +326,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       return
     }
 
-    if (!await this.reservationStore.hasReservation(dstPeer)) {
+    if (!this.reservationStore.hasReservation(dstPeer)) {
       log.error('hop connect denied for destination peer %p not having a reservation for %p with status %s', dstPeer, connection.remotePeer, Status.NO_RESERVATION)
       hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
       return
@@ -368,7 +369,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
     const sourceStream = stream.unwrap()
 
     log('connection from %p to %p established - merging streans', connection.remotePeer, dstPeer)
-    const limit = (await this.reservationStore.get(dstPeer))?.limit
+    const limit = this.reservationStore.get(dstPeer)?.limit
     // Short circuit the two streams to create the relayed connection
     createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, limit)
   }
@@ -408,7 +409,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
     stream.close()
   }
 
-  get reservations () {
+  get reservations (): PeerMap<RelayReservation> {
     return this.reservationStore.reservations
   }
 }
diff --git a/src/circuit/transport/index.ts b/src/circuit/transport/index.ts
index de108f56f2..a76e320fc8 100644
--- a/src/circuit/transport/index.ts
+++ b/src/circuit/transport/index.ts
@@ -143,7 +143,7 @@ class CircuitRelayTransport implements Transport {
     return true
   }
 
-  get [Symbol.toStringTag] () {
+  get [Symbol.toStringTag] (): 'libp2p/circuit-relay-v2' {
     return 'libp2p/circuit-relay-v2'
   }
 
@@ -208,7 +208,7 @@ class CircuitRelayTransport implements Transport {
       destinationAddr, relayAddr, ma,
       disconnectOnFailure
     }: ConnectOptions
-  ) {
+  ): Promise<Connection> {
     try {
       const pbstr = pbStream(stream)
       const hopstr = pbstr.pb(HopMessage)
diff --git a/src/circuit/utils.ts b/src/circuit/utils.ts
index 10e4d2ba89..68a920d8a1 100644
--- a/src/circuit/utils.ts
+++ b/src/circuit/utils.ts
@@ -37,7 +37,7 @@ async function * countStreamBytes (source: Source<Uint8Array | Uint8ArrayList>,
 }
 
 const doRelay = (src: Stream, dst: Stream, abortSignal: AbortSignal, limit: Required<Limit>): void => {
-  function abortStreams (err: Error) {
+  function abortStreams (err: Error): void {
     src.abort(err)
     dst.abort(err)
     clearTimeout(timeout)
diff --git a/src/components.ts b/src/components.ts
index e0f732cd8c..ee60acbc92 100644
--- a/src/components.ts
+++ b/src/components.ts
@@ -91,11 +91,11 @@ export class DefaultComponents implements Components, Startable {
     this._dialer = init.dialer
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this._started
   }
 
-  async beforeStart () {
+  async beforeStart (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.beforeStart != null) {
@@ -105,7 +105,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async start () {
+  async start (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         await startable.start()
@@ -115,7 +115,7 @@ export class DefaultComponents implements Components, Startable {
     this._started = true
   }
 
-  async afterStart () {
+  async afterStart (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.afterStart != null) {
@@ -125,7 +125,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async beforeStop () {
+  async beforeStop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.beforeStop != null) {
@@ -135,7 +135,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         await startable.stop()
@@ -145,7 +145,7 @@ export class DefaultComponents implements Components, Startable {
     this._started = false
   }
 
-  async afterStop () {
+  async afterStop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.afterStop != null) {
diff --git a/src/connection-manager/auto-dialler.ts b/src/connection-manager/auto-dialler.ts
index 46fda1faf3..f35337a65e 100644
--- a/src/connection-manager/auto-dialler.ts
+++ b/src/connection-manager/auto-dialler.ts
@@ -58,14 +58,14 @@ export class AutoDialler implements Startable {
     log('options: %j', this.options)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Starts the auto dialer
    */
-  async start () {
+  async start (): Promise<void> {
     if (!this.options.enabled) {
       log('not enabled')
       return
@@ -83,7 +83,7 @@ export class AutoDialler implements Startable {
   /**
    * Stops the auto dialler
    */
-  async stop () {
+  async stop (): Promise<void> {
     if (!this.options.enabled) {
       log('not enabled')
       return
@@ -98,7 +98,7 @@ export class AutoDialler implements Startable {
     log('stopped')
   }
 
-  async _autoDial () {
+  async _autoDial (): Promise<void> {
     if (this.autoDialTimeout != null) {
       this.autoDialTimeout.clear()
     }
diff --git a/src/connection-manager/dialer/dial-request.ts b/src/connection-manager/dialer/dial-request.ts
index 77d1a306a9..d0034518b3 100644
--- a/src/connection-manager/dialer/dial-request.ts
+++ b/src/connection-manager/dialer/dial-request.ts
@@ -138,7 +138,7 @@ export class DialRequest {
           c.abort()
         }
       })
-      tokens.forEach(token => this.dialer.releaseToken(token)) // release tokens back to the dialer
+      tokens.forEach(token => { this.dialer.releaseToken(token) }) // release tokens back to the dialer
     }
   }
 }
diff --git a/src/connection-manager/dialer/index.ts b/src/connection-manager/dialer/index.ts
index fc1365b303..a7ec43ca62 100644
--- a/src/connection-manager/dialer/index.ts
+++ b/src/connection-manager/dialer/index.ts
@@ -117,18 +117,18 @@ export class DefaultDialer implements Startable, Dialer {
     }
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.started = true
   }
 
   /**
    * Clears any pending dials
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
 
     for (const dial of this.pendingDials.values()) {
@@ -367,14 +367,14 @@ export class DefaultDialer implements Startable, Dialer {
     return pendingDial
   }
 
-  getTokens (num: number) {
+  getTokens (num: number): number[] {
     const total = Math.min(num, this.maxDialsPerPeer, this.tokens.length)
     const tokens = this.tokens.splice(0, total)
     log('%d tokens request, returning %d, %d remaining', num, total, this.tokens.length)
     return tokens
   }
 
-  releaseToken (token: number) {
+  releaseToken (token: number): void {
     // Guard against duplicate releases
     if (this.tokens.includes(token)) {
       return
diff --git a/src/connection-manager/index.ts b/src/connection-manager/index.ts
index c22e59ec5b..c09929ecb4 100644
--- a/src/connection-manager/index.ts
+++ b/src/connection-manager/index.ts
@@ -211,7 +211,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.incomingPendingConnections = 0
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
@@ -219,7 +219,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
    * Starts the Connection Manager. If Metrics are not enabled on libp2p
    * only event loop and connection limits will be monitored.
    */
-  async start () {
+  async start (): Promise<void> {
     // track inbound/outbound connections
     this.components.metrics?.registerMetricGroup('libp2p_connection_manager_connections', {
       calculate: () => {
@@ -307,7 +307,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     log('started')
   }
 
-  async afterStart () {
+  async afterStart (): Promise<void> {
     this.components.upgrader.addEventListener('connection', this.onConnect)
     this.components.upgrader.addEventListener('connectionEnd', this.onDisconnect)
 
@@ -352,7 +352,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       })
   }
 
-  async beforeStop () {
+  async beforeStop (): Promise<void> {
     // if we are still dialing KEEP_ALIVE peers, abort those dials
     this.connectOnStartupController?.abort()
     this.components.upgrader.removeEventListener('connection', this.onConnect)
@@ -362,7 +362,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   /**
    * Stops the Connection Manager
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.latencyMonitor?.removeEventListener('data', this._onLatencyMeasure)
     this.latencyMonitor?.stop()
 
@@ -374,7 +374,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   /**
    * Cleans up the connections
    */
-  async _close () {
+  async _close (): Promise<void> {
     // Close all connections we're tracking
     const tasks: Array<Promise<void>> = []
     for (const connectionList of this.connections.values()) {
@@ -394,7 +394,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.connections.clear()
   }
 
-  onConnect (evt: CustomEvent<Connection>) {
+  onConnect (evt: CustomEvent<Connection>): void {
     void this._onConnect(evt).catch(err => {
       log.error(err)
     })
@@ -403,7 +403,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   /**
    * Tracks the incoming connection and check the connection limit
    */
-  async _onConnect (evt: CustomEvent<Connection>) {
+  async _onConnect (evt: CustomEvent<Connection>): Promise<void> {
     const { detail: connection } = evt
 
     if (!this.started) {
@@ -436,7 +436,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   /**
    * Removes the connection from tracking
    */
-  onDisconnect (evt: CustomEvent<Connection>) {
+  onDisconnect (evt: CustomEvent<Connection>): void {
     const { detail: connection } = evt
 
     if (!this.started) {
@@ -542,7 +542,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     await Promise.all(
       connections.map(async connection => {
-        return await connection.close()
+        await connection.close()
       })
     )
   }
@@ -569,7 +569,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   /**
    * If the event loop is slow, maybe close a connection
    */
-  _onLatencyMeasure (evt: CustomEvent<SummaryObject>) {
+  _onLatencyMeasure (evt: CustomEvent<SummaryObject>): void {
     const { detail: summary } = evt
 
     this._checkMaxLimit('maxEventLoopDelay', summary.avgMs, 1)
@@ -581,7 +581,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   /**
    * If the `value` of `name` has exceeded its limit, maybe close a connection
    */
-  async _checkMaxLimit (name: keyof ConnectionManagerInit, value: number, toPrune: number = 1) {
+  async _checkMaxLimit (name: keyof ConnectionManagerInit, value: number, toPrune: number = 1): Promise<void> {
     const limit = this.opts[name]
 
     if (limit == null) {
@@ -600,7 +600,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
    * If we have more connections than our maximum, select some excess connections
    * to prune based on peer value
    */
-  async _pruneConnections (toPrune: number) {
+  async _pruneConnections (toPrune: number): Promise<void> {
     const connections = this.getConnections()
     const peerValues = new PeerMap<number>()
 
@@ -726,7 +726,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     return false
   }
 
-  afterUpgradeInbound () {
+  afterUpgradeInbound (): void {
     this.incomingPendingConnections--
   }
 }
diff --git a/src/connection-manager/latency-monitor.ts b/src/connection-manager/latency-monitor.ts
index 3d975cc8fd..9f45770be6 100644
--- a/src/connection-manager/latency-monitor.ts
+++ b/src/connection-manager/latency-monitor.ts
@@ -148,7 +148,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
     this.latencyData = this.initLatencyData()
   }
 
-  start () {
+  start (): void {
     // We check for isBrowser because of browsers set max rates of timeouts when a page is hidden,
     // so we fall back to another library
     // See: http://stackoverflow.com/questions/6032429/chrome-timeouts-interval-suspended-in-background-tabs
@@ -172,7 +172,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
     }
   }
 
-  stop () {
+  stop (): void {
     this._stopTimers()
   }
 
@@ -181,7 +181,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
    *
    * @private
    */
-  _startTimers () {
+  _startTimers (): void {
     // Timer already started, ignore this
     if (this.checkLatencyID != null) {
       return
@@ -190,7 +190,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
     this.checkLatency()
 
     if (this.dataEmitIntervalMs != null) {
-      this.emitIntervalID = setInterval(() => this._emitSummary(), this.dataEmitIntervalMs)
+      this.emitIntervalID = setInterval(() => { this._emitSummary() }, this.dataEmitIntervalMs)
       if (typeof this.emitIntervalID.unref === 'function') {
         this.emitIntervalID.unref() // Doesn't block exit
       }
@@ -202,7 +202,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
    *
    * @private
    */
-  _stopTimers () {
+  _stopTimers (): void {
     if (this.checkLatencyID != null) {
       clearTimeout(this.checkLatencyID)
       this.checkLatencyID = undefined
@@ -218,7 +218,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
    *
    * @private
    */
-  _emitSummary () {
+  _emitSummary (): void {
     const summary = this.getSummary()
     if (summary.events > 0) {
       this.dispatchEvent(new CustomEvent<SummaryObject>('data', {
@@ -254,7 +254,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
    * Randomly calls an async fn every roughly latencyCheckIntervalMs (plus some randomness). If no async fn is found,
    * it will simply report on event loop latency.
    */
-  checkLatency () {
+  checkLatency (): void {
     // Randomness is needed to avoid alignment by accident to regular things in the event loop
     const randomness = (Math.random() * this.latencyCheckMultiply) - this.latencyCheckSubtract
 
@@ -264,7 +264,7 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
       startTime: this.now()
     }
 
-    const cb = () => {
+    const cb = (): void => {
       // We are already stopped, ignore this datapoint
       if (this.checkLatencyID == null) {
         return
@@ -314,6 +314,6 @@ export class LatencyMonitor extends EventEmitter<LatencyMonitorEvents> {
   }
 }
 
-function isBrowser () {
+function isBrowser (): boolean {
   return typeof globalThis.window !== 'undefined'
 }
diff --git a/src/connection-manager/visibility-change-emitter.ts b/src/connection-manager/visibility-change-emitter.ts
index 1e0d2ab61e..3c103e28f2 100644
--- a/src/connection-manager/visibility-change-emitter.ts
+++ b/src/connection-manager/visibility-change-emitter.ts
@@ -60,7 +60,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    *
    * @private
    */
-  _initializeVisibilityVarNames () {
+  _initializeVisibilityVarNames (): void {
     let hidden: Hidden = 'hidden'
     let visibilityChange = 'visibilitychange'
 
@@ -91,7 +91,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    *
    * @private
    */
-  _addVisibilityChangeListener () {
+  _addVisibilityChangeListener (): void {
     // @ts-expect-error cannot index document object with string key
     if (typeof globalThis.document.addEventListener === 'undefined' || typeof document[this.hidden] === 'undefined') {
       log('Checking page visibility requires a browser that supports the Page Visibility API.')
@@ -105,7 +105,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    * The function returns ```true``` if the page is visible or ```false``` if the page is not visible and
    * ```undefined``` if the page visibility API is not supported by the browser.
    */
-  isVisible () {
+  isVisible (): boolean | undefined {
     // @ts-expect-error cannot index document object with string key
     if (this.hidden === undefined || document[this.hidden] === undefined) {
       return undefined
@@ -122,7 +122,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    *
    * @private
    */
-  _handleVisibilityChange () {
+  _handleVisibilityChange (): void {
     // @ts-expect-error cannot index document object with string key
     const visible = globalThis.document[this.hidden] === false
     log(visible ? 'Page Visible' : 'Page Hidden')
diff --git a/src/connection/index.ts b/src/connection/index.ts
index 953ca3bcb1..7d73e6130e 100644
--- a/src/connection/index.ts
+++ b/src/connection/index.ts
@@ -87,18 +87,18 @@ export class ConnectionImpl implements Connection {
     this._closing = false
   }
 
-  get [Symbol.toStringTag] () {
+  get [Symbol.toStringTag] (): 'Connection' {
     return 'Connection'
   }
 
-  get [symbol] () {
+  get [symbol] (): true {
     return true
   }
 
   /**
    * Get all the streams of the muxer
    */
-  get streams () {
+  get streams (): Stream[] {
     return this._getStreams()
   }
 
@@ -128,21 +128,21 @@ export class ConnectionImpl implements Connection {
   /**
    * Add a stream when it is opened to the registry
    */
-  addStream (stream: Stream) {
+  addStream (stream: Stream): void {
     stream.stat.direction = 'inbound'
   }
 
   /**
    * Remove stream registry after it is closed
    */
-  removeStream (id: string) {
+  removeStream (id: string): void {
 
   }
 
   /**
    * Close the connection
    */
-  async close () {
+  async close (): Promise<void> {
     if (this.stat.status === CLOSED || this._closing) {
       return
     }
@@ -151,7 +151,7 @@ export class ConnectionImpl implements Connection {
 
     // close all streams - this can throw if we're not multiplexed
     try {
-      this.streams.forEach(s => s.close())
+      this.streams.forEach(s => { s.close() })
     } catch (err) {
       log.error(err)
     }
diff --git a/src/content-routing/index.ts b/src/content-routing/index.ts
index 0834100048..f1cedcef73 100644
--- a/src/content-routing/index.ts
+++ b/src/content-routing/index.ts
@@ -14,6 +14,8 @@ import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats/cid'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { DualDHT } from '@libp2p/interface-dht'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 export interface CompoundContentRoutingInit {
   routers: ContentRouting[]
@@ -35,22 +37,22 @@ export class CompoundContentRouting implements ContentRouting, Startable {
     this.components = components
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.started = true
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
   }
 
   /**
    * Iterates over all content routers in parallel to find providers of the given key
    */
-  async * findProviders (key: CID, options: AbortOptions = {}) {
+  async * findProviders (key: CID, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
       throw errCode(new Error('No content this.routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
     }
@@ -69,18 +71,18 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    * Iterates over all content routers in parallel to notify it is
    * a provider of the given key
    */
-  async provide (key: CID, options: AbortOptions = {}) {
+  async provide (key: CID, options: AbortOptions = {}): Promise<void> {
     if (this.routers.length === 0) {
       throw errCode(new Error('No content routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
-    await Promise.all(this.routers.map(async (router) => await router.provide(key, options)))
+    await Promise.all(this.routers.map(async (router) => { await router.provide(key, options) }))
   }
 
   /**
    * Store the given key/value pair in the available content routings
    */
-  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions) {
+  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
     if (!this.isStarted()) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
@@ -117,7 +119,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
   /**
    * Get the `n` values to the given key without sorting
    */
-  async * getMany (key: Uint8Array, nVals: number, options: AbortOptions) { // eslint-disable-line require-await
+  async * getMany (key: Uint8Array, nVals: number, options: AbortOptions): AsyncIterable<{ from: PeerId, val: Uint8Array }> {
     if (!this.isStarted()) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
diff --git a/src/content-routing/utils.ts b/src/content-routing/utils.ts
index bc6fa84b92..70832688e8 100644
--- a/src/content-routing/utils.ts
+++ b/src/content-routing/utils.ts
@@ -8,7 +8,7 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 /**
  * Store the multiaddrs from every peer in the passed peer store
  */
-export async function * storeAddresses (source: Source<PeerInfo>, peerStore: PeerStore) {
+export async function * storeAddresses (source: Source<PeerInfo>, peerStore: PeerStore): AsyncIterable<PeerInfo> {
   yield * map(source, async (peer) => {
     // ensure we have the addresses for a given peer
     await peerStore.addressBook.add(peer.id, peer.multiaddrs)
@@ -20,7 +20,7 @@ export async function * storeAddresses (source: Source<PeerInfo>, peerStore: Pee
 /**
  * Filter peers by unique peer id
  */
-export function uniquePeers (source: Source<PeerInfo>) {
+export function uniquePeers (source: Source<PeerInfo>): AsyncIterable<PeerInfo> {
   /** @type Set<string> */
   const seen = new Set()
 
@@ -39,7 +39,7 @@ export function uniquePeers (source: Source<PeerInfo>) {
 /**
  * Require at least `min` peers to be yielded from `source`
  */
-export async function * requirePeers (source: Source<PeerInfo>, min: number = 1) {
+export async function * requirePeers (source: Source<PeerInfo>, min: number = 1): AsyncIterable<PeerInfo> {
   let seen = 0
 
   for await (const peer of source) {
diff --git a/src/dht/dht-content-routing.ts b/src/dht/dht-content-routing.ts
index f520db4546..de9f77726c 100644
--- a/src/dht/dht-content-routing.ts
+++ b/src/dht/dht-content-routing.ts
@@ -4,6 +4,7 @@ import type { DHT } from '@libp2p/interface-dht'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { CID } from 'multiformats/cid'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 
 /**
  * Wrapper class to convert events into returned values
@@ -15,11 +16,11 @@ export class DHTContentRouting implements ContentRouting {
     this.dht = dht
   }
 
-  async provide (cid: CID) {
+  async provide (cid: CID): Promise<void> {
     await drain(this.dht.provide(cid))
   }
 
-  async * findProviders (cid: CID, options: AbortOptions = {}) {
+  async * findProviders (cid: CID, options: AbortOptions = {}): AsyncGenerator<PeerInfo, void, undefined> {
     for await (const event of this.dht.findProviders(cid, options)) {
       if (event.name === 'PROVIDER') {
         yield * event.providers
diff --git a/src/dht/dht-peer-routing.ts b/src/dht/dht-peer-routing.ts
index e1d5ddafb3..fe7e3580f8 100644
--- a/src/dht/dht-peer-routing.ts
+++ b/src/dht/dht-peer-routing.ts
@@ -4,6 +4,7 @@ import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { DHT } from '@libp2p/interface-dht'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 
 /**
  * Wrapper class to convert events into returned values
@@ -15,7 +16,7 @@ export class DHTPeerRouting implements PeerRouting {
     this.dht = dht
   }
 
-  async findPeer (peerId: PeerId, options: AbortOptions = {}) {
+  async findPeer (peerId: PeerId, options: AbortOptions = {}): Promise<PeerInfo> {
     for await (const event of this.dht.findPeer(peerId, options)) {
       if (event.name === 'FINAL_PEER') {
         return event.peer
@@ -25,7 +26,7 @@ export class DHTPeerRouting implements PeerRouting {
     throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
   }
 
-  async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}) {
+  async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
     for await (const event of this.dht.getClosestPeers(key, options)) {
       if (event.name === 'FINAL_PEER') {
         yield event.peer
diff --git a/src/dht/dummy-dht.ts b/src/dht/dummy-dht.ts
index 3f37be345e..e2f06526fe 100644
--- a/src/dht/dummy-dht.ts
+++ b/src/dht/dummy-dht.ts
@@ -10,7 +10,7 @@ export class DummyDHT extends EventEmitter<PeerDiscoveryEvents> implements DualD
     return true
   }
 
-  get [Symbol.toStringTag] () {
+  get [Symbol.toStringTag] (): '@libp2p/dummy-dht' {
     return '@libp2p/dummy-dht'
   }
 
diff --git a/src/fetch/index.ts b/src/fetch/index.ts
index 08d8a3e973..7ab75508ba 100644
--- a/src/fetch/index.ts
+++ b/src/fetch/index.ts
@@ -67,7 +67,7 @@ export class FetchService implements Startable {
     this.init = init
   }
 
-  async start () {
+  async start (): Promise<void> {
     await this.components.registrar.handle(this.protocol, (data) => {
       void this.handleMessage(data)
         .catch(err => {
@@ -83,12 +83,12 @@ export class FetchService implements Startable {
     this.started = true
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await this.components.registrar.unhandle(this.protocol)
     this.started = false
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
@@ -178,7 +178,7 @@ export class FetchService implements Startable {
    * responds based on looking up the key in the request via the lookup callback that corresponds
    * to the key's prefix.
    */
-  async handleMessage (data: IncomingStreamData) {
+  async handleMessage (data: IncomingStreamData): Promise<void> {
     const { stream } = data
     const self = this
 
@@ -224,7 +224,7 @@ export class FetchService implements Startable {
    * Given a key, finds the appropriate function for looking up its corresponding value, based on
    * the key's prefix.
    */
-  _getLookupFunction (key: string) {
+  _getLookupFunction (key: string): LookupFunction | undefined {
     for (const prefix of this.lookupFunctions.keys()) {
       if (key.startsWith(prefix)) {
         return this.lookupFunctions.get(prefix)
@@ -243,7 +243,7 @@ export class FetchService implements Startable {
    * libp2p.fetchService.registerLookupFunction('/prefix', (key) => { ... })
    * ```
    */
-  registerLookupFunction (prefix: string, lookup: LookupFunction) {
+  registerLookupFunction (prefix: string, lookup: LookupFunction): void {
     if (this.lookupFunctions.has(prefix)) {
       throw errCode(new Error("Fetch protocol handler for key prefix '" + prefix + "' already registered"), codes.ERR_KEY_ALREADY_EXISTS)
     }
@@ -262,7 +262,7 @@ export class FetchService implements Startable {
    * libp2p.fetchService.unregisterLookupFunction('/prefix')
    * ```
    */
-  unregisterLookupFunction (prefix: string, lookup?: LookupFunction) {
+  unregisterLookupFunction (prefix: string, lookup?: LookupFunction): void {
     if (lookup != null) {
       const existingLookup = this.lookupFunctions.get(prefix)
 
diff --git a/src/identify/index.ts b/src/identify/index.ts
index 6c01b23252..410b69ad5f 100644
--- a/src/identify/index.ts
+++ b/src/identify/index.ts
@@ -4,7 +4,7 @@ import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { multiaddr, protocols } from '@multiformats/multiaddr'
+import { Multiaddr, multiaddr, protocols } from '@multiformats/multiaddr'
 import { Identify } from './pb/message.js'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import {
@@ -112,7 +112,7 @@ export class IdentifyService implements Startable {
       const { peerId } = evt.detail
 
       if (this.components.peerId.equals(peerId)) {
-        void this.pushToPeerStore().catch(err => log.error(err))
+        void this.pushToPeerStore().catch(err => { log.error(err) })
       }
     })
 
@@ -121,16 +121,16 @@ export class IdentifyService implements Startable {
       const { peerId } = evt.detail
 
       if (this.components.peerId.equals(peerId)) {
-        void this.pushToPeerStore().catch(err => log.error(err))
+        void this.pushToPeerStore().catch(err => { log.error(err) })
       }
     })
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     if (this.started) {
       return
     }
@@ -158,7 +158,7 @@ export class IdentifyService implements Startable {
     this.started = true
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await this.components.registrar.unhandle(this.identifyProtocolStr)
     await this.components.registrar.unhandle(this.identifyPushProtocolStr)
 
@@ -216,7 +216,7 @@ export class IdentifyService implements Startable {
   /**
    * Calls `push` on all peer connections
    */
-  async pushToPeerStore () {
+  async pushToPeerStore (): Promise<void> {
     // Do not try to push if we are not running
     if (!this.isStarted()) {
       return
@@ -388,7 +388,7 @@ export class IdentifyService implements Startable {
    * Sends the `Identify` response with the Signed Peer Record
    * to the requesting peer over the given `connection`
    */
-  async _handleIdentify (data: IncomingStreamData) {
+  async _handleIdentify (data: IncomingStreamData): Promise<void> {
     const { connection, stream } = data
     const timeoutController = new TimeoutController(this.init.timeout)
 
@@ -440,7 +440,7 @@ export class IdentifyService implements Startable {
   /**
    * Reads the Identify Push message from the given `connection`
    */
-  async _handlePush (data: IncomingStreamData) {
+  async _handlePush (data: IncomingStreamData): Promise<void> {
     const { connection, stream } = data
     const timeoutController = new TimeoutController(this.init.timeout)
 
@@ -467,14 +467,16 @@ export class IdentifyService implements Startable {
         message = Identify.decode(data)
       }
     } catch (err: any) {
-      return log.error('received invalid message', err)
+      log.error('received invalid message', err)
+      return
     } finally {
       stream.close()
       timeoutController.clear()
     }
 
     if (message == null) {
-      return log.error('received invalid message')
+      log.error('received invalid message')
+      return
     }
 
     const id = connection.remotePeer
@@ -509,8 +511,7 @@ export class IdentifyService implements Startable {
 
     // LEGACY: Update peers data in PeerStore
     try {
-      await this.components.peerStore.addressBook.set(id,
-        message.listenAddrs.map((addr) => multiaddr(addr)))
+      await this.components.peerStore.addressBook.set(id, message.listenAddrs.map((addr) => multiaddr(addr)))
     } catch (err: any) {
       log.error('received invalid addrs', err)
     }
@@ -528,7 +529,7 @@ export class IdentifyService implements Startable {
   /**
    * Takes the `addr` and converts it to a Multiaddr if possible
    */
-  static getCleanMultiaddr (addr: Uint8Array | string | null | undefined) {
+  static getCleanMultiaddr (addr: Uint8Array | string | null | undefined): Multiaddr | undefined {
     if (addr != null && addr.length > 0) {
       try {
         return multiaddr(addr)
diff --git a/src/insecure/index.ts b/src/insecure/index.ts
index a161446919..b5e7e8c56e 100644
--- a/src/insecure/index.ts
+++ b/src/insecure/index.ts
@@ -32,11 +32,12 @@ import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
 import type { Duplex } from 'it-stream-types'
 import map from 'it-map'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 const log = logger('libp2p:plaintext')
 const PROTOCOL = '/plaintext/2.0.0'
 
-function lpEncodeExchange (exchange: Exchange) {
+function lpEncodeExchange (exchange: Exchange): Uint8ArrayList {
   const pb = Exchange.encode(exchange)
 
   return lp.encode.single(pb)
diff --git a/src/libp2p.ts b/src/libp2p.ts
index 7fce47690d..f586dc84f5 100644
--- a/src/libp2p.ts
+++ b/src/libp2p.ts
@@ -25,7 +25,7 @@ import { DHTContentRouting } from './dht/dht-content-routing.js'
 import { DefaultComponents } from './components.js'
 import type { Components } from './components.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Connection } from '@libp2p/interface-connection'
+import type { Connection, Stream } from '@libp2p/interface-connection'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { PubSub } from '@libp2p/interface-pubsub'
@@ -260,7 +260,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   /**
    * Starts the libp2p node and all its subsystems
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.started) {
       return
     }
@@ -287,7 +287,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
 
       // start any startables
       await Promise.all(
-        this.services.map(async service => await service.start())
+        this.services.map(async service => { await service.start() })
       )
 
       await Promise.all(
@@ -309,7 +309,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   /**
    * Stop the libp2p node by closing its listeners and open connections
    */
-  async stop () {
+  async stop (): Promise<void> {
     if (!this.started) {
       return
     }
@@ -327,7 +327,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     )
 
     await Promise.all(
-      this.services.map(async service => await service.stop())
+      this.services.map(async service => { await service.stop() })
     )
 
     await Promise.all(
@@ -341,7 +341,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     log('libp2p has stopped')
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
@@ -363,7 +363,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return await this.components.connectionManager.openConnection(peer, options)
   }
 
-  async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}) {
+  async dialProtocol (peer: PeerId | Multiaddr, protocols: string | string[], options: AbortOptions = {}): Promise<Stream> {
     if (protocols == null) {
       throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
     }
@@ -482,7 +482,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return await this.registrar.register(protocol, topology)
   }
 
-  unregister (id: string) {
+  unregister (id: string): void {
     this.registrar.unregister(id)
   }
 
@@ -490,7 +490,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
    * Called whenever peer discovery services emit `peer` events.
    * Known peers may be emitted.
    */
-  onDiscoveryPeer (evt: CustomEvent<PeerInfo>) {
+  onDiscoveryPeer (evt: CustomEvent<PeerInfo>): void {
     const { detail: peer } = evt
 
     if (peer.id.toString() === this.peerId.toString()) {
@@ -499,11 +499,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     }
 
     if (peer.multiaddrs.length > 0) {
-      void this.components.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => log.error(err))
+      void this.components.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => { log.error(err) })
     }
 
     if (peer.protocols.length > 0) {
-      void this.components.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => log.error(err))
+      void this.components.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => { log.error(err) })
     }
 
     this.dispatchEvent(new CustomEvent<PeerInfo>('peer:discovery', { detail: peer }))
diff --git a/src/nat-manager.ts b/src/nat-manager.ts
index 2486ee23c7..13c859973c 100644
--- a/src/nat-manager.ts
+++ b/src/nat-manager.ts
@@ -15,7 +15,7 @@ import type { AddressManager } from '@libp2p/interface-address-manager'
 const log = logger('libp2p:nat')
 const DEFAULT_TTL = 7200
 
-function highPort (min = 1024, max = 65535) {
+function highPort (min = 1024, max = 65535): number {
   return Math.floor(Math.random() * (max - min + 1) + min)
 }
 
@@ -98,18 +98,20 @@ export class NatManager implements Startable {
     }
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  start () {}
+  start (): void {
+    // #TODO: is there a way to remove this? Seems like a hack
+  }
 
   /**
    * Attempt to use uPnP to configure port mapping using the current gateway.
    *
    * Run after start to ensure the transport manager has all addresses configured.
    */
-  afterStart () {
+  afterStart (): void {
     if (isBrowser || !this.enabled || this.started) {
       return
     }
@@ -123,7 +125,7 @@ export class NatManager implements Startable {
     })
   }
 
-  async _start () {
+  async _start (): Promise<void> {
     const addrs = this.components.transportManager.getAddrs()
 
     for (const addr of addrs) {
@@ -178,7 +180,7 @@ export class NatManager implements Startable {
     }
   }
 
-  async _getClient () {
+  async _getClient (): Promise<NatAPI> {
     if (this.client != null) {
       return this.client
     }
@@ -196,7 +198,7 @@ export class NatManager implements Startable {
   /**
    * Stops the NAT manager
    */
-  async stop () {
+  async stop (): Promise<void> {
     if (isBrowser || this.client == null) {
       return
     }
diff --git a/src/peer-record-updater.ts b/src/peer-record-updater.ts
index d93c69c63d..64f2f2f7bb 100644
--- a/src/peer-record-updater.ts
+++ b/src/peer-record-updater.ts
@@ -26,18 +26,18 @@ export class PeerRecordUpdater implements Startable {
     this.update = this.update.bind(this)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.started = true
     this.components.transportManager.addEventListener('listener:listening', this.update)
     this.components.transportManager.addEventListener('listener:close', this.update)
     this.components.addressManager.addEventListener('change:addresses', this.update)
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
     this.components.transportManager.removeEventListener('listener:listening', this.update)
     this.components.transportManager.removeEventListener('listener:close', this.update)
@@ -47,7 +47,7 @@ export class PeerRecordUpdater implements Startable {
   /**
    * Create (or update if existing) self peer record and store it in the AddressBook.
    */
-  update () {
+  update (): void {
     Promise.resolve()
       .then(async () => {
         const peerRecord = new PeerRecord({
diff --git a/src/peer-routing.ts b/src/peer-routing.ts
index 23eb1a2c7c..6e5246e6a3 100644
--- a/src/peer-routing.ts
+++ b/src/peer-routing.ts
@@ -76,14 +76,14 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
     this._findClosestPeersTask = this._findClosestPeersTask.bind(this)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
   /**
    * Start peer routing service.
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.started || this.routers.length === 0 || this.timeoutId != null || this.refreshManagerInit.enabled === false) {
       return
     }
@@ -98,7 +98,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
   /**
    * Recurrent task to find closest peers and add their addresses to the Address Book.
    */
-  async _findClosestPeersTask () {
+  async _findClosestPeersTask (): Promise<void> {
     if (this.abortController != null) {
       // we are already running the query
       return
@@ -127,7 +127,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
   /**
    * Stop peer routing service.
    */
-  async stop () {
+  async stop (): Promise<void> {
     clearDelayedInterval(this.timeoutId)
 
     // abort query if it is in-flight
diff --git a/src/ping/index.ts b/src/ping/index.ts
index 6e25da93f9..35f665e97a 100644
--- a/src/ping/index.ts
+++ b/src/ping/index.ts
@@ -47,7 +47,7 @@ export class PingService implements Startable {
     this.init = init
   }
 
-  async start () {
+  async start (): Promise<void> {
     await this.components.registrar.handle(this.protocol, this.handleMessage, {
       maxInboundStreams: this.init.maxInboundStreams,
       maxOutboundStreams: this.init.maxOutboundStreams
@@ -55,19 +55,19 @@ export class PingService implements Startable {
     this.started = true
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await this.components.registrar.unhandle(this.protocol)
     this.started = false
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
   /**
    * A handler to register with Libp2p to process ping messages
    */
-  handleMessage (data: IncomingStreamData) {
+  handleMessage (data: IncomingStreamData): void {
     const { stream } = data
 
     void pipe(stream, stream)
diff --git a/src/pnet/crypto.ts b/src/pnet/crypto.ts
index ffc6b17d5d..f9f4e69938 100644
--- a/src/pnet/crypto.ts
+++ b/src/pnet/crypto.ts
@@ -11,7 +11,7 @@ const log = logger('libp2p:pnet')
 /**
  * Creates a stream iterable to encrypt messages in a private network
  */
-export function createBoxStream (nonce: Uint8Array, psk: Uint8Array) {
+export function createBoxStream (nonce: Uint8Array, psk: Uint8Array): (source: Source<Uint8Array>) => AsyncIterable<Uint8Array> {
   const xor = xsalsa20(nonce, psk)
 
   return (source: Source<Uint8Array>) => (async function * () {
@@ -38,7 +38,7 @@ export function createUnboxStream (nonce: Uint8Array, psk: Uint8Array) {
 /**
  * Decode the version 1 psk from the given Uint8Array
  */
-export function decodeV1PSK (pskBuffer: Uint8Array) {
+export function decodeV1PSK (pskBuffer: Uint8Array): { tag: string | undefined, codecName: string | undefined, psk: Uint8Array } {
   try {
     // This should pull from multibase/multicodec to allow for
     // more encoding flexibility. Ideally we'd consume the codecs
@@ -58,7 +58,7 @@ export function decodeV1PSK (pskBuffer: Uint8Array) {
     return {
       tag: pskTag,
       codecName: codec,
-      psk: psk
+      psk
     }
   } catch (err: any) {
     log.error(err)
diff --git a/src/pnet/key-generator.ts b/src/pnet/key-generator.ts
index dd0ba7ddd5..15462bc0b7 100644
--- a/src/pnet/key-generator.ts
+++ b/src/pnet/key-generator.ts
@@ -8,7 +8,7 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
  * @param {Uint8Array | NodeJS.WriteStream} bytes - An object to write the psk into
  * @returns {void}
  */
-export function generateKey (bytes: Uint8Array | NodeJS.WriteStream) {
+export function generateKey (bytes: Uint8Array | NodeJS.WriteStream): void {
   const psk = uint8ArrayToString(randomBytes(KEY_LENGTH), 'base16')
   const key = uint8ArrayFromString('/key/swarm/psk/1.0.0/\n/base16/\n' + psk)
 
diff --git a/src/registrar.ts b/src/registrar.ts
index 75121edc04..b41c14174b 100644
--- a/src/registrar.ts
+++ b/src/registrar.ts
@@ -44,14 +44,14 @@ export class DefaultRegistrar implements Registrar {
     this.components.peerStore.addEventListener('change:protocols', this._onProtocolChange)
   }
 
-  getProtocols () {
+  getProtocols (): string[] {
     return Array.from(new Set<string>([
       ...this.topologies.keys(),
       ...this.handlers.keys()
     ])).sort()
   }
 
-  getHandler (protocol: string) {
+  getHandler (protocol: string): StreamHandlerRecord {
     const handler = this.handlers.get(protocol)
 
     if (handler == null) {
@@ -61,7 +61,7 @@ export class DefaultRegistrar implements Registrar {
     return handler
   }
 
-  getTopologies (protocol: string) {
+  getTopologies (protocol: string): Topology[] {
     const topologies = this.topologies.get(protocol)
 
     if (topologies == null) {
@@ -99,7 +99,7 @@ export class DefaultRegistrar implements Registrar {
    * Removes the handler for each protocol. The protocol
    * will no longer be supported on streams.
    */
-  async unhandle (protocols: string | string[]) {
+  async unhandle (protocols: string | string[]): Promise<void> {
     const protocolList = Array.isArray(protocols) ? protocols : [protocols]
 
     protocolList.forEach(protocol => {
@@ -140,7 +140,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Unregister topology
    */
-  unregister (id: string) {
+  unregister (id: string): void {
     for (const [protocol, topologies] of this.topologies.entries()) {
       if (topologies.has(id)) {
         topologies.delete(id)
@@ -155,7 +155,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Remove a disconnected peer from the record
    */
-  _onDisconnect (evt: CustomEvent<Connection>) {
+  _onDisconnect (evt: CustomEvent<Connection>): void {
     const connection = evt.detail
 
     void this.components.peerStore.protoBook.get(connection.remotePeer)
@@ -182,7 +182,7 @@ export class DefaultRegistrar implements Registrar {
    * On peer connected if we already have their protocols. Usually used for reconnects
    * as change:protocols event won't be emitted due to identical protocols.
    */
-  _onConnect (evt: CustomEvent<Connection>) {
+  _onConnect (evt: CustomEvent<Connection>): void {
     const connection = evt.detail
 
     void this.components.peerStore.protoBook.get(connection.remotePeer)
@@ -208,7 +208,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Check if a new peer support the multicodecs for this topology
    */
-  _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>) {
+  _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>): void {
     const { peerId, protocols, oldProtocols } = evt.detail
     const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
     const added = protocols.filter(protocol => !oldProtocols.includes(protocol))
diff --git a/src/transport-manager.ts b/src/transport-manager.ts
index 70092ad969..288796d1f0 100644
--- a/src/transport-manager.ts
+++ b/src/transport-manager.ts
@@ -47,7 +47,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Adds a `Transport` to the manager
    */
-  add (transport: Transport) {
+  add (transport: Transport): void {
     const tag = transport[Symbol.toStringTag]
 
     if (tag == null) {
@@ -67,11 +67,11 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     }
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     // Listen on the provided transports for the provided addresses
     const addrs = this.components.addressManager.getListenAddrs()
 
@@ -83,7 +83,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Stops all listeners
    */
-  async stop () {
+  async stop (): Promise<void> {
     const tasks = []
     for (const [key, listeners] of this.listeners) {
       log('closing listeners for %s', key)
@@ -147,14 +147,14 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Returns all the transports instances
    */
-  getTransports () {
+  getTransports (): Transport[] {
     return Array.of(...this.transports.values())
   }
 
   /**
    * Finds a transport that matches the given Multiaddr
    */
-  transportForMultiaddr (ma: Multiaddr) {
+  transportForMultiaddr (ma: Multiaddr): Transport | undefined {
     for (const transport of this.transports.values()) {
       const addrs = transport.filter([ma])
 
@@ -167,7 +167,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Starts listeners for each listen Multiaddr
    */
-  async listen (addrs: Multiaddr[]) {
+  async listen (addrs: Multiaddr[]): Promise<void> {
     if (addrs == null || addrs.length === 0) {
       log('no addresses were provided for listening, this node is dial only')
       return
@@ -243,7 +243,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
    * Removes the given transport from the manager.
    * If a transport has any running listeners, they will be closed.
    */
-  async remove (key: string) {
+  async remove (key: string): Promise<void> {
     log('removing %s', key)
 
     // Close any running listeners
@@ -261,7 +261,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
    *
    * @async
    */
-  async removeAll () {
+  async removeAll (): Promise<void> {
     const tasks = []
     for (const key of this.transports.keys()) {
       tasks.push(this.remove(key))
diff --git a/src/upgrader.ts b/src/upgrader.ts
index 8b213d9907..1b290f0dc6 100644
--- a/src/upgrader.ts
+++ b/src/upgrader.ts
@@ -54,7 +54,7 @@ export interface UpgraderInit {
   inboundUpgradeTimeout: number
 }
 
-function findIncomingStreamLimit (protocol: string, registrar: Registrar) {
+function findIncomingStreamLimit (protocol: string, registrar: Registrar): number | undefined {
   try {
     const { options } = registrar.getHandler(protocol)
 
@@ -68,7 +68,7 @@ function findIncomingStreamLimit (protocol: string, registrar: Registrar) {
   return DEFAULT_MAX_INBOUND_STREAMS
 }
 
-function findOutgoingStreamLimit (protocol: string, registrar: Registrar) {
+function findOutgoingStreamLimit (protocol: string, registrar: Registrar): number | undefined {
   try {
     const { options } = registrar.getHandler(protocol)
 
@@ -82,7 +82,7 @@ function findOutgoingStreamLimit (protocol: string, registrar: Registrar) {
   return DEFAULT_MAX_OUTBOUND_STREAMS
 }
 
-function countStreams (protocol: string, direction: 'inbound' | 'outbound', connection: Connection) {
+function countStreams (protocol: string, direction: 'inbound' | 'outbound', connection: Connection): number {
   let streamCount = 0
 
   connection.streams.forEach(stream => {
@@ -400,7 +400,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
               // If a protocol stream has been successfully negotiated and is to be passed to the application,
               // the peerstore should ensure that the peer is registered with that protocol
-              this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
+              this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => { log.error(err) })
 
               connection.addStream(muxedStream)
               this.components.metrics?.trackProtocolStream(muxedStream, connection)
@@ -457,7 +457,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
           // If a protocol stream has been successfully negotiated and is to be passed to the application,
           // the peerstore should ensure that the peer is registered with that protocol
-          this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
+          this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => { log.error(err) })
 
           // after the handshake the returned stream can have early data so override
           // the souce/sink
@@ -523,14 +523,14 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     })
     maConn.timeline.upgraded = Date.now()
 
-    const errConnectionNotMultiplexed = () => {
+    const errConnectionNotMultiplexed = (): any => {
       throw errCode(new Error('connection is not multiplexed'), codes.ERR_CONNECTION_NOT_MULTIPLEXED)
     }
 
     // Create the connection
     connection = createConnection({
       remoteAddr: maConn.remoteAddr,
-      remotePeer: remotePeer,
+      remotePeer,
       stat: {
         status: 'OPEN',
         direction,
@@ -539,7 +539,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         encryption: cryptoProtocol
       },
       newStream: newStream ?? errConnectionNotMultiplexed,
-      getStreams: () => muxer != null ? muxer.streams : errConnectionNotMultiplexed(),
+      getStreams: () => { if (muxer != null) { return muxer.streams } else { return errConnectionNotMultiplexed() } },
       close: async () => {
         await maConn.close()
         // Ensure remaining streams are closed
diff --git a/test/circuit/reservation-store.spec.ts b/test/circuit/reservation-store.spec.ts
index 048cb84392..06d63f37fc 100644
--- a/test/circuit/reservation-store.spec.ts
+++ b/test/circuit/reservation-store.spec.ts
@@ -11,38 +11,38 @@ describe('circuit-relay server reservation store', function () {
   it('should add reservation', async function () {
     const store = new ReservationStore({ maxReservations: 2 })
     const peer = await createPeerId()
-    const result = await store.reserve(peer, multiaddr())
+    const result = store.reserve(peer, multiaddr())
     expect(result.status).to.equal(Status.OK)
     expect(result.expire).to.not.be.undefined()
-    expect(await store.hasReservation(peer)).to.be.true()
+    expect(store.hasReservation(peer)).to.be.true()
   })
 
   it('should add reservation if peer already has reservation', async function () {
     const store = new ReservationStore({ maxReservations: 1 })
     const peer = await createPeerId()
-    await store.reserve(peer, multiaddr())
-    const result = await store.reserve(peer, multiaddr())
+    store.reserve(peer, multiaddr())
+    const result = store.reserve(peer, multiaddr())
     expect(result.status).to.equal(Status.OK)
     expect(result.expire).to.not.be.undefined()
-    expect(await store.hasReservation(peer)).to.be.true()
+    expect(store.hasReservation(peer)).to.be.true()
   })
 
   it('should fail to add reservation on exceeding limit', async function () {
     const store = new ReservationStore({ maxReservations: 0 })
     const peer = await createPeerId()
-    const result = await store.reserve(peer, multiaddr())
+    const result = store.reserve(peer, multiaddr())
     expect(result.status).to.equal(Status.RESERVATION_REFUSED)
   })
 
   it('should remove reservation', async function () {
     const store = new ReservationStore({ maxReservations: 10 })
     const peer = await createPeerId()
-    const result = await store.reserve(peer, multiaddr())
+    const result = store.reserve(peer, multiaddr())
     expect(result.status).to.equal(Status.OK)
-    expect(await store.hasReservation(peer)).to.be.true()
-    await store.removeReservation(peer)
-    expect(await store.hasReservation(peer)).to.be.false()
-    await store.removeReservation(peer)
+    expect(store.hasReservation(peer)).to.be.true()
+    store.removeReservation(peer)
+    expect(store.hasReservation(peer)).to.be.false()
+    store.removeReservation(peer)
   })
 
   it('should apply configured default connection limits', async function () {
@@ -54,7 +54,7 @@ describe('circuit-relay server reservation store', function () {
       defaultDurationLimit
     })
     const peer = await createPeerId()
-    await store.reserve(peer, multiaddr())
+    store.reserve(peer, multiaddr())
 
     const reservation = store.get(peer)
 
@@ -65,7 +65,7 @@ describe('circuit-relay server reservation store', function () {
   it('should apply default connection limits', async function () {
     const store = new ReservationStore()
     const peer = await createPeerId()
-    await store.reserve(peer, multiaddr())
+    store.reserve(peer, multiaddr())
 
     const reservation = store.get(peer)
 
@@ -78,7 +78,7 @@ describe('circuit-relay server reservation store', function () {
       applyDefaultLimit: false
     })
     const peer = await createPeerId()
-    await store.reserve(peer, multiaddr())
+    store.reserve(peer, multiaddr())
 
     const reservation = store.get(peer)
 
diff --git a/test/circuit/utils.spec.ts b/test/circuit/utils.spec.ts
index a6893f8771..4e1f32edcb 100644
--- a/test/circuit/utils.spec.ts
+++ b/test/circuit/utils.spec.ts
@@ -11,7 +11,7 @@ import { pushable } from 'it-pushable'
 import Sinon from 'sinon'
 import toBuffer from 'it-to-buffer'
 
-describe('circuit-relay utils', function () {
+describe('circuit-relay utils', () => {
   it('should create relay', async () => {
     const received = pushable()
 
diff --git a/test/circuit/utils.ts b/test/circuit/utils.ts
index 2efd22cc70..1e03ff260b 100644
--- a/test/circuit/utils.ts
+++ b/test/circuit/utils.ts
@@ -27,7 +27,7 @@ export function createNodeOptions (...overrides: Libp2pOptions[]): Libp2pOptions
   }, ...overrides)
 }
 
-export async function usingAsRelay (node: Libp2p, relay: Libp2p, opts?: PWaitForOptions<boolean>) {
+export async function usingAsRelay (node: Libp2p, relay: Libp2p, opts?: PWaitForOptions<boolean>): Promise<void> {
   // Wait for peer to be used as a relay
   await pWaitFor(() => {
     const relayAddrs = node.getMultiaddrs().filter(addr => addr.protoNames().includes('p2p-circuit'))
@@ -86,7 +86,7 @@ export async function hasRelay (node: Libp2p, opts?: PWaitForOptions<PeerId>): P
   return relayPeerId
 }
 
-export async function discoveredRelayConfig (node: Libp2p, relay: Libp2p, opts?: PWaitForOptions<boolean>) {
+export async function discoveredRelayConfig (node: Libp2p, relay: Libp2p, opts?: PWaitForOptions<boolean>): Promise<void> {
   await pWaitFor(async () => {
     const peerData = await node.peerStore.get(relay.peerId)
     return peerData.protocols.includes(RELAY_V2_HOP_CODEC)
@@ -116,7 +116,7 @@ export class MockContentRouting implements ContentRouting {
   static providers: Map<string, PeerInfo[]> = new Map()
   static data: Map<string, Uint8Array> = new Map()
 
-  static reset () {
+  static reset (): void {
     MockContentRouting.providers.clear()
     MockContentRouting.data.clear()
   }
@@ -129,7 +129,7 @@ export class MockContentRouting implements ContentRouting {
     this.addressManager = components.addressManager
   }
 
-  async provide (cid: CID, options?: AbortOptions) {
+  async provide (cid: CID, options?: AbortOptions): Promise<void> {
     let providers = MockContentRouting.providers.get(cid.toString()) ?? []
     providers = providers.filter(peerInfo => !peerInfo.id.equals(this.peerId))
 
@@ -142,15 +142,15 @@ export class MockContentRouting implements ContentRouting {
     MockContentRouting.providers.set(cid.toString(), providers)
   }
 
-  async * findProviders (cid: CID<unknown, number, number, Version>, options?: AbortOptions | undefined) {
+  async * findProviders (cid: CID<unknown, number, number, Version>, options?: AbortOptions | undefined): AsyncGenerator<PeerInfo, void, undefined> {
     yield * MockContentRouting.providers.get(cid.toString()) ?? []
   }
 
-  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions) {
+  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
     MockContentRouting.data.set(uint8ArrayToString(key, 'base58btc'), value)
   }
 
-  async get (key: Uint8Array, options?: AbortOptions) {
+  async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
     const value = MockContentRouting.data.get(uint8ArrayToString(key, 'base58btc'))
 
     if (value != null) {
diff --git a/test/configuration/pubsub.spec.ts b/test/configuration/pubsub.spec.ts
index 110ba14815..e46ec92c30 100644
--- a/test/configuration/pubsub.spec.ts
+++ b/test/configuration/pubsub.spec.ts
@@ -81,7 +81,7 @@ describe('Pubsub subscription handlers adapter', () => {
     const topic = 'topic'
     const defer = pDefer()
 
-    const handler = () => {
+    const handler = (): void => {
       countMessages++
       defer.resolve()
     }
diff --git a/test/connection-manager/index.node.ts b/test/connection-manager/index.node.ts
index f36413cdd8..938081d136 100644
--- a/test/connection-manager/index.node.ts
+++ b/test/connection-manager/index.node.ts
@@ -65,8 +65,8 @@ describe('Connection Manager', () => {
 
     await start(connectionManager)
 
-    const conn1 = await mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
-    const conn2 = await mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
+    const conn1 = mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
+    const conn2 = mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
 
     expect(connectionManager.getConnections(peerIds[1])).to.have.lengthOf(0)
 
@@ -105,8 +105,8 @@ describe('Connection Manager', () => {
 
     await start(connectionManager)
 
-    const conn1 = await mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
-    const conn2 = await mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
+    const conn1 = mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
+    const conn2 = mockConnection(mockMultiaddrConnection(mockDuplex(), peerIds[1]))
 
     // Add connection to the connectionManager
     upgrader.dispatchEvent(new CustomEvent<Connection>('connection', { detail: conn1 }))
@@ -189,7 +189,7 @@ describe('libp2p.connections', () => {
     })
 
     afterEach(async () => {
-      await Promise.all(nodes.map(async (node) => await node.stop()))
+      await Promise.all(nodes.map(async (node) => { await node.stop() }))
 
       if (libp2p != null) {
         await libp2p.stop()
diff --git a/test/connection-manager/index.spec.ts b/test/connection-manager/index.spec.ts
index b5668b2148..7953db9466 100644
--- a/test/connection-manager/index.spec.ts
+++ b/test/connection-manager/index.spec.ts
@@ -132,7 +132,7 @@ describe('Connection Manager', () => {
     const connectionManagerMaybeDisconnectOneSpy = sinon.spy(connectionManager, '_pruneConnections')
     const spies = new Map<string, sinon.SinonSpy<[], Promise<void>>>()
 
-    const createConnection = async (value: number, open: number = Date.now(), peerTag: string = 'test-tag') => {
+    const createConnection = async (value: number, open: number = Date.now(), peerTag: string = 'test-tag'): Promise<void> => {
       // #TODO: Mock the connection timeline to simulate an older connection
       const connection = mockConnection(mockMultiaddrConnection({ ...mockDuplex(), timeline: { open } }, await createEd25519PeerId()))
       const spy = sinon.spy(connection, 'close')
diff --git a/test/content-routing/content-routing.node.ts b/test/content-routing/content-routing.node.ts
index 229c05c970..8c8ee224f8 100644
--- a/test/content-routing/content-routing.node.ts
+++ b/test/content-routing/content-routing.node.ts
@@ -27,7 +27,7 @@ describe('content-routing', () => {
       })
     })
 
-    after(async () => await node.stop())
+    after(async () => { await node.stop() })
 
     it('.findProviders should return an error', async () => {
       try {
@@ -72,7 +72,7 @@ describe('content-routing', () => {
       sinon.restore()
     })
 
-    after(async () => await Promise.all(nodes.map(async (n) => await n.stop())))
+    after(async () => await Promise.all(nodes.map(async (n) => { await n.stop() })))
 
     it('should use the nodes dht to provide', async () => {
       const deferred = pDefer()
@@ -244,7 +244,7 @@ describe('content-routing', () => {
       sinon.restore()
     })
 
-    afterEach(async () => await node.stop())
+    afterEach(async () => { await node.stop() })
 
     it('should store the multiaddrs of a peer', async () => {
       const providerPeerId = await createPeerId()
diff --git a/test/content-routing/dht/operation.node.ts b/test/content-routing/dht/operation.node.ts
index d6c51866e1..ffc2fbae21 100644
--- a/test/content-routing/dht/operation.node.ts
+++ b/test/content-routing/dht/operation.node.ts
@@ -14,7 +14,7 @@ import { start } from '@libp2p/interfaces/startable'
 const listenAddr = multiaddr('/ip4/127.0.0.1/tcp/8000')
 const remoteListenAddr = multiaddr('/ip4/127.0.0.1/tcp/8001')
 
-async function getRemoteAddr (remotePeerId: PeerId, libp2p: Libp2pNode) {
+async function getRemoteAddr (remotePeerId: PeerId, libp2p: Libp2pNode): Promise<Multiaddr> {
   const addrs = await libp2p.components.peerStore.addressBook.get(remotePeerId)
 
   if (addrs.length === 0) {
@@ -152,7 +152,7 @@ describe('DHT subsystem operates correctly', () => {
       // the ability to report stats on the DHT routing table instead of reaching into it's heart like this
       expect(remoteLibp2p.dht.lan.routingTable).to.be.empty()
 
-      return await pWaitFor(() => libp2p.dht.lan.routingTable.size === 1)
+      await pWaitFor(() => libp2p.dht.lan.routingTable.size === 1)
     })
 
     it('should put on a peer and get from the other', async () => {
diff --git a/test/content-routing/dht/utils.ts b/test/content-routing/dht/utils.ts
index 0e1eebe45f..702ee3c1d9 100644
--- a/test/content-routing/dht/utils.ts
+++ b/test/content-routing/dht/utils.ts
@@ -2,7 +2,7 @@ import { kadDHT } from '@libp2p/kad-dht'
 import type { Libp2pOptions } from '../../../src/index.js'
 import { createBaseOptions } from '../../utils/base-options.js'
 
-export function createSubsystemOptions (...overrides: Libp2pOptions[]) {
+export function createSubsystemOptions (...overrides: Libp2pOptions[]): Libp2pOptions {
   return createBaseOptions({
     dht: kadDHT({
       kBucketSize: 20
diff --git a/test/dialing/dial-request.spec.ts b/test/dialing/dial-request.spec.ts
index bfc244531f..a4d057fbf7 100644
--- a/test/dialing/dial-request.spec.ts
+++ b/test/dialing/dial-request.spec.ts
@@ -184,7 +184,7 @@ describe('Dial Request', () => {
   })
 
   it('should abort all dials when its signal is aborted', async () => {
-    const deferToAbort = async (args: { signal: AbortSignal }) => {
+    const deferToAbort = async (args: { signal: AbortSignal }): Promise<any> => {
       const { signal } = args
 
       if (signal.aborted) {
@@ -192,7 +192,7 @@ describe('Dial Request', () => {
       }
 
       const deferred = pDefer<any>()
-      const onAbort = () => {
+      const onAbort = (): void => {
         deferred.reject(new AbortError())
         signal.removeEventListener('abort', onAbort)
       }
@@ -229,7 +229,7 @@ describe('Dial Request', () => {
     sinon.spy(actions, '/ip4/127.0.0.1/tcp/1233')
 
     try {
-      setTimeout(() => controller.abort(), 100)
+      setTimeout(() => { controller.abort() }, 100)
       await dialRequest.run({ signal: controller.signal })
       expect.fail('dial should have failed')
     } catch (err: any) {
diff --git a/test/dialing/direct.node.ts b/test/dialing/direct.node.ts
index 956d75bb7d..eb3d74d6e8 100644
--- a/test/dialing/direct.node.ts
+++ b/test/dialing/direct.node.ts
@@ -94,7 +94,7 @@ describe('Dialing (direct, TCP)', () => {
     remoteAddr = remoteTM.getAddrs()[0].encapsulate(`/p2p/${remotePeerId.toString()}`)
   })
 
-  afterEach(async () => await remoteTM.stop())
+  afterEach(async () => { await remoteTM.stop() })
 
   afterEach(() => {
     sinon.restore()
diff --git a/test/dialing/direct.spec.ts b/test/dialing/direct.spec.ts
index 1084db1270..2f7687e1e8 100644
--- a/test/dialing/direct.spec.ts
+++ b/test/dialing/direct.spec.ts
@@ -269,7 +269,7 @@ describe('Dialing (direct, WebSockets)', () => {
 
     sinon.stub(localTM, 'dial').callsFake(async (_, options) => {
       const deferredDial = pDefer<Connection>()
-      const onAbort = () => {
+      const onAbort = (): void => {
         options.signal.removeEventListener('abort', onAbort)
         deferredDial.reject(new AbortError())
       }
diff --git a/test/dialing/resolver.spec.ts b/test/dialing/resolver.spec.ts
index c7a1e3a13d..731ddf40b1 100644
--- a/test/dialing/resolver.spec.ts
+++ b/test/dialing/resolver.spec.ts
@@ -16,10 +16,11 @@ import { peerIdFromString } from '@libp2p/peer-id'
 import { createFromJSON } from '@libp2p/peer-id-factory'
 import { RELAY_V2_HOP_CODEC } from '../../src/circuit/constants.js'
 import { circuitRelayServer } from '../../src/circuit/index.js'
+import type { Transport } from '@libp2p/interface-transport'
 
 const relayAddr = MULTIADDRS_WEBSOCKETS[0]
 
-const getDnsaddrStub = (peerId: PeerId) => [
+const getDnsaddrStub = (peerId: PeerId): string[] => [
   `/dnsaddr/ams-1.bootstrap.libp2p.io/p2p/${peerId.toString()}`,
   `/dnsaddr/ams-2.bootstrap.libp2p.io/p2p/${peerId.toString()}`,
   `/dnsaddr/lon-1.bootstrap.libp2p.io/p2p/${peerId.toString()}`,
@@ -28,9 +29,9 @@ const getDnsaddrStub = (peerId: PeerId) => [
   `/dnsaddr/sfo-2.bootstrap.libp2p.io/p2p/${peerId.toString()}`
 ]
 
-const relayedAddr = (peerId: PeerId) => `${relayAddr.toString()}/p2p-circuit/p2p/${peerId.toString()}`
+const relayedAddr = (peerId: PeerId): string => `${relayAddr.toString()}/p2p-circuit/p2p/${peerId.toString()}`
 
-const getDnsRelayedAddrStub = (peerId: PeerId) => [
+const getDnsRelayedAddrStub = (peerId: PeerId): string[] => [
   `${relayedAddr(peerId)}`
 ]
 
@@ -222,7 +223,7 @@ describe('Dialing (resolvable addresses)', () => {
   })
 })
 
-function getTransport (libp2p: Libp2pNode, tag: string) {
+function getTransport (libp2p: Libp2pNode, tag: string): Transport {
   const transport = libp2p.components.transportManager.getTransports().find(t => {
     return t[Symbol.toStringTag] === tag
   })
diff --git a/test/fetch/fetch.node.ts b/test/fetch/fetch.node.ts
index 574e581ae1..b9a797e99a 100644
--- a/test/fetch/fetch.node.ts
+++ b/test/fetch/fetch.node.ts
@@ -9,7 +9,7 @@ import { createPeerId } from '../utils/creators/peer.js'
 import { codes } from '../../src/errors.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 
-async function createNode (peerId: PeerId) {
+async function createNode (peerId: PeerId): Promise<Libp2pNode> {
   return await createLibp2pNode({
     peerId,
     addresses: {
@@ -120,7 +120,7 @@ describe('Fetch', () => {
   it('registering multiple handlers for same prefix errors', async () => {
     receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_A))
 
-    expect(() => receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_B)))
+    expect(() => { receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_B)) })
       .to.throw().with.property('code', codes.ERR_KEY_ALREADY_EXISTS)
   })
 
diff --git a/test/fetch/index.spec.ts b/test/fetch/index.spec.ts
index 27a7e80db3..b693eefd43 100644
--- a/test/fetch/index.spec.ts
+++ b/test/fetch/index.spec.ts
@@ -23,7 +23,7 @@ const defaultInit: FetchServiceInit = {
   timeout: 1000
 }
 
-async function createComponents (index: number) {
+async function createComponents (index: number): Promise<DefaultComponents> {
   const peerId = await createFromJSON(Peers[index])
 
   const components = new DefaultComponents({
diff --git a/test/identify/index.spec.ts b/test/identify/index.spec.ts
index 5a5f0b247e..5b67645dac 100644
--- a/test/identify/index.spec.ts
+++ b/test/identify/index.spec.ts
@@ -46,7 +46,7 @@ const defaultInit: IdentifyServiceInit = {
 
 const protocols = [MULTICODEC_IDENTIFY, MULTICODEC_IDENTIFY_PUSH]
 
-async function createComponents (index: number) {
+async function createComponents (index: number): Promise<DefaultComponents> {
   const peerId = await createFromJSON(Peers[index])
 
   const components = new DefaultComponents({
@@ -115,7 +115,7 @@ describe('identify', () => {
     const localProtoBookSetSpy = sinon.spy(localComponents.peerStore.protoBook, 'set')
 
     // Make sure the remote peer has a peer record to share during identify
-    await remotePeerRecordUpdater.update()
+    remotePeerRecordUpdater.update()
 
     // Run identify
     await localIdentify.identify(localToRemote)
@@ -139,7 +139,7 @@ describe('identify', () => {
       ...defaultInit,
       protocolPrefix: 'ipfs',
       host: {
-        agentVersion: agentVersion
+        agentVersion
       }
     })
     await start(localIdentify)
@@ -147,7 +147,7 @@ describe('identify', () => {
       ...defaultInit,
       protocolPrefix: 'ipfs',
       host: {
-        agentVersion: agentVersion
+        agentVersion
       }
     })
     await start(remoteIdentify)
@@ -305,7 +305,7 @@ describe('identify', () => {
           [data],
           lp.encode(),
           stream,
-          async (source) => await drain(source)
+          async (source) => { await drain(source) }
         )
 
         deferred.resolve()
diff --git a/test/identify/push.spec.ts b/test/identify/push.spec.ts
index c6482aecce..9a0bee6437 100644
--- a/test/identify/push.spec.ts
+++ b/test/identify/push.spec.ts
@@ -148,7 +148,7 @@ describe('identify (push)', () => {
     await delay(1000)
 
     // make sure we have a peer record to send
-    await localPeerRecordUpdater.update()
+    localPeerRecordUpdater.update()
 
     // wait for the remote peer store to notice the changes
     const eventPromise = pEvent(remoteComponents.peerStore, 'change:multiaddrs')
diff --git a/test/interop.ts b/test/interop.ts
index 67da7cc3ea..d4b95cc389 100644
--- a/test/interop.ts
+++ b/test/interop.ts
@@ -103,7 +103,7 @@ async function createGoPeer (options: SpawnOptions): Promise<Daemon> {
   return {
     client: createClient(apiAddr),
     stop: async () => {
-      await proc.kill()
+      proc.kill()
     }
   }
 }
@@ -184,7 +184,7 @@ async function createJsPeer (options: SpawnOptions): Promise<Daemon> {
   }
 }
 
-async function main () {
+async function main (): Promise<void> {
   const factory: DaemonFactory = {
     async spawn (options: SpawnOptions) {
       if (options.type === 'go') {
diff --git a/test/nat-manager/nat-manager.node.ts b/test/nat-manager/nat-manager.node.ts
index aadd8a0be6..d2322d6990 100644
--- a/test/nat-manager/nat-manager.node.ts
+++ b/test/nat-manager/nat-manager.node.ts
@@ -61,7 +61,7 @@ describe('Nat Manager (TCP)', () => {
     }
   }
 
-  afterEach(async () => await Promise.all(teardown.map(async t => await t())))
+  afterEach(async () => await Promise.all(teardown.map(async t => { await t() })))
 
   it('should map TCP connections to external ports', async () => {
     const {
diff --git a/test/peer-discovery/index.node.ts b/test/peer-discovery/index.node.ts
index 60a6ce6c83..bcfeefab1e 100644
--- a/test/peer-discovery/index.node.ts
+++ b/test/peer-discovery/index.node.ts
@@ -15,6 +15,7 @@ import type { PeerId } from '@libp2p/interface-peer-id'
 import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
 import { CustomEvent } from '@libp2p/interfaces/events'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { Libp2pOptions } from '../../src/index.js'
 
 const listenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
 
@@ -109,7 +110,7 @@ describe('peer discovery scenarios', () => {
     // use a random tag to prevent CI collision
     const serviceTag = `libp2p-test-${uint8ArrayToString(randomBytes(4), 'base16')}.local`
 
-    const getConfig = (peerId: PeerId) => createBaseOptions({
+    const getConfig = (peerId: PeerId): Libp2pOptions => createBaseOptions({
       peerId,
       addresses: {
         listen: [
@@ -162,7 +163,7 @@ describe('peer discovery scenarios', () => {
   it('kad-dht should discover other peers', async () => {
     const deferred = defer()
 
-    const getConfig = (peerId: PeerId) => createBaseOptions({
+    const getConfig = (peerId: PeerId): Libp2pOptions => createBaseOptions({
       peerId,
       addresses: {
         listen: [
diff --git a/test/peer-routing/peer-routing.node.ts b/test/peer-routing/peer-routing.node.ts
index 9aa5fc0706..ebc2b0e241 100644
--- a/test/peer-routing/peer-routing.node.ts
+++ b/test/peer-routing/peer-routing.node.ts
@@ -36,7 +36,7 @@ describe('peer-routing', () => {
       })
     })
 
-    after(async () => await node.stop())
+    after(async () => { await node.stop() })
 
     it('.findPeer should return an error', async () => {
       await expect(node.peerRouting.findPeer(peerId))
@@ -78,7 +78,7 @@ describe('peer-routing', () => {
       sinon.restore()
     })
 
-    after(async () => await Promise.all(nodes.map(async (n) => await n.stop())))
+    after(async () => await Promise.all(nodes.map(async (n) => { await n.stop() })))
 
     it('should use the nodes dht', async () => {
       if (nodes[0].dht == null) {
@@ -253,7 +253,7 @@ describe('peer-routing', () => {
       sinon.restore()
     })
 
-    afterEach(async () => await node.stop())
+    afterEach(async () => { await node.stop() })
 
     it('should only have one router', () => {
       // @ts-expect-error private field
@@ -334,7 +334,7 @@ describe('peer-routing', () => {
       sinon.restore()
     })
 
-    afterEach(async () => await node.stop())
+    afterEach(async () => { await node.stop() })
 
     it('should use the delegate if the dht fails to find the peer', async () => {
       const remotePeerId = await createPeerId()
diff --git a/test/ping/ping.node.ts b/test/ping/ping.node.ts
index c54b3a2b07..49dc874fa0 100644
--- a/test/ping/ping.node.ts
+++ b/test/ping/ping.node.ts
@@ -24,7 +24,7 @@ describe('ping', () => {
     await nodes[1].components.peerStore.addressBook.set(nodes[0].peerId, nodes[0].getMultiaddrs())
   })
 
-  afterEach(async () => await Promise.all(nodes.map(async n => await n.stop())))
+  afterEach(async () => await Promise.all(nodes.map(async n => { await n.stop() })))
 
   it('ping once from peer0 to peer1 using a multiaddr', async () => {
     const ma = multiaddr(`${nodes[2].getMultiaddrs()[0].toString()}/p2p/${nodes[2].peerId.toString()}`)
diff --git a/test/registrar/registrar.spec.ts b/test/registrar/registrar.spec.ts
index d9fac96a4f..511974c0bc 100644
--- a/test/registrar/registrar.spec.ts
+++ b/test/registrar/registrar.spec.ts
@@ -75,7 +75,7 @@ describe('registrar', () => {
       })
     })
 
-    afterEach(async () => await libp2p.stop())
+    afterEach(async () => { await libp2p.stop() })
 
     it('should be able to register a protocol', async () => {
       const topology = createTopology({
@@ -143,13 +143,13 @@ describe('registrar', () => {
       await libp2p.peerStore.protoBook.set(remotePeerId, [protocol])
 
       // remote peer connects
-      await libp2p.components.upgrader.dispatchEvent(new CustomEvent<Connection>('connection', {
+      libp2p.components.upgrader.dispatchEvent(new CustomEvent<Connection>('connection', {
         detail: conn
       }))
       await onConnectDefer.promise
       // remote peer disconnects
       await conn.close()
-      await libp2p.components.upgrader.dispatchEvent(new CustomEvent<Connection>('connectionEnd', {
+      libp2p.components.upgrader.dispatchEvent(new CustomEvent<Connection>('connectionEnd', {
         detail: conn
       }))
       await onDisconnectDefer.promise
@@ -181,12 +181,12 @@ describe('registrar', () => {
       await libp2p.peerStore.protoBook.set(remotePeerId, [])
 
       // remote peer connects
-      await libp2p.components.upgrader.dispatchEvent(new CustomEvent<Connection>('connection', {
+      libp2p.components.upgrader.dispatchEvent(new CustomEvent<Connection>('connection', {
         detail: conn
       }))
 
       // identify completes
-      await libp2p.components.peerStore.dispatchEvent(new CustomEvent<PeerProtocolsChangeData>('change:protocols', {
+      libp2p.components.peerStore.dispatchEvent(new CustomEvent<PeerProtocolsChangeData>('change:protocols', {
         detail: {
           peerId: conn.remotePeer,
           protocols: [protocol],
@@ -197,7 +197,7 @@ describe('registrar', () => {
       await onConnectDefer.promise
 
       // Peer no longer supports the protocol our topology is registered for
-      await libp2p.components.peerStore.dispatchEvent(new CustomEvent<PeerProtocolsChangeData>('change:protocols', {
+      libp2p.components.peerStore.dispatchEvent(new CustomEvent<PeerProtocolsChangeData>('change:protocols', {
         detail: {
           peerId: conn.remotePeer,
           protocols: [],
@@ -226,7 +226,7 @@ describe('registrar', () => {
 
       expect(registrar.getProtocols()).to.not.have.any.keys(['/echo/1.0.0', '/echo/1.0.1'])
 
-      const echoHandler = () => {}
+      const echoHandler = (): void => {}
       await libp2p.handle(['/echo/1.0.0', '/echo/1.0.1'], echoHandler)
       expect(registrar.getHandler('/echo/1.0.0')).to.have.property('handler', echoHandler)
       expect(registrar.getHandler('/echo/1.0.1')).to.have.property('handler', echoHandler)
diff --git a/test/upgrading/upgrader.spec.ts b/test/upgrading/upgrader.spec.ts
index 762df7adad..f1a55a8d63 100644
--- a/test/upgrading/upgrader.spec.ts
+++ b/test/upgrading/upgrader.spec.ts
@@ -186,7 +186,7 @@ describe('Upgrader', () => {
     // Verify the MultiaddrConnection close method is called
     const inboundCloseSpy = sinon.spy(inbound, 'close')
     const outboundCloseSpy = sinon.spy(outbound, 'close')
-    await Promise.all(connections.map(async conn => await conn.close()))
+    await Promise.all(connections.map(async conn => { await conn.close() }))
     expect(inboundCloseSpy.callCount).to.equal(1)
     expect(outboundCloseSpy.callCount).to.equal(1)
   })
@@ -278,8 +278,8 @@ describe('Upgrader', () => {
       }
 
       source = []
-      async sink () {}
-      close () {}
+      async sink (): Promise<void> {}
+      close (): void {}
     }
 
     class OtherMuxerFactory implements StreamMuxerFactory {
@@ -344,7 +344,7 @@ describe('Upgrader', () => {
     // Verify the MultiaddrConnection close method is called
     const inboundCloseSpy = sinon.spy(inbound, 'close')
     const outboundCloseSpy = sinon.spy(outbound, 'close')
-    await Promise.all(connections.map(async conn => await conn.close()))
+    await Promise.all(connections.map(async conn => { await conn.close() }))
     expect(inboundCloseSpy.callCount).to.equal(1)
     expect(outboundCloseSpy.callCount).to.equal(1)
   })
@@ -382,7 +382,7 @@ describe('Upgrader', () => {
     ])
 
     // Verify onConnectionEnd is called with the connection
-    await Promise.all(connections.map(async conn => await conn.close()))
+    await Promise.all(connections.map(async conn => { await conn.close() }))
 
     await Promise.all([
       localConnectionEndEventReceived.promise,
@@ -593,7 +593,7 @@ describe('libp2p.upgrader', () => {
       ]
     })
     await libp2p.start()
-    const echoHandler = () => {}
+    const echoHandler = (): void => {}
     await libp2p.handle(['/echo/1.0.0'], echoHandler)
 
     remoteLibp2p = await createLibp2pNode({
@@ -675,7 +675,7 @@ describe('libp2p.upgrader', () => {
     expect(remotePeer.equals(event.detail.remotePeer)).to.equal(true)
 
     // Close and check the disconnect event
-    await Promise.all(connections.map(async conn => await conn.close()))
+    await Promise.all(connections.map(async conn => { await conn.close() }))
     expect(connectionManagerDispatchEventSpy.callCount).to.equal(2)
     ;([event] = connectionManagerDispatchEventSpy.getCall(1).args)
     expect(event).to.have.property('type', 'peer:disconnect')
diff --git a/test/utils/creators/peer.ts b/test/utils/creators/peer.ts
index 6e22754b85..895f5c2be5 100644
--- a/test/utils/creators/peer.ts
+++ b/test/utils/creators/peer.ts
@@ -63,7 +63,7 @@ export async function createNode (options: CreatePeerOptions = {}): Promise<Libp
   return peer
 }
 
-export async function populateAddressBooks (peers: Libp2pNode[]) {
+export async function populateAddressBooks (peers: Libp2pNode[]): Promise<void> {
   for (let i = 0; i < peers.length; i++) {
     for (let j = 0; j < peers.length; j++) {
       if (i !== j) {