libp2p 0.42.2 → 0.43.0

package/src/connection/index.ts

@@ -1,5 +1,5 @@
 import type { Multiaddr } from '@multiformats/multiaddr'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { OPEN, CLOSING, CLOSED } from '@libp2p/interface-connection/status'
 import { symbol } from '@libp2p/interface-connection'
 import type { Connection, ConnectionStat, Stream } from '@libp2p/interface-connection'
@@ -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()
   }
 
@@ -107,11 +107,11 @@ export class ConnectionImpl implements Connection {
    */
   async newStream (protocols: string | string[], options?: AbortOptions): Promise<Stream> {
     if (this.stat.status === CLOSING) {
-      throw errCode(new Error('the connection is being closed'), 'ERR_CONNECTION_BEING_CLOSED')
+      throw new CodeError('the connection is being closed', 'ERR_CONNECTION_BEING_CLOSED')
     }
 
     if (this.stat.status === CLOSED) {
-      throw errCode(new Error('the connection is closed'), 'ERR_CONNECTION_CLOSED')
+      throw new CodeError('the connection is closed', 'ERR_CONNECTION_CLOSED')
     }
 
     if (!Array.isArray(protocols)) {
@@ -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)
     }

package/src/connection-manager/auto-dialler.ts

@@ -2,10 +2,6 @@ import { logger } from '@libp2p/logger'
 import mergeOptions from 'merge-options'
 // @ts-expect-error retimer does not have types
 import retimer from 'retimer'
-import all from 'it-all'
-import { pipe } from 'it-pipe'
-import filter from 'it-filter'
-import sort from 'it-sort'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
@@ -14,11 +10,6 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 const log = logger('libp2p:connection-manager:auto-dialler')
 
 export interface AutoDiallerInit {
-  /**
-   * Should preemptively guarantee connections are above the low watermark
-   */
-  enabled?: boolean
-
   /**
    * The minimum number of connections to avoid pruning
    */
@@ -37,7 +28,6 @@ export interface AutoDiallerComponents {
 }
 
 const defaultOptions: Partial<AutoDiallerInit> = {
-  enabled: true,
   minConnections: 0,
   autoDialInterval: 10000
 }
@@ -62,19 +52,14 @@ export class AutoDialler implements Startable {
     log('options: %j', this.options)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Starts the auto dialer
    */
-  async start () {
-    if (!this.options.enabled) {
-      log('not enabled')
-      return
-    }
-
+  async start (): Promise<void> {
     this.running = true
 
     void this._autoDial().catch(err => {
@@ -87,12 +72,7 @@ export class AutoDialler implements Startable {
   /**
    * Stops the auto dialler
    */
-  async stop () {
-    if (!this.options.enabled) {
-      log('not enabled')
-      return
-    }
-
+  async stop (): Promise<void> {
     this.running = false
 
     if (this.autoDialTimeout != null) {
@@ -102,7 +82,7 @@ export class AutoDialler implements Startable {
     log('stopped')
   }
 
-  async _autoDial () {
+  async _autoDial (): Promise<void> {
     if (this.autoDialTimeout != null) {
       this.autoDialTimeout.clear()
     }
@@ -117,22 +97,38 @@ export class AutoDialler implements Startable {
     }
 
     // Sort peers on whether we know protocols or public keys for them
-    const allPeers = await this.components.peerStore.all()
-
-    const peers = await pipe(
-      // shuffle the peers
-      allPeers.sort(() => Math.random() > 0.5 ? 1 : -1),
-      (source) => filter(source, (peer) => !peer.id.equals(this.components.peerId)),
-      (source) => sort(source, (a, b) => {
-        if (b.protocols.length > a.protocols.length) {
-          return 1
-        } else if (b.id.publicKey != null && a.id.publicKey == null) {
-          return 1
-        }
-        return -1
-      }),
-      async (source) => await all(source)
-    )
+    let peers = await this.components.peerStore.all()
+
+    peers = peers.filter((peer) => {
+      // do not dial ourselves
+      if (peer.id.equals(this.components.peerId)) {
+        return false
+      }
+
+      // do not dial peers without multiaddrs
+      if (peer.addresses.length === 0) {
+        return false
+      }
+
+      return true
+    })
+
+    // shuffle the peers
+    peers = peers.sort(() => Math.random() > 0.5 ? 1 : -1)
+
+    peers = peers.sort((a, b) => {
+      // dial peers with the most protocols first
+      if (b.protocols.length > a.protocols.length) {
+        return 1
+      }
+
+      // dial peers with public keys first
+      if (b.id.publicKey != null && a.id.publicKey == null) {
+        return 1
+      }
+
+      return -1
+    })
 
     for (let i = 0; this.running && i < peers.length && this.components.connectionManager.getConnections().length < minConnections; i++) {
       // Connection Manager was stopped during async dial

package/src/connection-manager/dialer/dial-request.ts

@@ -1,4 +1,4 @@
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { anySignal } from 'any-signal'
 import FIFO from 'p-fifo'
 import { setMaxListeners } from 'events'
@@ -50,7 +50,7 @@ export class DialRequest {
 
     // If no tokens are available, throw
     if (tokens.length < 1) {
-      throw errCode(new Error('No dial tokens available'), codes.ERR_NO_DIAL_TOKENS)
+      throw new CodeError('No dial tokens available', codes.ERR_NO_DIAL_TOKENS)
     }
 
     const tokenHolder = new FIFO<number>()
@@ -87,12 +87,12 @@ export class DialRequest {
         // End attempt once another attempt succeeded
         if (done) {
           this.dialer.releaseToken(tokens.splice(tokens.indexOf(token), 1)[0])
-          throw errCode(new Error('dialAction already succeeded'), codes.ERR_ALREADY_SUCCEEDED)
+          throw new CodeError('dialAction already succeeded', codes.ERR_ALREADY_SUCCEEDED)
         }
 
         const controller = dialAbortControllers[i]
         if (controller == null) {
-          throw errCode(new Error('dialAction did not come with an AbortController'), codes.ERR_INVALID_PARAMETERS)
+          throw new CodeError('dialAction did not come with an AbortController', codes.ERR_INVALID_PARAMETERS)
         }
         let conn
         try {
@@ -116,7 +116,7 @@ export class DialRequest {
           // Notify Promise.any that attempt was not successful
           // to prevent from returning undefined despite there
           // were successful dial attempts
-          throw errCode(new Error('dialAction led to empty object'), codes.ERR_TRANSPORT_DIAL_FAILED)
+          throw new CodeError('dialAction led to empty object', codes.ERR_TRANSPORT_DIAL_FAILED)
         } else {
           // This dial succeeded, don't attempt anything else
           done = true
@@ -124,6 +124,13 @@ export class DialRequest {
 
         return conn
       }))
+    } catch (err: any) {
+      // if we only dialed one address, unwrap the AggregateError
+      if (this.addrs.length === 1 && err.name === 'AggregateError') {
+        throw err.errors[0]
+      }
+
+      throw err
     } finally {
       // success/failure happened, abort everything else
       dialAbortControllers.forEach(c => {
@@ -131,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
     }
   }
 }

package/src/connection-manager/dialer/index.ts

@@ -1,5 +1,5 @@
 import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { isMultiaddr, Multiaddr, Resolver, multiaddr, resolvers } from '@multiformats/multiaddr'
 import { TimeoutController } from 'timeout-abort-controller'
 import { anySignal } from 'any-signal'
@@ -14,7 +14,7 @@ import {
   MAX_PER_PEER_DIALS,
   MAX_ADDRS_TO_DIAL
 } from '../../constants.js'
-import type { Connection, ConnectionGater } from '@libp2p/interface-connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
@@ -23,6 +23,7 @@ import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { Dialer } from '@libp2p/interface-connection-manager'
 import type { TransportManager } from '@libp2p/interface-transport'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 
 const log = logger('libp2p:dialer')
 
@@ -116,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()) {
@@ -155,7 +156,7 @@ export class DefaultDialer implements Startable, Dialer {
 
     if (peerId != null) {
       if (this.components.peerId.equals(peerId)) {
-        throw errCode(new Error('Tried to dial self'), codes.ERR_DIALED_SELF)
+        throw new CodeError('Tried to dial self', codes.ERR_DIALED_SELF)
       }
 
       if (multiaddr != null) {
@@ -163,8 +164,8 @@ export class DefaultDialer implements Startable, Dialer {
         await this.components.peerStore.addressBook.add(peerId, [multiaddr])
       }
 
-      if (await this.components.connectionGater.denyDialPeer(peerId)) {
-        throw errCode(new Error('The dial request is blocked by gater.allowDialPeer'), codes.ERR_PEER_DIAL_INTERCEPTED)
+      if ((await this.components.connectionGater.denyDialPeer?.(peerId)) === true) {
+        throw new CodeError('The dial request is blocked by gater.allowDialPeer', codes.ERR_PEER_DIAL_INTERCEPTED)
       }
     }
 
@@ -194,7 +195,7 @@ export class DefaultDialer implements Startable, Dialer {
     }
 
     if (dialTarget.addrs.length === 0) {
-      throw errCode(new Error('The dial request has no valid addresses'), codes.ERR_NO_VALID_ADDRESSES)
+      throw new CodeError('The dial request has no valid addresses', codes.ERR_NO_VALID_ADDRESSES)
     }
 
     // try to join an in-flight dial for this peer if one is available
@@ -217,6 +218,24 @@ export class DefaultDialer implements Startable, Dialer {
     }
   }
 
+  /**
+   * Get the current dial targets which are pending
+   */
+  getPendingDialTargets (): Map<string, AbortController> {
+    return this.pendingDialTargets
+  }
+
+  /**
+   * Returns true if the peer id is in the pending dials
+   */
+  hasPendingDial (peerId: PeerId | Multiaddr): boolean {
+    if (isMultiaddr(peerId)) {
+      return this.pendingDials.has(peerId.getPeerId() ?? '')
+    }
+
+    return this.pendingDials.has(peerId.toString())
+  }
+
   /**
    * Creates a DialTarget. The DialTarget is used to create and track
    * the DialRequest to a given peer.
@@ -248,7 +267,7 @@ export class DefaultDialer implements Startable, Dialer {
     addrs = [...new Set(addrs.map(ma => ma.toString()))].map(ma => multiaddr(ma))
 
     if (addrs.length > this.maxAddrsToDial) {
-      throw errCode(new Error('dial with more addresses than allowed'), codes.ERR_TOO_MANY_ADDRESSES)
+      throw new CodeError('dial with more addresses than allowed', codes.ERR_TOO_MANY_ADDRESSES)
     }
 
     const peerId = isPeerId(peerIdOrMultiaddr.peerId) ? peerIdOrMultiaddr.peerId : undefined
@@ -280,9 +299,9 @@ export class DefaultDialer implements Startable, Dialer {
 
     return (await Promise.all(
       addresses.map(async address => {
-        const deny = await this.components.connectionGater.denyDialMultiaddr(peer, address.multiaddr)
+        const deny = await this.components.connectionGater.denyDialMultiaddr?.(peer, address.multiaddr)
 
-        if (deny) {
+        if (deny === true) {
           return false
         }
 
@@ -305,7 +324,7 @@ export class DefaultDialer implements Startable, Dialer {
      */
     const dialAction: DialAction = async (addr, options = {}) => {
       if (options.signal?.aborted === true) {
-        throw errCode(new Error('already aborted'), codes.ERR_ALREADY_ABORTED)
+        throw new CodeError('already aborted', codes.ERR_ALREADY_ABORTED)
       }
 
       return await this.components.transportManager.dial(addr, options).catch(err => {
@@ -348,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

package/src/connection-manager/index.ts

@@ -1,5 +1,5 @@
 import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import mergeOptions from 'merge-options'
 import { LatencyMonitor, SummaryObject } from './latency-monitor.js'
 import type { AbortOptions } from '@libp2p/interfaces'
@@ -44,11 +44,6 @@ export interface ConnectionManagerConfig {
    */
   pollInterval?: number
 
-  /**
-   * If true, try to connect to all discovered peers up to the connection manager limit
-   */
-  autoDial?: boolean
-
   /**
    * How long to wait between attempting to keep our number of concurrent connections
    * above minConnections
@@ -168,7 +163,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.opts = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, init)
 
     if (this.opts.maxConnections < this.opts.minConnections) {
-      throw errCode(new Error('Connection Manager maxConnections must be greater than minConnections'), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError('Connection Manager maxConnections must be greater than minConnections', codes.ERR_INVALID_PARAMETERS)
     }
 
     log('options: %o', this.opts)
@@ -211,7 +206,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.incomingPendingConnections = 0
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
@@ -219,7 +214,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 +302,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 +347,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 +357,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 +369,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 +389,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 +398,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 +431,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) {
@@ -470,11 +465,15 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     return conns
   }
 
+  getConnectionsMap (): Map<string, Connection[]> {
+    return this.connections
+  }
+
   async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr, options: AbortOptions = {}): Promise<Connection> {
     const { peerId, multiaddr } = getPeerAddress(peerIdOrMultiaddr)
 
     if (peerId == null && multiaddr == null) {
-      throw errCode(new TypeError('Can only open connections to PeerIds or Multiaddrs'), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError('Can only open connections to PeerIds or Multiaddrs', codes.ERR_INVALID_PARAMETERS)
     }
 
     if (peerId != null) {
@@ -538,7 +537,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     await Promise.all(
       connections.map(async connection => {
-        return await connection.close()
+        await connection.close()
       })
     )
   }
@@ -548,7 +547,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
    */
   getAll (peerId: PeerId): Connection[] {
     if (!isPeerId(peerId)) {
-      throw errCode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError('peerId must be an instance of peer-id', codes.ERR_INVALID_PARAMETERS)
     }
 
     const id = peerId.toString()
@@ -565,7 +564,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)
@@ -577,7 +576,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) {
@@ -596,7 +595,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>()
 
@@ -722,7 +721,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     return false
   }
 
-  afterUpgradeInbound () {
+  afterUpgradeInbound (): void {
     this.incomingPendingConnections--
   }
 }

package/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'
 }