libp2p 0.44.0 → 0.45.0

package/src/connection-manager/connection-pruner.ts

@@ -4,7 +4,8 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 import { PeerMap } from '@libp2p/peer-collections'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import { MAX_CONNECTIONS } from './constants.js'
-import { CustomEvent } from '@libp2p/interfaces/events'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:connection-manager:connection-pruner')
 
@@ -16,6 +17,7 @@ interface ConnectionPrunerInit {
 interface ConnectionPrunerComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 const defaultOptions = {
@@ -31,12 +33,22 @@ export class ConnectionPruner {
   private readonly connectionManager: ConnectionManager
   private readonly peerStore: PeerStore
   private readonly allow: Multiaddr[]
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
     this.allow = init.allow ?? defaultOptions.allow
     this.connectionManager = components.connectionManager
     this.peerStore = components.peerStore
+    this.events = components.events
+
+    // check the max connection limit whenever a peer connects
+    components.events.addEventListener('connection:open', () => {
+      this.maybePruneConnections()
+        .catch(err => {
+          log.error(err)
+        })
+    })
   }
 
   /**
@@ -48,7 +60,7 @@ export class ConnectionPruner {
     const numConnections = connections.length
     const toPrune = Math.max(numConnections - this.maxConnections, 0)
 
-    log.trace('checking max connections limit %d/%d', numConnections, this.maxConnections)
+    log('checking max connections limit %d/%d', numConnections, this.maxConnections)
     if (numConnections <= this.maxConnections) {
       return
     }
@@ -64,12 +76,20 @@ export class ConnectionPruner {
         continue
       }
 
-      const tags = await this.peerStore.getTags(remotePeer)
+      peerValues.set(remotePeer, 0)
 
-      // sum all tag values
-      peerValues.set(remotePeer, tags.reduce((acc, curr) => {
-        return acc + curr.value
-      }, 0))
+      try {
+        const peer = await this.peerStore.get(remotePeer)
+
+        // sum all tag values
+        peerValues.set(remotePeer, [...peer.tags.values()].reduce((acc, curr) => {
+          return acc + curr.value
+        }, 0))
+      } catch (err: any) {
+        if (err.code !== 'ERR_NOT_FOUND') {
+          log.error('error loading peer tags', err)
+        }
+      }
     }
 
     // sort by value, lowest to highest
@@ -132,6 +152,6 @@ export class ConnectionPruner {
     )
 
     // despatch prune event
-    this.connectionManager.dispatchEvent(new CustomEvent('peer:prune', { detail: toClose.map(conn => conn.remotePeer) }))
+    this.events.safeDispatchEvent('connection:prune', { detail: toClose })
   }
 }

package/src/connection-manager/dial-queue.ts

@@ -1,7 +1,6 @@
 import { logger } from '@libp2p/logger'
 import { AbortError, CodeError } from '@libp2p/interfaces/errors'
 import { Multiaddr, Resolver, resolvers } from '@multiformats/multiaddr'
-import { TimeoutController } from 'timeout-abort-controller'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { codes } from '../errors.js'
 import {
@@ -14,7 +13,7 @@ import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import { getPeerAddress } from '../get-peer.js'
-import type { Address, AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
+import type { Address, PeerStore } from '@libp2p/interface-peer-store'
 import type { Metric, Metrics } from '@libp2p/interface-metrics'
 import type { TransportManager } from '@libp2p/interface-transport'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
@@ -22,7 +21,9 @@ import PQueue from 'p-queue'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { combineSignals, resolveMultiaddrs } from './utils.js'
 import pDefer from 'p-defer'
-import type { ClearableSignal } from 'any-signal'
+import { ClearableSignal, anySignal } from 'any-signal'
+import type { AddressSorter } from '@libp2p/interface-libp2p'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
@@ -100,6 +101,11 @@ export class DialQueue {
     this.transportManager = components.transportManager
     this.shutDownController = new AbortController()
 
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, this.shutDownController.signal)
+    } catch {}
+
     this.pendingDialCount = components.metrics?.registerMetric('libp2p_dialler_pending_dials')
     this.inProgressDialCount = components.metrics?.registerMetric('libp2p_dialler_in_progress_dials')
     this.pendingDials = []
@@ -175,7 +181,7 @@ export class DialQueue {
 
     // create abort conditions - need to do this before `calculateMultiaddrs` as we may be about to
     // resolve a dns addr which can time out
-    const { timeoutController, signal } = this.createDialAbortControllers(options.signal)
+    const signal = this.createDialAbortControllers(options.signal)
     let addrsToDial: Address[]
 
     try {
@@ -186,7 +192,6 @@ export class DialQueue {
       })
     } catch (err) {
       signal.clear()
-      timeoutController.clear()
       throw err
     }
 
@@ -209,7 +214,6 @@ export class DialQueue {
     if (existingDial != null) {
       log('joining existing dial target for %p', peerId)
       signal.clear()
-      timeoutController.clear()
       return await existingDial.promise
     }
 
@@ -232,13 +236,12 @@ export class DialQueue {
 
         // clean up abort signals/controllers
         signal.clear()
-        timeoutController.clear()
       })
       .catch(err => {
-        log.error('dial failed to %s', addrsToDial.map(({ multiaddr }) => multiaddr.toString()).join(', '), err)
+        log.error('dial failed to %s', pendingDial.multiaddrs.map(ma => ma.toString()).join(', '), err)
 
         // Error is a timeout
-        if (timeoutController.signal.aborted) {
+        if (signal.aborted) {
           const error = new CodeError(err.message, codes.ERR_TIMEOUT)
           throw error
         }
@@ -252,18 +255,21 @@ export class DialQueue {
     return await pendingDial.promise
   }
 
-  private createDialAbortControllers (userSignal?: AbortSignal): { timeoutController: TimeoutController, signal: ClearableSignal } {
-    // ensure we throw if the dial takes longer than the dial timeout
-    const timeoutController = new TimeoutController(this.dialTimeout)
-
+  private createDialAbortControllers (userSignal?: AbortSignal): ClearableSignal {
     // let any signal abort the dial
-    const signal = combineSignals(
-      timeoutController.signal,
-      this.shutDownController.signal,
-      userSignal
+    const signal = anySignal(
+      [AbortSignal.timeout(this.dialTimeout),
+        this.shutDownController.signal,
+        userSignal
+      ]
     )
 
-    return { timeoutController, signal }
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, signal)
+    } catch {}
+
+    return signal
   }
 
   private async calculateMultiaddrs (peerId?: PeerId, addrs: Address[] = [], options: DialOptions = {}): Promise<Address[]> {
@@ -280,8 +286,15 @@ export class DialQueue {
       // if just a peer id was passed, load available multiaddrs for this peer from the address book
       if (addrs.length === 0) {
         log('loading multiaddrs for %p', peerId)
-        addrs.push(...(await this.peerStore.addressBook.get(peerId)))
-        log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+        try {
+          const peer = await this.peerStore.get(peerId)
+          addrs.push(...peer.addresses)
+          log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+        } catch (err: any) {
+          if (err.code !== codes.ERR_NOT_FOUND) {
+            throw err
+          }
+        }
       }
     }
 
@@ -371,7 +384,14 @@ export class DialQueue {
       gatedAdrs.push(addr)
     }
 
-    return gatedAdrs.sort(this.addressSorter)
+    const sortedGatedAddrs = gatedAdrs.sort(this.addressSorter)
+
+    // make sure we actually have some addresses to dial
+    if (sortedGatedAddrs.length === 0) {
+      throw new CodeError('The connection gater denied all addresses in the dial request', codes.ERR_NO_VALID_ADDRESSES)
+    }
+
+    return sortedGatedAddrs
   }
 
   private async performDial (pendingDial: PendingDial, options: DialOptions = {}): Promise<Connection> {

package/src/connection-manager/index.ts

@@ -1,19 +1,18 @@
 import { logger } from '@libp2p/logger'
 import { CodeError } from '@libp2p/interfaces/errors'
 import type { AbortOptions } from '@libp2p/interfaces'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { codes } from '../errors.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { setMaxListeners } from 'events'
 import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
-import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interface-connection-manager'
-import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 import { Multiaddr, Resolver, multiaddr } from '@multiformats/multiaddr'
 import { KEEP_ALIVE } from '@libp2p/interface-peer-store/tags'
 import { RateLimiterMemory } from 'rate-limiter-flexible'
 import type { Metrics } from '@libp2p/interface-metrics'
-import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
+import type { TransportManager } from '@libp2p/interface-transport'
 import { getPeerAddress } from '../get-peer.js'
 import { AutoDial } from './auto-dial.js'
 import { DialQueue } from './dial-queue.js'
@@ -23,7 +22,7 @@ import { PeerMap } from '@libp2p/peer-collections'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import type { PendingDial } from '../libp2p.js'
+import type { PendingDial, AddressSorter, Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:connection-manager')
 
@@ -143,10 +142,10 @@ const defaultOptions = {
 export interface DefaultConnectionManagerComponents {
   peerId: PeerId
   metrics?: Metrics
-  upgrader: Upgrader
   peerStore: PeerStore
   transportManager: TransportManager
   connectionGater: ConnectionGater
+  events: EventEmitter<Libp2pEvents>
 }
 
 export interface OpenConnectionOptions extends AbortOptions {
@@ -156,7 +155,7 @@ export interface OpenConnectionOptions extends AbortOptions {
 /**
  * Responsible for managing known connections.
  */
-export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager, Startable {
+export class DefaultConnectionManager implements ConnectionManager, Startable {
   private started: boolean
   private readonly connections: PeerMap<Connection[]>
   private readonly allow: Multiaddr[]
@@ -172,10 +171,9 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
   private readonly peerStore: PeerStore
   private readonly metrics?: Metrics
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: DefaultConnectionManagerComponents, init: ConnectionManagerInit = {}) {
-    super()
-
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
     const minConnections = init.minConnections ?? defaultOptions.minConnections
 
@@ -189,17 +187,14 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.connections = new PeerMap()
 
     this.started = false
-
-    try {
-      // This emitter gets listened to a lot
-      setMaxListeners?.(Infinity, this)
-    } catch {}
-
     this.peerStore = components.peerStore
     this.metrics = components.metrics
+    this.events = components.events
 
     this.onConnect = this.onConnect.bind(this)
     this.onDisconnect = this.onDisconnect.bind(this)
+    this.events.addEventListener('connection:open', this.onConnect)
+    this.events.addEventListener('connection:close', this.onDisconnect)
 
     // allow/deny lists
     this.allow = (init.allow ?? []).map(ma => multiaddr(ma))
@@ -217,35 +212,23 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     // controls what happens when we don't have enough connections
     this.autoDial = new AutoDial({
       connectionManager: this,
-      peerStore: components.peerStore
+      peerStore: components.peerStore,
+      events: components.events
     }, {
       minConnections,
       autoDialConcurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency,
       autoDialPriority: init.autoDialPriority ?? defaultOptions.autoDialPriority
     })
-    // check the min connection limit whenever a peer disconnects
-    this.addEventListener('peer:disconnect', () => {
-      this.autoDial.autoDial()
-        .catch(err => {
-          log.error(err)
-        })
-    })
 
     // controls what happens when we have too many connections
     this.connectionPruner = new ConnectionPruner({
       connectionManager: this,
-      peerStore: components.peerStore
+      peerStore: components.peerStore,
+      events: components.events
     }, {
       maxConnections: this.maxConnections,
       allow: this.allow
     })
-    // check the max connection limit whenever a peer connects
-    this.addEventListener('peer:connect', () => {
-      this.connectionPruner.maybePruneConnections()
-        .catch(err => {
-          log.error(err)
-        })
-    })
 
     this.dialQueue = new DialQueue({
       peerId: components.peerId,
@@ -262,9 +245,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         dnsaddr: dnsaddrResolver
       }
     })
-
-    components.upgrader.addEventListener('connection', this.onConnect)
-    components.upgrader.addEventListener('connectionEnd', this.onDisconnect)
   }
 
   isStarted (): boolean {
@@ -367,10 +347,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         const keepAlivePeers: PeerId[] = []
 
         for (const peer of await this.peerStore.all()) {
-          const tags = await this.peerStore.getTags(peer.id)
-          const hasKeepAlive = tags.filter(tag => tag.name === KEEP_ALIVE).length > 0
-
-          if (hasKeepAlive) {
+          if (peer.tags.has(KEEP_ALIVE)) {
             keepAlivePeers.push(peer.id)
           }
         }
@@ -439,18 +416,25 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     const peerId = connection.remotePeer
     const storedConns = this.connections.get(peerId)
+    let isNewPeer = false
 
     if (storedConns != null) {
       storedConns.push(connection)
     } else {
+      isNewPeer = true
       this.connections.set(peerId, [connection])
     }
 
-    if (peerId.publicKey != null) {
-      await this.peerStore.keyBook.set(peerId, peerId.publicKey)
+    // only need to store RSA public keys, all other types are embedded in the peer id
+    if (peerId.publicKey != null && peerId.type === 'RSA') {
+      await this.peerStore.patch(peerId, {
+        publicKey: peerId.publicKey
+      })
     }
 
-    this.dispatchEvent(new CustomEvent<Connection>('peer:connect', { detail: connection }))
+    if (isNewPeer) {
+      this.events.safeDispatchEvent('peer:connect', { detail: connection.remotePeer })
+    }
   }
 
   /**
@@ -472,7 +456,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       this.connections.set(peerId, storedConn)
     } else if (storedConn != null) {
       this.connections.delete(peerId)
-      this.dispatchEvent(new CustomEvent<Connection>('peer:disconnect', { detail: connection }))
+      this.events.safeDispatchEvent('peer:disconnect', { detail: connection.remotePeer })
     }
   }
 
@@ -495,6 +479,10 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   }
 
   async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
+    if (!this.isStarted()) {
+      throw new CodeError('Not started', codes.ERR_NODE_NOT_STARTED)
+    }
+
     const { peerId } = getPeerAddress(peerIdOrMultiaddr)
 
     if (peerId != null) {

package/src/content-routing/index.ts

@@ -5,7 +5,6 @@ import {
   uniquePeers,
   requirePeers
 } from './utils.js'
-import drain from 'it-drain'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
@@ -13,9 +12,7 @@ import type { AbortOptions } from '@libp2p/interfaces'
 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[]
@@ -23,7 +20,6 @@ export interface CompoundContentRoutingInit {
 
 export interface CompoundContentRoutingComponents {
   peerStore: PeerStore
-  dht?: DualDHT
 }
 
 export class CompoundContentRouting implements ContentRouting, Startable {
@@ -54,7 +50,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async * findProviders (key: CID, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
-      throw new CodeError('No content this.routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new CodeError('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     yield * pipe(
@@ -87,11 +83,9 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
-    const dht = this.components.dht
-
-    if (dht != null) {
-      await drain(dht.put(key, value, options))
-    }
+    await Promise.all(this.routers.map(async (router) => {
+      await router.put(key, value, options)
+    }))
   }
 
   /**
@@ -103,50 +97,8 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
-    const dht = this.components.dht
-
-    if (dht != null) {
-      for await (const event of dht.get(key, options)) {
-        if (event.name === 'VALUE') {
-          return event.value
-        }
-      }
-    }
-
-    throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
-  }
-
-  /**
-   * Get the `n` values to the given key without sorting
-   */
-  async * getMany (key: Uint8Array, nVals: number, options: AbortOptions): AsyncIterable<{ from: PeerId, val: Uint8Array }> {
-    if (!this.isStarted()) {
-      throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
-    }
-
-    if (nVals == null || nVals === 0) {
-      return
-    }
-
-    let gotValues = 0
-    const dht = this.components.dht
-
-    if (dht != null) {
-      for await (const event of dht.get(key, options)) {
-        if (event.name === 'VALUE') {
-          yield { from: event.from, val: event.value }
-
-          gotValues++
-
-          if (gotValues === nVals) {
-            break
-          }
-        }
-      }
-    }
-
-    if (gotValues === 0) {
-      throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
-    }
+    return await Promise.any(this.routers.map(async (router) => {
+      return await router.get(key, options)
+    }))
   }
 }

package/src/content-routing/utils.ts

@@ -11,7 +11,9 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 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)
+    await peerStore.merge(peer.id, {
+      multiaddrs: peer.multiaddrs
+    })
 
     return peer
   })

package/src/fetch/index.ts

@@ -12,7 +12,6 @@ import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
-import { TimeoutController } from 'timeout-abort-controller'
 import { setMaxListeners } from 'events'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
@@ -20,15 +19,17 @@ import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 
 const log = logger('libp2p:fetch')
 
+const DEFAULT_TIMEOUT = 10000
+
 export interface FetchServiceInit {
-  protocolPrefix: string
-  maxInboundStreams: number
-  maxOutboundStreams: number
+  protocolPrefix?: string
+  maxInboundStreams?: number
+  maxOutboundStreams?: number
 
   /**
    * How long we should wait for a remote peer to send any data
    */
-  timeout: number
+  timeout?: number
 }
 
 export interface HandleMessageOptions {
@@ -45,13 +46,51 @@ export interface FetchServiceComponents {
   connectionManager: ConnectionManager
 }
 
+export interface FetchService {
+  /**
+   * The protocol name used by this fetch service
+   */
+  protocol: string
+
+  /**
+   * Sends a request to fetch the value associated with the given key from the given peer
+   */
+  fetch: (peer: PeerId, key: string, options?: AbortOptions) => Promise<Uint8Array | null>
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix
+   *
+   * @example
+   *
+   * ```js
+   * // ...
+   * libp2p.fetchService.registerLookupFunction('/prefix', (key) => { ... })
+   * ```
+   */
+  registerLookupFunction: (prefix: string, lookup: LookupFunction) => void
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix.
+   *
+   * @example
+   *
+   * ```js
+   * // ...
+   * libp2p.fetchService.unregisterLookupFunction('/prefix')
+   * ```
+   */
+  unregisterLookupFunction: (prefix: string, lookup?: LookupFunction) => void
+}
+
 /**
  * A simple libp2p protocol for requesting a value corresponding to a key from a peer.
  * Developers can register one or more lookup function for retrieving the value corresponding to
  * a given key.  Each lookup function must act on a distinct part of the overall key space, defined
  * by a fixed prefix that all keys that should be routed to that lookup function will start with.
  */
-export class FetchService implements Startable {
+class DefaultFetchService implements Startable, FetchService {
   public readonly protocol: string
   private readonly components: FetchServiceComponents
   private readonly lookupFunctions: Map<string, LookupFunction>
@@ -99,19 +138,17 @@ export class FetchService implements Startable {
     log('dialing %s to %p', this.protocol, peer)
 
     const connection = await this.components.connectionManager.openConnection(peer, options)
-    let timeoutController
     let signal = options.signal
     let stream: Stream | undefined
 
     // create a timeout if no abort signal passed
     if (signal == null) {
       log('using default timeout of %d ms', this.init.timeout)
-      timeoutController = new TimeoutController(this.init.timeout)
-      signal = timeoutController.signal
+      signal = AbortSignal.timeout(this.init.timeout ?? DEFAULT_TIMEOUT)
 
       try {
         // fails on node < 15.4
-        setMaxListeners?.(Infinity, timeoutController.signal)
+        setMaxListeners?.(Infinity, signal)
       } catch {}
     }
 
@@ -163,10 +200,6 @@ export class FetchService implements Startable {
 
       return result ?? null
     } finally {
-      if (timeoutController != null) {
-        timeoutController.clear()
-      }
-
       if (stream != null) {
         stream.close()
       }
@@ -274,3 +307,7 @@ export class FetchService implements Startable {
     this.lookupFunctions.delete(prefix)
   }
 }
+
+export function fetchService (init: FetchServiceInit = {}): (components: FetchServiceComponents) => FetchService {
+  return (components) => new DefaultFetchService(components, init)
+}