@libp2p/kad-dht 10.0.15 → 11.0.0-06e6d235f

package/src/network.ts

@@ -1,11 +1,5 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { TypedEventEmitter, CustomEvent } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
-import { abortableDuplex } from 'abortable-iterator'
-import drain from 'it-drain'
-import first from 'it-first'
-import * as lp from 'it-length-prefixed'
-import { pipe } from 'it-pipe'
+import { TypedEventEmitter, CustomEvent } from '@libp2p/interface'
+import { pbStream } from 'it-protobuf-stream'
 import { Message } from './message/index.js'
 import {
   dialPeerEvent,
@@ -14,14 +8,7 @@ import {
   queryErrorEvent
 } from './query/events.js'
 import type { KadDHTComponents, QueryEvent, QueryOptions } from './index.js'
-import type { AbortOptions } from '@libp2p/interface'
-import type { Stream } from '@libp2p/interface/connection'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { Startable } from '@libp2p/interface/startable'
-import type { Logger } from '@libp2p/logger'
-import type { Duplex, Source } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
+import type { AbortOptions, Logger, Stream, PeerId, PeerInfo, Startable } from '@libp2p/interface'
 
 export interface NetworkInit {
   protocol: string
@@ -49,7 +36,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
 
     const { protocol, lan } = init
     this.components = components
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:network`)
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:network`)
     this.running = false
     this.protocol = protocol
   }
@@ -97,7 +84,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       const connection = await this.components.connectionManager.openConnection(to, options)
       const stream = await connection.newStream(this.protocol, options)
 
-      const response = await this._writeReadMessage(stream, msg.serialize(), options)
+      const response = await this._writeReadMessage(stream, msg, options)
 
       yield peerResponseEvent({
         from: to,
@@ -133,7 +120,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       const connection = await this.components.connectionManager.openConnection(to, options)
       const stream = await connection.newStream(this.protocol, options)
 
-      await this._writeMessage(stream, msg.serialize(), options)
+      await this._writeMessage(stream, msg, options)
 
       yield peerResponseEvent({ from: to, messageType: msg.type }, options)
     } catch (err: any) {
@@ -148,17 +135,10 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   /**
    * Write a message to the given stream
    */
-  async _writeMessage (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<void> {
-    if (options.signal != null) {
-      stream = abortableDuplex(stream, options.signal)
-    }
-
-    await pipe(
-      [msg],
-      (source) => lp.encode(source),
-      stream,
-      drain
-    )
+  async _writeMessage (stream: Stream, msg: Message, options: AbortOptions): Promise<void> {
+    const pb = pbStream(stream)
+    await pb.write(msg, Message, options)
+    await pb.unwrap().close(options)
   }
 
   /**
@@ -166,28 +146,14 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
    * If no response is received after the specified timeout
    * this will error out.
    */
-  async _writeReadMessage (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<Message> {
-    if (options.signal != null) {
-      stream = abortableDuplex(stream, options.signal)
-    }
+  async _writeReadMessage (stream: Stream, msg: Message, options: AbortOptions): Promise<Message> {
+    const pb = pbStream(stream)
 
-    const res = await pipe(
-      [msg],
-      (source) => lp.encode(source),
-      stream,
-      (source) => lp.decode(source),
-      async source => {
-        const buf = await first(source)
+    await pb.write(msg, Message, options)
 
-        if (buf != null) {
-          return buf
-        }
-
-        throw new CodeError('No message received', 'ERR_NO_MESSAGE_RECEIVED')
-      }
-    )
+    const message = await pb.read(Message, options)
 
-    const message = Message.deserialize(res)
+    await pb.unwrap().close(options)
 
     // tell any listeners about new peers we've seen
     message.closerPeers.forEach(peerData => {

package/src/peer-list/index.ts

@@ -1,4 +1,4 @@
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerId } from '@libp2p/interface'
 
 /**
  * A list of unique peers.

package/src/peer-list/peer-distance-list.ts

@@ -1,7 +1,7 @@
 import { compare as uint8ArrayCompare } from 'uint8arrays/compare'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import * as utils from '../utils.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerId } from '@libp2p/interface'
 
 interface PeerDistance {
   peerId: PeerId

package/src/peer-routing/index.ts

@@ -1,6 +1,5 @@
 import { keys } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { Message, MESSAGE_TYPE } from '../message/index.js'
@@ -18,10 +17,7 @@ import type { Network } from '../network.js'
 import type { QueryManager, QueryOptions } from '../query/manager.js'
 import type { QueryFunc } from '../query/types.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { AbortOptions } from '@libp2p/interface'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { Logger } from '@libp2p/logger'
+import type { AbortOptions, Logger, PeerId, PeerInfo, PeerStore } from '@libp2p/interface'
 
 export interface PeerRoutingInit {
   routingTable: RoutingTable
@@ -32,22 +28,24 @@ export interface PeerRoutingInit {
 }
 
 export class PeerRouting {
-  private readonly components: KadDHTComponents
   private readonly log: Logger
   private readonly routingTable: RoutingTable
   private readonly network: Network
   private readonly validators: Validators
   private readonly queryManager: QueryManager
+  private readonly peerStore: PeerStore
+  private readonly peerId: PeerId
 
   constructor (components: KadDHTComponents, init: PeerRoutingInit) {
     const { routingTable, network, validators, queryManager, lan } = init
 
-    this.components = components
     this.routingTable = routingTable
     this.network = network
     this.validators = validators
     this.queryManager = queryManager
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:peer-routing`)
+    this.peerStore = components.peerStore
+    this.peerId = components.peerId
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:peer-routing`)
   }
 
   /**
@@ -62,7 +60,7 @@ export class PeerRouting {
       this.log('findPeerLocal found %p in routing table', peer)
 
       try {
-        peerData = await this.components.peerStore.get(p)
+        peerData = await this.peerStore.get(p)
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
           throw err
@@ -72,7 +70,7 @@ export class PeerRouting {
 
     if (peerData == null) {
       try {
-        peerData = await this.components.peerStore.get(peer)
+        peerData = await this.peerStore.get(peer)
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
           throw err
@@ -85,8 +83,7 @@ export class PeerRouting {
 
       return {
         id: peerData.id,
-        multiaddrs: peerData.addresses.map((address) => address.multiaddr),
-        protocols: []
+        multiaddrs: peerData.addresses.map((address) => address.multiaddr)
       }
     }
 
@@ -142,7 +139,7 @@ export class PeerRouting {
     if (pi != null) {
       this.log('found local')
       yield finalPeerEvent({
-        from: this.components.peerId,
+        from: this.peerId,
         peer: pi
       }, options)
       return
@@ -181,7 +178,7 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({ from: this.components.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') }, options)
+      yield queryErrorEvent({ from: this.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') }, options)
     }
   }
 
@@ -220,14 +217,13 @@ export class PeerRouting {
 
     for (const peerId of peers.peers) {
       try {
-        const peer = await this.components.peerStore.get(peerId)
+        const peer = await this.peerStore.get(peerId)
 
         yield finalPeerEvent({
-          from: this.components.peerId,
+          from: this.peerId,
           peer: {
             id: peerId,
-            multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr),
-            protocols: peer.protocols
+            multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
           }
         }, options)
       } catch (err: any) {
@@ -292,12 +288,11 @@ export class PeerRouting {
       }
 
       try {
-        const peer = await this.components.peerStore.get(peerId)
+        const peer = await this.peerStore.get(peerId)
 
         output.push({
           id: peerId,
-          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr),
-          protocols: peer.protocols
+          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
         })
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {

package/src/providers.ts

@@ -1,4 +1,3 @@
-import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import cache from 'hashlru'
 import { Key } from 'interface-datastore/key'
@@ -11,13 +10,10 @@ import {
   PROVIDERS_LRU_CACHE_SIZE,
   PROVIDER_KEY_PREFIX
 } from './constants.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Startable } from '@libp2p/interface/startable'
+import type { ComponentLogger, Logger, PeerId, Startable } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats'
 
-const log = logger('libp2p:kad-dht:providers')
-
 export interface ProvidersInit {
   cacheSize?: number
   /**
@@ -32,6 +28,7 @@ export interface ProvidersInit {
 
 export interface ProvidersComponents {
   datastore: Datastore
+  logger: ComponentLogger
 }
 
 /**
@@ -47,7 +44,8 @@ export interface ProvidersComponents {
  * access is fast there is an LRU cache in front of that.
  */
 export class Providers implements Startable {
-  private readonly components: ProvidersComponents
+  private readonly log: Logger
+  private readonly datastore: Datastore
   private readonly cache: ReturnType<typeof cache>
   private readonly cleanupInterval: number
   private readonly provideValidity: number
@@ -58,7 +56,8 @@ export class Providers implements Startable {
   constructor (components: ProvidersComponents, init: ProvidersInit = {}) {
     const { cacheSize, cleanupInterval, provideValidity } = init
 
-    this.components = components
+    this.log = components.logger.forComponent('libp2p:kad-dht:providers')
+    this.datastore = components.datastore
     this.cleanupInterval = cleanupInterval ?? PROVIDERS_CLEANUP_INTERVAL
     this.provideValidity = provideValidity ?? PROVIDERS_VALIDITY
     this.cache = cache(cacheSize ?? PROVIDERS_LRU_CACHE_SIZE)
@@ -83,7 +82,7 @@ export class Providers implements Startable {
     this.cleaner = setInterval(
       () => {
         this._cleanup().catch(err => {
-          log.error(err)
+          this.log.error(err)
         })
       },
       this.cleanupInterval
@@ -112,10 +111,10 @@ export class Providers implements Startable {
       let count = 0
       let deleteCount = 0
       const deleted = new Map<string, Set<string>>()
-      const batch = this.components.datastore.batch()
+      const batch = this.datastore.batch()
 
       // Get all provider entries from the datastore
-      const query = this.components.datastore.query({ prefix: PROVIDER_KEY_PREFIX })
+      const query = this.datastore.query({ prefix: PROVIDER_KEY_PREFIX })
 
       for await (const entry of query) {
         try {
@@ -126,7 +125,7 @@ export class Providers implements Startable {
           const delta = now - time
           const expired = delta > this.provideValidity
 
-          log('comparing: %d - %d = %d > %d %s', now, time, delta, this.provideValidity, expired ? '(expired)' : '')
+          this.log('comparing: %d - %d = %d > %d %s', now, time, delta, this.provideValidity, expired ? '(expired)' : '')
 
           if (expired) {
             deleteCount++
@@ -137,16 +136,16 @@ export class Providers implements Startable {
           }
           count++
         } catch (err: any) {
-          log.error(err.message)
+          this.log.error(err.message)
         }
       }
 
       // Commit the deletes to the datastore
       if (deleted.size > 0) {
-        log('deleting %d / %d entries', deleteCount, count)
+        this.log('deleting %d / %d entries', deleteCount, count)
         await batch.commit()
       } else {
-        log('nothing to delete')
+        this.log('nothing to delete')
       }
 
       // Clear expired entries from the cache
@@ -167,7 +166,7 @@ export class Providers implements Startable {
         }
       }
 
-      log('Cleanup successful (%dms)', Date.now() - start)
+      this.log('Cleanup successful (%dms)', Date.now() - start)
     })
   }
 
@@ -179,7 +178,7 @@ export class Providers implements Startable {
     let provs: Map<string, Date> = this.cache.get(cacheKey)
 
     if (provs == null) {
-      provs = await loadProviders(this.components.datastore, cid)
+      provs = await loadProviders(this.datastore, cid)
       this.cache.set(cacheKey, provs)
     }
 
@@ -191,17 +190,17 @@ export class Providers implements Startable {
    */
   async addProvider (cid: CID, provider: PeerId): Promise<void> {
     await this.syncQueue.add(async () => {
-      log('%p provides %s', provider, cid)
+      this.log('%p provides %s', provider, cid)
       const provs = await this._getProvidersMap(cid)
 
-      log('loaded %s provs', provs.size)
+      this.log('loaded %s provs', provs.size)
       const now = new Date()
       provs.set(provider.toString(), now)
 
       const dsKey = makeProviderKey(cid)
       this.cache.set(dsKey, provs)
 
-      await writeProviderEntry(this.components.datastore, cid, provider, now)
+      await writeProviderEntry(this.datastore, cid, provider, now)
     })
   }
 
@@ -210,7 +209,7 @@ export class Providers implements Startable {
    */
   async getProviders (cid: CID): Promise<PeerId[]> {
     return this.syncQueue.add(async () => {
-      log('get providers for %s', cid)
+      this.log('get providers for %s', cid)
       const provs = await this._getProvidersMap(cid)
 
       return [...provs.keys()].map(peerIdStr => {

package/src/query/events.ts

@@ -1,10 +1,9 @@
-import { CustomEvent } from '@libp2p/interface/events'
+import { CustomEvent } from '@libp2p/interface'
 import { MESSAGE_TYPE_LOOKUP } from '../message/index.js'
 import type { SendQueryEvent, PeerResponseEvent, DialPeerEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent, QueryOptions } from '../index.js'
 import type { Message } from '../message/dht.js'
 import type { Libp2pRecord } from '../record/index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerId, PeerInfo } from '@libp2p/interface'
 
 export interface QueryEventFields {
   to: PeerId

package/src/query/manager.ts

@@ -1,6 +1,4 @@
-import { AbortError } from '@libp2p/interface/errors'
-import { TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
+import { AbortError, TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
@@ -13,9 +11,7 @@ import { queryPath } from './query-path.js'
 import type { QueryFunc } from './types.js'
 import type { QueryEvent, QueryOptions as RootQueryOptions } from '../index.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { Metric, Metrics } from '@libp2p/interface/metrics'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Startable } from '@libp2p/interface/startable'
+import type { ComponentLogger, Metric, Metrics, PeerId, Startable } from '@libp2p/interface'
 import type { DeferredPromise } from 'p-defer'
 
 export interface CleanUpEvents {
@@ -33,6 +29,7 @@ export interface QueryManagerInit {
 export interface QueryManagerComponents {
   peerId: PeerId
   metrics?: Metrics
+  logger: ComponentLogger
 }
 
 export interface QueryOptions extends RootQueryOptions {
@@ -44,25 +41,24 @@ export interface QueryOptions extends RootQueryOptions {
  * Keeps track of all running queries
  */
 export class QueryManager implements Startable {
-  private readonly components: QueryManagerComponents
   private readonly lan: boolean
   public disjointPaths: number
   private readonly alpha: number
   private readonly shutDownController: AbortController
   private running: boolean
   private queries: number
-  private metrics?: {
+  private readonly logger: ComponentLogger
+  private readonly peerId: PeerId
+  private readonly routingTable: RoutingTable
+  private initialQuerySelfHasRun?: DeferredPromise<void>
+  private readonly metrics?: {
     runningQueries: Metric
     queryTime: Metric
   }
 
-  private readonly routingTable: RoutingTable
-  private initialQuerySelfHasRun?: DeferredPromise<void>
-
   constructor (components: QueryManagerComponents, init: QueryManagerInit) {
     const { lan = false, disjointPaths = K, alpha = ALPHA } = init
 
-    this.components = components
     this.disjointPaths = disjointPaths ?? K
     this.running = false
     this.alpha = alpha ?? ALPHA
@@ -70,6 +66,15 @@ export class QueryManager implements Startable {
     this.queries = 0
     this.initialQuerySelfHasRun = init.initialQuerySelfHasRun
     this.routingTable = init.routingTable
+    this.logger = components.logger
+    this.peerId = components.peerId
+
+    if (components.metrics != null) {
+      this.metrics = {
+        runningQueries: components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_running_queries`),
+        queryTime: components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_query_time_seconds`)
+      }
+    }
 
     // allow us to stop queries on shut down
     this.shutDownController = new AbortController()
@@ -86,13 +91,6 @@ export class QueryManager implements Startable {
    */
   async start (): Promise<void> {
     this.running = true
-
-    if (this.components.metrics != null && this.metrics == null) {
-      this.metrics = {
-        runningQueries: this.components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_running_queries`),
-        queryTime: this.components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_query_time_seconds`)
-      }
-    }
   }
 
   /**
@@ -131,7 +129,7 @@ export class QueryManager implements Startable {
     // so make sure we don't make a lot of noise in the logs
     setMaxListeners(Infinity, signal)
 
-    const log = logger(`libp2p:kad-dht:${this.lan ? 'lan' : 'wan'}:query:` + uint8ArrayToString(key, 'base58btc'))
+    const log = this.logger.forComponent(`libp2p:kad-dht:${this.lan ? 'lan' : 'wan'}:query:` + uint8ArrayToString(key, 'base58btc'))
 
     // query a subset of peers up to `kBucketSize / 2` in length
     const startTime = Date.now()
@@ -174,7 +172,7 @@ export class QueryManager implements Startable {
         return queryPath({
           key,
           startingPeer: peer,
-          ourPeerId: this.components.peerId,
+          ourPeerId: this.peerId,
           signal,
           query: queryFunc,
           pathIndex: index,

package/src/query/query-path.ts

@@ -8,9 +8,7 @@ import { queueToGenerator } from './utils.js'
 import type { CleanUpEvents } from './manager.js'
 import type { QueryEvent, QueryOptions } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
-import type { TypedEventTarget } from '@libp2p/interface/events'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Logger } from '@libp2p/logger'
+import type { Logger, TypedEventTarget, PeerId } from '@libp2p/interface'
 import type { PeerSet } from '@libp2p/peer-collections'
 
 const MAX_XOR = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')

package/src/query/types.ts

@@ -1,5 +1,5 @@
 import type { QueryEvent } from '../index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerId } from '@libp2p/interface'
 
 export interface QueryContext {
   // the key we are looking up

package/src/query/utils.ts

@@ -1,9 +1,8 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { pushable } from 'it-pushable'
 import type { CleanUpEvents } from './manager.js'
 import type { QueryEvent } from '../index.js'
-import type { TypedEventTarget } from '@libp2p/interface/events'
-import type { Logger } from '@libp2p/logger'
+import type { Logger, TypedEventTarget } from '@libp2p/interface'
 import type Queue from 'p-queue'
 
 export async function * queueToGenerator (queue: Queue, signal: AbortSignal, cleanUp: TypedEventTarget<CleanUpEvents>, log: Logger): AsyncGenerator<QueryEvent, void, undefined> {

package/src/query-self.ts

@@ -1,5 +1,4 @@
-import { setMaxListeners } from '@libp2p/interface/events'
-import { logger, type Logger } from '@libp2p/logger'
+import { setMaxListeners } from '@libp2p/interface'
 import { anySignal } from 'any-signal'
 import length from 'it-length'
 import { pipe } from 'it-pipe'
@@ -9,8 +8,7 @@ import { pEvent } from 'p-event'
 import { QUERY_SELF_INTERVAL, QUERY_SELF_TIMEOUT, K, QUERY_SELF_INITIAL_INTERVAL } from './constants.js'
 import type { PeerRouting } from './peer-routing/index.js'
 import type { RoutingTable } from './routing-table/index.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Startable } from '@libp2p/interface/startable'
+import type { ComponentLogger, Logger, PeerId, Startable } from '@libp2p/interface'
 import type { DeferredPromise } from 'p-defer'
 
 export interface QuerySelfInit {
@@ -26,6 +24,7 @@ export interface QuerySelfInit {
 
 export interface QuerySelfComponents {
   peerId: PeerId
+  logger: ComponentLogger
 }
 
 /**
@@ -33,7 +32,7 @@ export interface QuerySelfComponents {
  */
 export class QuerySelf implements Startable {
   private readonly log: Logger
-  private readonly components: QuerySelfComponents
+  private readonly peerId: PeerId
   private readonly peerRouting: PeerRouting
   private readonly routingTable: RoutingTable
   private readonly count: number
@@ -49,8 +48,8 @@ export class QuerySelf implements Startable {
   constructor (components: QuerySelfComponents, init: QuerySelfInit) {
     const { peerRouting, lan, count, interval, queryTimeout, routingTable } = init
 
-    this.components = components
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:query-self`)
+    this.peerId = components.peerId
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:query-self`)
     this.started = false
     this.peerRouting = peerRouting
     this.routingTable = routingTable
@@ -125,7 +124,7 @@ export class QuerySelf implements Startable {
         const start = Date.now()
 
         const found = await pipe(
-          this.peerRouting.getClosestPeers(this.components.peerId.toBytes(), {
+          this.peerRouting.getClosestPeers(this.peerId.toBytes(), {
             signal,
             isSelfQuery: true
           }),

package/src/record/selectors.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import type { Selectors } from '../index.js'
 

package/src/record/validators.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'

package/src/routing-table/index.ts

@@ -1,15 +1,10 @@
-import { TypedEventEmitter } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import Queue from 'p-queue'
 import * as utils from '../utils.js'
 import { KBucket, type PingEventDetails } from './k-bucket.js'
-import type { Metric, Metrics } from '@libp2p/interface/metrics'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerStore } from '@libp2p/interface/peer-store'
-import type { Startable } from '@libp2p/interface/startable'
-import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
-import type { Logger } from '@libp2p/logger'
+import type { ComponentLogger, Logger, Metric, Metrics, PeerId, PeerStore, Startable } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
 
 export const KAD_CLOSE_TAG_NAME = 'kad-close'
 export const KAD_CLOSE_TAG_VALUE = 50
@@ -32,6 +27,7 @@ export interface RoutingTableComponents {
   peerStore: PeerStore
   connectionManager: ConnectionManager
   metrics?: Metrics
+  logger: ComponentLogger
 }
 
 export interface RoutingTableEvents {
@@ -69,7 +65,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     const { kBucketSize, pingTimeout, lan, pingConcurrency, protocol, tagName, tagValue } = init
 
     this.components = components
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table`)
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table`)
     this.kBucketSize = kBucketSize ?? KBUCKET_SIZE
     this.pingTimeout = pingTimeout ?? PING_TIMEOUT
     this.pingConcurrency = pingConcurrency ?? PING_CONCURRENCY

package/src/routing-table/k-bucket.ts

@@ -27,8 +27,8 @@ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 */
 
-import { TypedEventEmitter } from '@libp2p/interface/events'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import { TypedEventEmitter } from '@libp2p/interface'
+import type { PeerId } from '@libp2p/interface'
 
 function arrayEquals (array1: Uint8Array, array2: Uint8Array): boolean {
   if (array1 === array2) {