@libp2p/kad-dht 1.0.0 → 1.0.3

package/src/kad-dht.ts

@@ -14,92 +14,48 @@ import {
   removePublicAddresses
 } from './utils.js'
 import { Logger, logger } from '@libp2p/logger'
-import type { DHT, QueryOptions, Validators, Selectors } from '@libp2p/interfaces/dht'
-import type { PeerData } from '@libp2p/interfaces/peer-data'
+import type { QueryOptions, Validators, Selectors, DHT } from '@libp2p/interfaces/dht'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces'
-import type { Addressable, Dialer } from '@libp2p/interfaces'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { PeerStore } from '@libp2p/interfaces/peer-store'
-import type { ComponentMetricsTracker } from '@libp2p/interfaces/metrics'
-import type { Datastore } from 'interface-datastore'
-import type { Registrar } from '@libp2p/interfaces/registrar'
 import type { CID } from 'multiformats/cid'
 import type { PeerDiscoveryEvents } from '@libp2p/interfaces/peer-discovery'
-
-export interface KadDHTOptions {
-  /**
-   * libp2p registrar handle protocol
-   */
-  protocol: string
-
-  /**
-   * k-bucket size (default 20)
-   */
-  kBucketSize?: number
-
-  /**
-   * If true, the DHT will not respond to queries. This should be true if your node will not be dialable. (default: false)
-   */
-  clientMode?: boolean
-
-  /**
-   * validators object with namespace as keys and function(key, record, callback)
-   */
-  validators: Validators
-
-  /**
-   * selectors object with namespace as keys and function(key, records)
-   */
-  selectors: Selectors
-
-  /**
-   * how often to search the network for peers close to ourselves
-   */
-  querySelfInterval: number
-  lan: boolean
-  bootstrapPeers: PeerData[]
-  dialer: Dialer
-  addressable: Addressable
-  peerStore: PeerStore
-  peerId: PeerId
-  datastore: Datastore
-  registrar: Registrar
-  metrics?: ComponentMetricsTracker
-}
+import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { KadDHTInit } from './index.js'
+import { validators as recordValidators } from '@libp2p/record/validators'
+import { selectors as recordSelectors } from '@libp2p/record/selectors'
 
 /**
  * A DHT implementation modelled after Kademlia with S/Kademlia modifications.
  * Original implementation in go: https://github.com/libp2p/go-libp2p-kad-dht.
  */
-export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
+export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT, Initializable {
+  public protocol: string
+  public routingTable: RoutingTable
+  public providers: Providers
+  public network: Network
+  public peerRouting: PeerRouting
+
+  public components: Components = new Components()
   private readonly log: Logger
   private running: boolean
-  public protocol: string
   private readonly kBucketSize: number
   private clientMode: boolean
-  private readonly bootstrapPeers: PeerData[]
-  public routingTable: RoutingTable
-  public providers: Providers
   private readonly lan: boolean
   private readonly validators: Validators
   private readonly selectors: Selectors
-  public network: Network
   private readonly queryManager: QueryManager
-  public peerRouting: PeerRouting
   private readonly contentFetching: ContentFetching
   private readonly contentRouting: ContentRouting
   private readonly routingTableRefresh: RoutingTableRefresh
   private readonly rpc: RPC
   private readonly topologyListener: TopologyListener
   private readonly querySelf: QuerySelf
-  public addressable: Addressable
-  public registrar: Registrar
-  private registrarHandleId?: string
 
   /**
    * Create a new KadDHT
    */
-  constructor (options: KadDHTOptions) {
+  constructor (init: KadDHTInit) {
     super()
 
     const {
@@ -109,110 +65,85 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
       selectors,
       querySelfInterval,
       lan,
-      protocol,
-      bootstrapPeers,
-      dialer,
-      addressable,
-      peerId,
-      peerStore,
-      metrics,
-      datastore,
-      registrar
-    } = options
+      protocolPrefix
+    } = init
 
     this.running = false
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}`)
-    this.protocol = protocol ?? '/ipfs/kad/1.0.0'
+    this.lan = Boolean(lan)
+    this.log = logger(`libp2p:kad-dht:${lan === true ? 'lan' : 'wan'}`)
+    this.protocol = `${protocolPrefix ?? '/ipfs'}${lan === true ? '/lan' : ''}/kad/1.0.0`
     this.kBucketSize = kBucketSize ?? 20
     this.clientMode = clientMode ?? true
-    this.bootstrapPeers = bootstrapPeers ?? []
-    this.addressable = addressable
-    this.registrar = registrar
     this.routingTable = new RoutingTable({
-      peerId,
-      dialer,
       kBucketSize,
-      metrics,
-      lan
+      lan: this.lan
     })
 
-    this.providers = new Providers({
-      datastore
-    })
-    this.lan = lan
-    this.validators = validators ?? {}
-    this.selectors = selectors ?? {}
+    this.providers = new Providers()
+
+    this.validators = {
+      ...recordValidators,
+      ...validators
+    }
+    this.selectors = {
+      ...recordSelectors,
+      ...selectors
+    }
     this.network = new Network({
-      dialer,
       protocol: this.protocol,
-      lan,
-      peerId
+      lan: this.lan
     })
     this.queryManager = new QueryManager({
-      peerId: peerId,
       // Number of disjoint query paths to use - This is set to `kBucketSize/2` per the S/Kademlia paper
       disjointPaths: Math.ceil(this.kBucketSize / 2),
-      metrics,
       lan
     })
 
     // DHT components
     this.peerRouting = new PeerRouting({
-      peerId,
       routingTable: this.routingTable,
-      peerStore,
       network: this.network,
       validators: this.validators,
       queryManager: this.queryManager,
-      lan
+      lan: this.lan
     })
     this.contentFetching = new ContentFetching({
-      peerId,
-      datastore,
       validators: this.validators,
       selectors: this.selectors,
       peerRouting: this.peerRouting,
       queryManager: this.queryManager,
       routingTable: this.routingTable,
       network: this.network,
-      lan
+      lan: this.lan
     })
     this.contentRouting = new ContentRouting({
-      peerId,
       network: this.network,
       peerRouting: this.peerRouting,
       queryManager: this.queryManager,
       routingTable: this.routingTable,
       providers: this.providers,
-      peerStore,
-      lan
+      lan: this.lan
     })
     this.routingTableRefresh = new RoutingTableRefresh({
       peerRouting: this.peerRouting,
       routingTable: this.routingTable,
-      lan
+      lan: this.lan
     })
     this.rpc = new RPC({
-      peerId,
       routingTable: this.routingTable,
       providers: this.providers,
       peerRouting: this.peerRouting,
-      datastore,
       validators: this.validators,
-      keyBook: peerStore.keyBook,
-      addressBook: peerStore.addressBook,
-      lan
+      lan: this.lan
     })
     this.topologyListener = new TopologyListener({
-      registrar,
       protocol: this.protocol,
-      lan
+      lan: this.lan
     })
     this.querySelf = new QuerySelf({
-      peerId,
       peerRouting: this.peerRouting,
       interval: querySelfInterval,
-      lan
+      lan: this.lan
     })
 
     // handle peers being discovered during processing of DHT messages
@@ -233,7 +164,7 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
       const peerId = evt.detail
 
       Promise.resolve().then(async () => {
-        const multiaddrs = await peerStore.addressBook.get(peerId)
+        const multiaddrs = await this.components.getPeerStore().addressBook.get(peerId)
 
         const peerData = {
           id: peerId,
@@ -248,7 +179,23 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
     })
   }
 
-  async onPeerConnect (peerData: PeerData) {
+  init (components: Components): void {
+    this.components = components
+
+    this.routingTable.init(components)
+    this.providers.init(components)
+    this.network.init(components)
+    this.queryManager.init(components)
+    this.peerRouting.init(components)
+    this.contentFetching.init(components)
+    this.contentRouting.init(components)
+    this.routingTableRefresh.init(components)
+    this.rpc.init(components)
+    this.topologyListener.init(components)
+    this.querySelf.init(components)
+  }
+
+  async onPeerConnect (peerData: PeerInfo) {
     this.log('peer %p connected', peerData.id)
 
     if (this.lan) {
@@ -287,9 +234,7 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
    * If 'server' this node will respond to DHT queries, if 'client' this node will not
    */
   async setMode (mode: 'client' | 'server') {
-    if (this.registrarHandleId != null) {
-      await this.registrar.unhandle(this.registrarHandleId)
-    }
+    await this.components.getRegistrar().unhandle(this.protocol)
 
     if (mode === 'client') {
       this.log('enabling client mode')
@@ -297,7 +242,8 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
     } else {
       this.log('enabling server mode')
       this.clientMode = false
-      this.registrarHandleId = await this.registrar.handle(this.protocol, this.rpc.onIncomingStream.bind(this.rpc))
+
+      await this.components.getRegistrar().handle(this.protocol, this.rpc.onIncomingStream.bind(this.rpc))
     }
   }
 
@@ -319,10 +265,6 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
       this.querySelf.start()
     ])
 
-    await Promise.all(
-      this.bootstrapPeers.map(async peerData => await this.routingTable.add(peerData.id))
-    )
-
     await this.routingTableRefresh.start()
   }
 
@@ -364,7 +306,7 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT {
    * Announce to the network that we can provide given key's value
    */
   async * provide (key: CID, options: QueryOptions = {}) { // eslint-disable-line require-await
-    yield * this.contentRouting.provide(key, this.addressable.multiaddrs, options)
+    yield * this.contentRouting.provide(key, this.components.getAddressManager().getAddresses(), options)
   }
 
   /**

package/src/message/index.ts

@@ -2,7 +2,7 @@ import { peerIdFromBytes } from '@libp2p/peer-id'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { Libp2pRecord } from '@libp2p/record'
 import Proto from './dht.js'
-import type { PeerData } from '@libp2p/interfaces/peer-data'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 
 export const MESSAGE_TYPE = Proto.Message.MessageType
 export const CONNECTION_TYPE = Proto.Message.ConnectionType
@@ -23,8 +23,8 @@ export class Message {
   public type: Proto.Message.MessageType
   public key: Uint8Array
   private clusterLevelRaw: number
-  public closerPeers: PeerData[]
-  public providerPeers: PeerData[]
+  public closerPeers: PeerInfo[]
+  public providerPeers: PeerInfo[]
   public record?: Libp2pRecord
 
   constructor (type: Proto.Message.MessageType, key: Uint8Array, level: number) {
@@ -88,7 +88,7 @@ export class Message {
   }
 }
 
-function toPbPeer (peer: PeerData) {
+function toPbPeer (peer: PeerInfo) {
   const output: PBPeer = {
     id: peer.id.toBytes(),
     addrs: (peer.multiaddrs ?? []).map((m) => m.bytes),

package/src/network.ts

@@ -13,44 +13,46 @@ import {
 } from './query/events.js'
 import { logger } from '@libp2p/logger'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { AbortOptions, Dialer, Startable } from '@libp2p/interfaces'
+import type { AbortOptions, Startable } from '@libp2p/interfaces'
 import type { Logger } from '@libp2p/logger'
 import type { Duplex } from 'it-stream-types'
-import type { PeerData } from '@libp2p/interfaces/peer-data'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
-export interface NetworkOptions {
-  dialer: Dialer
+export interface NetworkInit {
   protocol: string
   lan: boolean
-  peerId: PeerId
 }
 
 interface NetworkEvents {
-  'peer': CustomEvent<PeerData>
+  'peer': CustomEvent<PeerInfo>
 }
 
 /**
  * Handle network operations for the dht
  */
-export class Network extends EventEmitter<NetworkEvents> implements Startable {
+export class Network extends EventEmitter<NetworkEvents> implements Startable, Initializable {
   private readonly log: Logger
-  public dialer: Dialer
   private readonly protocol: string
   private running: boolean
+  private components: Components = new Components()
 
   /**
    * Create a new network
    */
-  constructor (options: NetworkOptions) {
+  constructor (init: NetworkInit) {
     super()
 
-    const { dialer, protocol, lan, peerId } = options
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:network:${peerId.toString()}`)
+    const { protocol, lan } = init
+    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:network`)
     this.running = false
-    this.dialer = dialer
     this.protocol = protocol
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   /**
    * Start the network
    */
@@ -89,7 +91,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
     try {
       yield dialingPeerEvent({ peer: to })
 
-      const { stream } = await this.dialer.dialProtocol(to, this.protocol, options)
+      const { stream } = await this.components.getDialer().dialProtocol(to, this.protocol, options)
 
       yield sendingQueryEvent({ to, type: msg.type })
 
@@ -119,7 +121,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
 
     yield dialingPeerEvent({ peer: to })
 
-    const { stream } = await this.dialer.dialProtocol(to, this.protocol, options)
+    const { stream } = await this.components.getDialer().dialProtocol(to, this.protocol, options)
 
     yield sendingQueryEvent({ to, type: msg.type })
 

package/src/peer-list/index.ts

@@ -24,7 +24,7 @@ export class PeerList {
   }
 
   /**
-   * Check if this PeerData is already in here
+   * Check if this PeerInfo is already in here
    */
   has (peerId: PeerId) {
     const match = this.list.find((i) => i.equals(peerId))

package/src/peer-routing/index.ts

@@ -10,52 +10,50 @@ import {
 } from '../query/events.js'
 import { PeerDistanceList } from '../peer-list/peer-distance-list.js'
 import { Libp2pRecord } from '@libp2p/record'
-import { base58btc } from 'multiformats/bases/base58'
 import { logger } from '@libp2p/logger'
 import { keys } from '@libp2p/crypto'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import type { DHTRecord, QueryOptions, Validators } from '@libp2p/interfaces/dht'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { PeerStore } from '@libp2p/interfaces/peer-store'
 import type { QueryManager } from '../query/manager.js'
 import type { Network } from '../network.js'
 import type { Logger } from '@libp2p/logger'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { QueryFunc } from '../query/types.js'
-import type { PeerData } from '@libp2p/interfaces/peer-data'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
-export interface PeerRoutingOptions {
-  peerId: PeerId
+export interface PeerRoutingInit {
   routingTable: RoutingTable
-  peerStore: PeerStore
   network: Network
   validators: Validators
   queryManager: QueryManager
   lan: boolean
 }
 
-export class PeerRouting {
+export class PeerRouting implements Initializable {
+  private components: Components = new Components()
   private readonly log: Logger
-  private readonly peerId: PeerId
   private readonly routingTable: RoutingTable
-  private readonly peerStore: PeerStore
   private readonly network: Network
   private readonly validators: Validators
   private readonly queryManager: QueryManager
 
-  constructor (options: PeerRoutingOptions) {
-    const { peerId, routingTable, peerStore, network, validators, queryManager, lan } = options
+  constructor (init: PeerRoutingInit) {
+    const { routingTable, network, validators, queryManager, lan } = init
 
-    this.peerId = peerId
     this.routingTable = routingTable
-    this.peerStore = peerStore
     this.network = network
     this.validators = validators
     this.queryManager = queryManager
     this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:peer-routing`)
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   /**
    * Look if we are connected to a peer with the given id.
    * Returns its id and addresses, if found, otherwise `undefined`.
@@ -68,7 +66,7 @@ export class PeerRouting {
       this.log('findPeerLocal found %p in routing table', peer)
 
       try {
-        peerData = await this.peerStore.get(p)
+        peerData = await this.components.getPeerStore().get(p)
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
           throw err
@@ -78,7 +76,7 @@ export class PeerRouting {
 
     if (peerData == null) {
       try {
-        peerData = await this.peerStore.get(peer)
+        peerData = await this.components.getPeerStore().get(peer)
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
           throw err
@@ -130,7 +128,7 @@ export class PeerRouting {
       }
     }
 
-    throw errcode(new Error(`Node not responding with its public key: ${peer.toString(base58btc)}`), 'ERR_INVALID_RECORD')
+    throw errcode(new Error(`Node not responding with its public key: ${peer.toString()}`), 'ERR_INVALID_RECORD')
   }
 
   /**
@@ -146,7 +144,7 @@ export class PeerRouting {
     if (pi != null) {
       this.log('found local')
       yield finalPeerEvent({
-        from: this.peerId,
+        from: this.components.getPeerId(),
         peer: pi
       })
       return
@@ -160,11 +158,11 @@ export class PeerRouting {
 
     if (match != null) {
       try {
-        const peer = await this.peerStore.get(id)
+        const peer = await this.components.getPeerStore().get(id)
 
         this.log('found in peerStore')
         yield finalPeerEvent({
-          from: this.peerId,
+          from: this.components.getPeerId(),
           peer: {
             id: peer.id,
             multiaddrs: peer.addresses.map((address) => address.multiaddr),
@@ -210,7 +208,7 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({ from: this.peerId, error: errcode(new Error('Not found'), 'ERR_NOT_FOUND') })
+      yield queryErrorEvent({ from: this.components.getPeerId(), error: errcode(new Error('Not found'), 'ERR_NOT_FOUND') })
     }
   }
 
@@ -246,10 +244,10 @@ export class PeerRouting {
 
     for (const peer of peers.peers) {
       yield finalPeerEvent({
-        from: this.peerId,
+        from: this.components.getPeerId(),
         peer: {
           id: peer,
-          multiaddrs: (await (this.peerStore.addressBook.get(peer)) ?? []).map(addr => addr.multiaddr),
+          multiaddrs: (await (this.components.getPeerStore().addressBook.get(peer)) ?? []).map(addr => addr.multiaddr),
           protocols: []
         }
       })
@@ -298,7 +296,7 @@ export class PeerRouting {
   async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId) {
     const id = await utils.convertBuffer(key)
     const ids = this.routingTable.closestPeers(id)
-    const output: PeerData[] = []
+    const output: PeerInfo[] = []
 
     for (const peerId of ids) {
       if (peerId.equals(closerThan)) {
@@ -306,8 +304,8 @@ export class PeerRouting {
       }
 
       try {
-        const addresses = await this.peerStore.addressBook.get(peerId)
-        const protocols = await this.peerStore.protoBook.get(peerId)
+        const addresses = await this.components.getPeerStore().addressBook.get(peerId)
+        const protocols = await this.components.getPeerStore().protoBook.get(peerId)
 
         output.push({
           id: peerId,

package/src/providers.ts

@@ -15,11 +15,11 @@ import type { Datastore } from 'interface-datastore'
 import type { Startable } from '@libp2p/interfaces'
 import type { CID } from 'multiformats'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { Components, Initializable } from '@libp2p/interfaces/components'
 
 const log = logger('libp2p:kad-dht:providers')
 
-export interface ProvidersOptions {
-  datastore: Datastore
+export interface ProvidersInit {
   cacheSize?: number
   /**
    * How often invalid records are cleaned. (in seconds)
@@ -43,8 +43,8 @@ export interface ProvidersOptions {
  * providers are stored in the datastore, but to ensure
  * access is fast there is an LRU cache in front of that.
  */
-export class Providers implements Startable {
-  private readonly datastore: Datastore
+export class Providers implements Startable, Initializable {
+  private components: Components = new Components()
   private readonly cache: ReturnType<typeof cache>
   private readonly cleanupInterval: number
   private readonly provideValidity: number
@@ -52,10 +52,9 @@ export class Providers implements Startable {
   private started: boolean
   private cleaner?: NodeJS.Timer
 
-  constructor (options: ProvidersOptions) {
-    const { datastore, cacheSize, cleanupInterval, provideValidity } = options
+  constructor (init: ProvidersInit = {}) {
+    const { cacheSize, cleanupInterval, provideValidity } = init
 
-    this.datastore = datastore
     this.cleanupInterval = cleanupInterval ?? PROVIDERS_CLEANUP_INTERVAL
     this.provideValidity = provideValidity ?? PROVIDERS_VALIDITY
     this.cache = cache(cacheSize ?? PROVIDERS_LRU_CACHE_SIZE)
@@ -63,6 +62,10 @@ export class Providers implements Startable {
     this.started = false
   }
 
+  init (components: Components): void {
+    this.components = components
+  }
+
   isStarted () {
     return this.started
   }
@@ -109,10 +112,10 @@ export class Providers implements Startable {
       let count = 0
       let deleteCount = 0
       const deleted = new Map<string, Set<string>>()
-      const batch = this.datastore.batch()
+      const batch = this.components.getDatastore().batch()
 
       // Get all provider entries from the datastore
-      const query = this.datastore.query({ prefix: PROVIDER_KEY_PREFIX })
+      const query = this.components.getDatastore().query({ prefix: PROVIDER_KEY_PREFIX })
 
       for await (const entry of query) {
         try {
@@ -176,7 +179,7 @@ export class Providers implements Startable {
     let provs: Map<string, Date> = this.cache.get(cacheKey)
 
     if (provs == null) {
-      provs = await loadProviders(this.datastore, cid)
+      provs = await loadProviders(this.components.getDatastore(), cid)
       this.cache.set(cacheKey, provs)
     }
 
@@ -198,7 +201,7 @@ export class Providers implements Startable {
       const dsKey = makeProviderKey(cid)
       this.cache.set(dsKey, provs)
 
-      await writeProviderEntry(this.datastore, cid, provider, now)
+      await writeProviderEntry(this.components.getDatastore(), cid, provider, now)
     })
   }