libp2p 0.45.0 → 0.45.1

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

@@ -1,29 +1,29 @@
-import { logger } from '@libp2p/logger'
+import { setMaxListeners } from 'events'
 import { AbortError, CodeError } from '@libp2p/interfaces/errors'
-import { Multiaddr, Resolver, resolvers } from '@multiformats/multiaddr'
+import { logger } from '@libp2p/logger'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
+import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+import { type ClearableSignal, anySignal } from 'any-signal'
+import pDefer from 'p-defer'
+import PQueue from 'p-queue'
 import { codes } from '../errors.js'
+import { getPeerAddress } from '../get-peer.js'
 import {
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS_PER_PEER,
   MAX_PARALLEL_DIALS,
   MAX_PEER_ADDRS_TO_DIAL
 } from './constants.js'
+import { combineSignals, resolveMultiaddrs } from './utils.js'
 import type { Connection } from '@libp2p/interface-connection'
-import type { AbortOptions } from '@libp2p/interfaces'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { AddressSorter } from '@libp2p/interface-libp2p'
+import type { Metric, Metrics } from '@libp2p/interface-metrics'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { getPeerAddress } from '../get-peer.js'
 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'
-import PQueue from 'p-queue'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import { combineSignals, resolveMultiaddrs } from './utils.js'
-import pDefer from 'p-defer'
-import { ClearableSignal, anySignal } from 'any-signal'
-import type { AddressSorter } from '@libp2p/interface-libp2p'
-import { setMaxListeners } from 'events'
+import type { AbortOptions } from '@libp2p/interfaces'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
@@ -214,7 +214,7 @@ export class DialQueue {
     if (existingDial != null) {
       log('joining existing dial target for %p', peerId)
       signal.clear()
-      return await existingDial.promise
+      return existingDial.promise
     }
 
     log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
@@ -252,7 +252,7 @@ export class DialQueue {
     // let other dials join this one
     this.pendingDials.push(pendingDial)
 
-    return await pendingDial.promise
+    return pendingDial.promise
   }
 
   private createDialAbortControllers (userSignal?: AbortSignal): ClearableSignal {
@@ -272,6 +272,7 @@ export class DialQueue {
     return signal
   }
 
+  // eslint-disable-next-line complexity
   private async calculateMultiaddrs (peerId?: PeerId, addrs: Address[] = [], options: DialOptions = {}): Promise<Address[]> {
     // if a peer id or multiaddr(s) with a peer id, make sure it isn't our peer id and that we are allowed to dial it
     if (peerId != null) {
@@ -319,7 +320,7 @@ export class DialQueue {
     const filteredAddrs = resolvedAddresses.filter(addr => Boolean(this.transportManager.transportForMultiaddr(addr.multiaddr)))
 
     // deduplicate addresses
-    const dedupedAddrs: Map<string, Address> = new Map()
+    const dedupedAddrs = new Map<string, Address>()
 
     for (const addr of filteredAddrs) {
       const maStr = addr.multiaddr.toString()
@@ -491,7 +492,7 @@ export class DialQueue {
           signal.clear()
         })
 
-        return await deferred.promise
+        return deferred.promise
       }))
 
       // dial succeeded or failed

package/src/connection-manager/index.ts

@@ -1,28 +1,28 @@
-import { logger } from '@libp2p/logger'
-import { CodeError } from '@libp2p/interfaces/errors'
-import type { AbortOptions } from '@libp2p/interfaces'
-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 type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
-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 { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
+import { PeerMap } from '@libp2p/peer-collections'
+import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import { type Multiaddr, type Resolver, multiaddr } from '@multiformats/multiaddr'
+import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { RateLimiterMemory } from 'rate-limiter-flexible'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { TransportManager } from '@libp2p/interface-transport'
+import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import { AutoDial } from './auto-dial.js'
-import { DialQueue } from './dial-queue.js'
 import { ConnectionPruner } from './connection-pruner.js'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-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 { DialQueue } from './dial-queue.js'
+import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { PendingDial, AddressSorter, Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:connection-manager')
 

package/src/connection-manager/utils.ts

@@ -1,8 +1,7 @@
-import { AbortOptions, multiaddr } from '@multiformats/multiaddr'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { logger } from '@libp2p/logger'
-import { ClearableSignal, anySignal } from 'any-signal'
 import { setMaxListeners } from 'events'
+import { logger } from '@libp2p/logger'
+import { type AbortOptions, multiaddr, type Multiaddr } from '@multiformats/multiaddr'
+import { type ClearableSignal, anySignal } from 'any-signal'
 
 const log = logger('libp2p:connection-manager:utils')
 
@@ -21,7 +20,7 @@ export async function resolveMultiaddrs (ma: Multiaddr, options: AbortOptions):
 
   const resolvedMultiaddrs = await resolveRecord(ma, options)
   const recursiveMultiaddrs = await Promise.all(resolvedMultiaddrs.map(async (nm) => {
-    return await resolveMultiaddrs(nm, options)
+    return resolveMultiaddrs(nm, options)
   }))
 
   const addrs = recursiveMultiaddrs.flat()

package/src/content-routing/index.ts

@@ -1,18 +1,18 @@
 import { CodeError } from '@libp2p/interfaces/errors'
+import merge from 'it-merge'
+import { pipe } from 'it-pipe'
 import { messages, codes } from '../errors.js'
 import {
   storeAddresses,
   uniquePeers,
   requirePeers
 } from './utils.js'
-import merge from 'it-merge'
-import { pipe } from 'it-pipe'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 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 { PeerInfo } from '@libp2p/interface-peer-info'
 
 export interface CompoundContentRoutingInit {
   routers: ContentRouting[]
@@ -97,8 +97,8 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
-    return await Promise.any(this.routers.map(async (router) => {
-      return await router.get(key, options)
+    return Promise.any(this.routers.map(async (router) => {
+      return router.get(key, options)
     }))
   }
 }

package/src/content-routing/utils.ts

@@ -1,9 +1,9 @@
 import { CodeError } from '@libp2p/interfaces/errors'
 import filter from 'it-filter'
 import map from 'it-map'
-import type { Source } from 'it-stream-types'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { Source } from 'it-stream-types'
 
 /**
  * Store the multiaddrs from every peer in the passed peer store

package/src/fetch/index.ts

@@ -1,21 +1,21 @@
-import { logger } from '@libp2p/logger'
+import { setMaxListeners } from 'events'
 import { CodeError } from '@libp2p/interfaces/errors'
-import { codes } from '../errors.js'
-import * as lp from 'it-length-prefixed'
-import { FetchRequest, FetchResponse } from './pb/proto.js'
-import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { Stream } from '@libp2p/interface-connection'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
+import { logger } from '@libp2p/logger'
 import { abortableDuplex } from 'abortable-iterator'
-import { pipe } from 'it-pipe'
 import first from 'it-first'
-import { setMaxListeners } from 'events'
+import * as lp from 'it-length-prefixed'
+import { pipe } from 'it-pipe'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
+import { codes } from '../errors.js'
+import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
+import { FetchRequest, FetchResponse } from './pb/proto.js'
+import type { Stream } from '@libp2p/interface-connection'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:fetch')
 

package/src/get-peer.ts

@@ -1,11 +1,11 @@
+import { isPeerId } from '@libp2p/interface-peer-id'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { Multiaddr } from '@multiformats/multiaddr'
 import { isMultiaddr } from '@multiformats/multiaddr'
-import { CodeError } from '@libp2p/interfaces/errors'
 import { codes } from './errors.js'
-import { isPeerId } from '@libp2p/interface-peer-id'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { logger } from '@libp2p/logger'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:get-peer')
 

package/src/identify/identify.ts

@@ -1,12 +1,19 @@
-import { logger } from '@libp2p/logger'
+import { setMaxListeners } from 'events'
 import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
+import { peerIdFromKeys } from '@libp2p/peer-id'
+import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
+import { type Multiaddr, multiaddr, protocols } from '@multiformats/multiaddr'
+import { abortableDuplex } from 'abortable-iterator'
+import { anySignal } from 'any-signal'
+import first from 'it-first'
 import * as lp from 'it-length-prefixed'
+import { pbStream } from 'it-pb-stream'
 import { pipe } from 'it-pipe'
-import first from 'it-first'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { Multiaddr, multiaddr, protocols } from '@multiformats/multiaddr'
-import { Identify } from './pb/message.js'
-import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isReactNative } from 'wherearewe'
+import { codes } from '../errors.js'
 import {
   AGENT_VERSION,
   IDENTIFY_PROTOCOL_VERSION,
@@ -15,25 +22,18 @@ import {
   MULTICODEC_IDENTIFY_PROTOCOL_VERSION,
   MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION
 } from './consts.js'
-import { codes } from '../errors.js'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import { Identify } from './pb/message.js'
+import type { IdentifyServiceComponents, IdentifyServiceInit } from './index.js'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { Startable } from '@libp2p/interfaces/startable'
-import { peerIdFromKeys } from '@libp2p/peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
-import { abortableDuplex } from 'abortable-iterator'
-import { setMaxListeners } from 'events'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Libp2pEvents, IdentifyResult, SignedPeerRecord } from '@libp2p/interface-libp2p'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Peer, PeerStore } from '@libp2p/interface-peer-store'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import { anySignal } from 'any-signal'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { pbStream } from 'it-pb-stream'
-import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isReactNative } from 'wherearewe'
-import type { IdentifyServiceComponents, IdentifyServiceInit } from './index.js'
-import type { Libp2pEvents, IdentifyResult, SignedPeerRecord } from '@libp2p/interface-libp2p'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { AbortOptions } from '@libp2p/interfaces'
 import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:identify')
 
@@ -277,7 +277,7 @@ export class DefaultIdentifyService implements Startable {
         (source) => lp.decode(source, {
           maxDataLength: this.maxIdentifyMessageSize ?? MAX_IDENTIFY_MESSAGE_SIZE
         }),
-        async (source) => await first(source)
+        async (source) => first(source)
       )
 
       if (data == null) {
@@ -439,8 +439,9 @@ export class DefaultIdentifyService implements Startable {
       return
     }
 
-    const envelope = await RecordEnvelope.openAndCertify(message.signedPeerRecord, PeerRecord.DOMAIN)
-    const peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
+    let peerRecordEnvelope = message.signedPeerRecord
+    const envelope = await RecordEnvelope.openAndCertify(peerRecordEnvelope, PeerRecord.DOMAIN)
+    let peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
 
     // Verify peerId
     if (!peerRecord.peerId.equals(envelope.peerId)) {
@@ -463,7 +464,7 @@ export class DefaultIdentifyService implements Startable {
     }
 
     log('received signedPeerRecord in push from %p', remotePeer)
-    let metadata = new Map()
+    const metadata = peer?.metadata ?? new Map()
 
     if (peer?.peerRecordEnvelope != null) {
       const storedEnvelope = await RecordEnvelope.createFromProtobuf(peer.peerRecordEnvelope)
@@ -472,9 +473,9 @@ export class DefaultIdentifyService implements Startable {
       // ensure seq is greater than, or equal to, the last received
       if (storedRecord.seqNumber >= peerRecord.seqNumber) {
         log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
+        peerRecord = storedRecord
+        peerRecordEnvelope = peer.peerRecordEnvelope
       }
-
-      metadata = peer.metadata
     }
 
     if (message.agentVersion != null) {
@@ -486,7 +487,7 @@ export class DefaultIdentifyService implements Startable {
     }
 
     await this.peerStore.patch(peerRecord.peerId, {
-      peerRecordEnvelope: message.signedPeerRecord,
+      peerRecordEnvelope,
       protocols: message.protocols,
       addresses: peerRecord.multiaddrs.map(multiaddr => ({
         isCertified: true,

package/src/identify/index.ts

@@ -1,16 +1,16 @@
-import { Identify } from './pb/message.js'
 import {
   MULTICODEC_IDENTIFY,
   MULTICODEC_IDENTIFY_PUSH
 } from './consts.js'
-import type { Registrar } from '@libp2p/interface-registrar'
+import { DefaultIdentifyService } from './identify.js'
+import { Identify } from './pb/message.js'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { AddressManager } from '@libp2p/interface-address-manager'
+import type { Registrar } from '@libp2p/interface-registrar'
 import type { EventEmitter } from '@libp2p/interfaces/events'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import { DefaultIdentifyService } from './identify.js'
 
 export interface IdentifyServiceInit {
   /**
@@ -60,6 +60,6 @@ export const multicodecs = {
 
 export const Message = { Identify }
 
-export function identifyService (init: IdentifyServiceInit = {}): (components: IdentifyServiceComponents) => {} {
+export function identifyService (init: IdentifyServiceInit = {}): (components: IdentifyServiceComponents) => DefaultIdentifyService {
   return (components) => new DefaultIdentifyService(components, init)
 }

package/src/index.ts

@@ -15,25 +15,25 @@
  */
 
 import { createLibp2pNode } from './libp2p.js'
-import type { RecursivePartial } from '@libp2p/interfaces'
+import type { AddressManagerInit } from './address-manager/index.js'
+import type { Components } from './components.js'
+import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { TransportManagerInit } from './transport-manager.js'
-import type { Datastore } from 'interface-datastore'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
 import type { ConnectionProtector } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { Transport } from '@libp2p/interface-transport'
-import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
 import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { Components } from './components.js'
 import type { Libp2p, ServiceMap } from '@libp2p/interface-libp2p'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
+import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
+import type { Transport } from '@libp2p/interface-transport'
+import type { RecursivePartial } from '@libp2p/interfaces'
 import type { KeyChainInit } from '@libp2p/keychain'
-import type { AddressManagerInit } from './address-manager/index.js'
-import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
+import type { Datastore } from 'interface-datastore'
 
 export type ServiceFactoryMap<T extends Record<string, unknown> = Record<string, unknown>> = {
   [Property in keyof T]: (components: Components) => T[Property]
@@ -42,7 +42,7 @@ export type ServiceFactoryMap<T extends Record<string, unknown> = Record<string,
 /**
  * For Libp2p configurations and modules details read the [Configuration Document](./CONFIGURATION.md).
  */
-export interface Libp2pInit<T extends ServiceMap = {}> {
+export interface Libp2pInit<T extends ServiceMap = { x: Record<string, unknown> }> {
   /**
    * peerId instance (it will be created if not provided)
    */
@@ -113,7 +113,7 @@ export interface Libp2pInit<T extends ServiceMap = {}> {
 
 export type { Libp2p }
 
-export type Libp2pOptions<T extends ServiceMap = {}> = RecursivePartial<Libp2pInit<T>> & { start?: boolean }
+export type Libp2pOptions<T extends ServiceMap = Record<string, unknown>> = RecursivePartial<Libp2pInit<T>> & { start?: boolean }
 
 /**
  * Returns a new instance of the Libp2p interface, generating a new PeerId
@@ -141,7 +141,7 @@ export type Libp2pOptions<T extends ServiceMap = {}> = RecursivePartial<Libp2pIn
  * const libp2p = await createLibp2p(options)
  * ```
  */
-export async function createLibp2p <T extends ServiceMap = {}> (options: Libp2pOptions<T>): Promise<Libp2p<T>> {
+export async function createLibp2p <T extends ServiceMap = { x: Record<string, unknown> }> (options: Libp2pOptions<T>): Promise<Libp2p<T>> {
   const node = await createLibp2pNode(options)
 
   if (options.start !== false) {

package/src/insecure/index.ts

@@ -22,16 +22,16 @@
  * ```
  */
 
+import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interface-connection-encrypter/errors'
 import { logger } from '@libp2p/logger'
+import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import { handshake } from 'it-handshake'
 import * as lp from 'it-length-prefixed'
-import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interface-connection-encrypter/errors'
+import map from 'it-map'
 import { Exchange, KeyType } from './pb/proto.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Duplex, Source } from 'it-stream-types'
-import map from 'it-map'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const log = logger('libp2p:plaintext')
@@ -125,11 +125,11 @@ class Plaintext implements ConnectionEncrypter {
   public protocol: string = PROTOCOL
 
   async secureInbound (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
-    return await encrypt(localId, conn, remoteId)
+    return encrypt(localId, conn, remoteId)
   }
 
   async secureOutbound (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
-    return await encrypt(localId, conn, remoteId)
+    return encrypt(localId, conn, remoteId)
   }
 }
 

package/src/libp2p.ts

@@ -1,48 +1,48 @@
-import { logger } from '@libp2p/logger'
-import type { AbortOptions } from '@libp2p/interfaces'
+import { setMaxListeners } from 'events'
+import { unmarshalPublicKey } from '@libp2p/crypto/keys'
+import { type ContentRouting, contentRouting } from '@libp2p/interface-content-routing'
+import { peerDiscovery } from '@libp2p/interface-peer-discovery'
+import { type PeerRouting, peerRouting } from '@libp2p/interface-peer-routing'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
-import { isMultiaddr, Multiaddr } from '@multiformats/multiaddr'
+import { DefaultKeyChain } from '@libp2p/keychain'
+import { logger } from '@libp2p/logger'
+import { PeerSet } from '@libp2p/peer-collections'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { PersistentPeerStore } from '@libp2p/peer-store'
+import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
-import { DefaultPeerRouting } from './peer-routing.js'
-import { CompoundContentRouting } from './content-routing/index.js'
-import { codes } from './errors.js'
+import mergeOptions from 'merge-options'
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DefaultAddressManager } from './address-manager/index.js'
+import { defaultComponents } from './components.js'
+import { connectionGater } from './config/connection-gater.js'
+import { validateConfig } from './config.js'
 import { DefaultConnectionManager } from './connection-manager/index.js'
-import { DefaultKeyChain } from '@libp2p/keychain'
+import { CompoundContentRouting } from './content-routing/index.js'
+import { codes } from './errors.js'
+import { DefaultPeerRouting } from './peer-routing.js'
+import { DefaultRegistrar } from './registrar.js'
 import { DefaultTransportManager } from './transport-manager.js'
 import { DefaultUpgrader } from './upgrader.js'
-import { DefaultRegistrar } from './registrar.js'
-import { PersistentPeerStore } from '@libp2p/peer-store'
-import { defaultComponents } from './components.js'
 import type { Components } from './components.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { StreamHandler, StreamHandlerOptions, Topology } from '@libp2p/interface-registrar'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { Libp2p, Libp2pInit, Libp2pOptions } from './index.js'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { CodeError } from '@libp2p/interfaces/errors'
-import type { Metrics } from '@libp2p/interface-metrics'
-import { PeerSet } from '@libp2p/peer-collections'
+import type { Connection, Stream } from '@libp2p/interface-connection'
 import type { KeyChain } from '@libp2p/interface-keychain'
 import type { Libp2pEvents, PendingDial, ServiceMap } from '@libp2p/interface-libp2p'
-import { setMaxListeners } from 'events'
-import { unmarshalPublicKey } from '@libp2p/crypto/keys'
-import { peerIdFromString } from '@libp2p/peer-id'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { StreamHandler, StreamHandlerOptions, Topology } from '@libp2p/interface-registrar'
+import type { AbortOptions } from '@libp2p/interfaces'
 import type { Datastore } from 'interface-datastore'
-import mergeOptions from 'merge-options'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-import { validateConfig } from './config.js'
-import { ContentRouting, contentRouting } from '@libp2p/interface-content-routing'
-import { PeerRouting, peerRouting } from '@libp2p/interface-peer-routing'
-import { peerDiscovery } from '@libp2p/interface-peer-discovery'
-import { connectionGater } from './config/connection-gater.js'
 
 const log = logger('libp2p')
 
-export class Libp2pNode<T extends ServiceMap = {}> extends EventEmitter<Libp2pEvents> implements Libp2p<T> {
+export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends EventEmitter<Libp2pEvents> implements Libp2p<T> {
   public peerId: PeerId
   public peerStore: PeerStore
   public contentRouting: ContentRouting
@@ -277,7 +277,7 @@ export class Libp2pNode<T extends ServiceMap = {}> extends EventEmitter<Libp2pEv
   }
 
   async dial (peer: PeerId | Multiaddr | Multiaddr[], options: AbortOptions = {}): Promise<Connection> {
-    return await this.components.connectionManager.openConnection(peer, options)
+    return this.components.connectionManager.openConnection(peer, options)
   }
 
   async dialProtocol (peer: PeerId | Multiaddr | Multiaddr[], protocols: string | string[], options: AbortOptions = {}): Promise<Stream> {
@@ -293,7 +293,7 @@ export class Libp2pNode<T extends ServiceMap = {}> extends EventEmitter<Libp2pEv
 
     const connection = await this.dial(peer, options)
 
-    return await connection.newStream(protocols, options)
+    return connection.newStream(protocols, options)
   }
 
   getMultiaddrs (): Multiaddr[] {
@@ -370,7 +370,7 @@ export class Libp2pNode<T extends ServiceMap = {}> extends EventEmitter<Libp2pEv
   }
 
   async register (protocol: string, topology: Topology): Promise<string> {
-    return await this.components.registrar.register(protocol, topology)
+    return this.components.registrar.register(protocol, topology)
   }
 
   unregister (id: string): void {
@@ -401,7 +401,7 @@ export class Libp2pNode<T extends ServiceMap = {}> extends EventEmitter<Libp2pEv
  * Returns a new Libp2pNode instance - this exposes more of the internals than the
  * libp2p interface and is useful for testing and debugging.
  */
-export async function createLibp2pNode <T extends ServiceMap = {}> (options: Libp2pOptions<T>): Promise<Libp2pNode<T>> {
+export async function createLibp2pNode <T extends ServiceMap = Record<string, unknown>> (options: Libp2pOptions<T>): Promise<Libp2pNode<T>> {
   if (options.peerId == null) {
     const datastore = options.datastore as Datastore | undefined
 

package/src/peer-routing.ts

@@ -1,20 +1,20 @@
-import { logger } from '@libp2p/logger'
 import { CodeError } from '@libp2p/interfaces/errors'
-import { codes, messages } from './errors.js'
+import { logger } from '@libp2p/logger'
+import filter from 'it-filter'
+import first from 'it-first'
+import merge from 'it-merge'
+import { pipe } from 'it-pipe'
 import {
   storeAddresses,
   uniquePeers,
   requirePeers
 } from './content-routing/utils.js'
-import merge from 'it-merge'
-import { pipe } from 'it-pipe'
-import first from 'it-first'
-import filter from 'it-filter'
+import { codes, messages } from './errors.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { AbortOptions } from '@libp2p/interfaces'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { AbortOptions } from '@libp2p/interfaces'
 
 const log = logger('libp2p:peer-routing')
 
@@ -60,7 +60,7 @@ export class DefaultPeerRouting implements PeerRouting {
       ),
       (source) => filter(source, Boolean),
       (source) => storeAddresses(source, this.components.peerStore),
-      async (source) => await first(source)
+      async (source) => first(source)
     )
 
     if (output != null) {