@libp2p/kad-dht 4.0.2 → 5.0.0

package/src/providers.ts

@@ -15,7 +15,6 @@ import type { Datastore } from 'interface-datastore'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { Components, Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:providers')
 
@@ -31,6 +30,10 @@ export interface ProvidersInit {
   provideValidity?: number
 }
 
+export interface ProvidersComponents {
+  datastore: Datastore
+}
+
 /**
  * This class manages known providers.
  * A provider is a peer that we know to have the content for a given CID.
@@ -43,8 +46,8 @@ export interface ProvidersInit {
  * 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, Initializable {
-  private components: Components = new Components()
+export class Providers implements Startable {
+  private readonly components: ProvidersComponents
   private readonly cache: ReturnType<typeof cache>
   private readonly cleanupInterval: number
   private readonly provideValidity: number
@@ -52,9 +55,10 @@ export class Providers implements Startable, Initializable {
   private started: boolean
   private cleaner?: NodeJS.Timer
 
-  constructor (init: ProvidersInit = {}) {
+  constructor (components: ProvidersComponents, init: ProvidersInit = {}) {
     const { cacheSize, cleanupInterval, provideValidity } = init
 
+    this.components = components
     this.cleanupInterval = cleanupInterval ?? PROVIDERS_CLEANUP_INTERVAL
     this.provideValidity = provideValidity ?? PROVIDERS_VALIDITY
     this.cache = cache(cacheSize ?? PROVIDERS_LRU_CACHE_SIZE)
@@ -62,10 +66,6 @@ export class Providers implements Startable, Initializable {
     this.started = false
   }
 
-  init (components: Components): void {
-    this.components = components
-  }
-
   isStarted () {
     return this.started
   }
@@ -112,10 +112,10 @@ export class Providers implements Startable, Initializable {
       let count = 0
       let deleteCount = 0
       const deleted = new Map<string, Set<string>>()
-      const batch = this.components.getDatastore().batch()
+      const batch = this.components.datastore.batch()
 
       // Get all provider entries from the datastore
-      const query = this.components.getDatastore().query({ prefix: PROVIDER_KEY_PREFIX })
+      const query = this.components.datastore.query({ prefix: PROVIDER_KEY_PREFIX })
 
       for await (const entry of query) {
         try {
@@ -179,7 +179,7 @@ export class Providers implements Startable, Initializable {
     let provs: Map<string, Date> = this.cache.get(cacheKey)
 
     if (provs == null) {
-      provs = await loadProviders(this.components.getDatastore(), cid)
+      provs = await loadProviders(this.components.datastore, cid)
       this.cache.set(cacheKey, provs)
     }
 
@@ -201,7 +201,7 @@ export class Providers implements Startable, Initializable {
       const dsKey = makeProviderKey(cid)
       this.cache.set(dsKey, provs)
 
-      await writeProviderEntry(this.components.getDatastore(), cid, provider, now)
+      await writeProviderEntry(this.components.datastore, cid, provider, now)
     })
   }
 

package/src/query/manager.ts

@@ -13,8 +13,8 @@ import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { QueryFunc } from './types.js'
 import type { QueryOptions } from '@libp2p/interface-dht'
-import { Components, Initializable } from '@libp2p/components'
 import { PeerSet } from '@libp2p/peer-collections'
+import type { Metrics } from '@libp2p/interface-metrics'
 
 const METRIC_RUNNING_QUERIES = 'running-queries'
 
@@ -28,11 +28,16 @@ export interface QueryManagerInit {
   alpha?: number
 }
 
+export interface QueryManagerComponents {
+  peerId: PeerId
+  metrics?: Metrics
+}
+
 /**
  * Keeps track of all running queries
  */
-export class QueryManager implements Startable, Initializable {
-  private components: Components = new Components()
+export class QueryManager implements Startable {
+  private readonly components: QueryManagerComponents
   private readonly lan: boolean
   public disjointPaths: number
   private readonly alpha: number
@@ -40,8 +45,10 @@ export class QueryManager implements Startable, Initializable {
   private running: boolean
   private queries: number
 
-  constructor (init: QueryManagerInit) {
+  constructor (components: QueryManagerComponents, init: QueryManagerInit) {
     const { lan = false, disjointPaths = K, alpha = ALPHA } = init
+
+    this.components = components
     this.disjointPaths = disjointPaths ?? K
     this.controllers = new Set()
     this.running = false
@@ -50,10 +57,6 @@ export class QueryManager implements Startable, Initializable {
     this.queries = 0
   }
 
-  init (components: Components): void {
-    this.components = components
-  }
-
   isStarted () {
     return this.running
   }
@@ -128,7 +131,7 @@ export class QueryManager implements Startable, Initializable {
     try {
       log('query:start')
       this.queries++
-      this.components.getMetrics()?.updateComponentMetric({
+      this.components.metrics?.updateComponentMetric({
         system: 'libp2p',
         component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
         metric: METRIC_RUNNING_QUERIES,
@@ -148,7 +151,7 @@ export class QueryManager implements Startable, Initializable {
         return queryPath({
           key,
           startingPeer: peer,
-          ourPeerId: this.components.getPeerId(),
+          ourPeerId: this.components.peerId,
           signal,
           query: queryFunc,
           pathIndex: index,
@@ -183,7 +186,7 @@ export class QueryManager implements Startable, Initializable {
       }
 
       this.queries--
-      this.components.getMetrics()?.updateComponentMetric({
+      this.components.metrics?.updateComponentMetric({
         system: 'libp2p',
         component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
         metric: METRIC_RUNNING_QUERIES,

package/src/query-self.ts

@@ -8,7 +8,7 @@ import { logger, Logger } from '@libp2p/logger'
 import type { PeerRouting } from './peer-routing/index.js'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { pipe } from 'it-pipe'
-import { Components, Initializable } from '@libp2p/components'
+import type { KadDHTComponents } from './index.js'
 
 export interface QuerySelfInit {
   lan: boolean
@@ -21,9 +21,9 @@ export interface QuerySelfInit {
 /**
  * Receives notifications of new peers joining the network that support the DHT protocol
  */
-export class QuerySelf implements Startable, Initializable {
+export class QuerySelf implements Startable {
   private readonly log: Logger
-  private components: Components = new Components()
+  private readonly components: KadDHTComponents
   private readonly peerRouting: PeerRouting
   private readonly count: number
   private readonly interval: number
@@ -32,9 +32,10 @@ export class QuerySelf implements Startable, Initializable {
   private timeoutId?: NodeJS.Timer
   private controller?: AbortController
 
-  constructor (init: QuerySelfInit) {
+  constructor (components: KadDHTComponents, init: QuerySelfInit) {
     const { peerRouting, lan, count, interval, queryTimeout } = init
 
+    this.components = components
     this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:query-self`)
     this.running = false
     this.peerRouting = peerRouting
@@ -43,10 +44,6 @@ export class QuerySelf implements Startable, Initializable {
     this.queryTimeout = queryTimeout ?? QUERY_SELF_TIMEOUT
   }
 
-  init (components: Components): void {
-    this.components = components
-  }
-
   isStarted () {
     return this.running
   }
@@ -86,7 +83,7 @@ export class QuerySelf implements Startable, Initializable {
           }
         } catch {} // fails on node < 15.4
         const found = await pipe(
-          this.peerRouting.getClosestPeers(this.components.getPeerId().toBytes(), {
+          this.peerRouting.getClosestPeers(this.components.peerId.toBytes(), {
             signal
           }),
           (source) => take(source, this.count),

package/src/routing-table/index.ts

@@ -7,8 +7,10 @@ import { logger } from '@libp2p/logger'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Logger } from '@libp2p/logger'
-import { Components, Initializable } from '@libp2p/components'
 import { PeerSet } from '@libp2p/peer-collections'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 
 export const KAD_CLOSE_TAG_NAME = 'kad-close'
 export const KAD_CLOSE_TAG_VALUE = 50
@@ -66,17 +68,24 @@ export interface RoutingTableInit {
   tagValue?: number
 }
 
+export interface RoutingTableComponents {
+  peerId: PeerId
+  peerStore: PeerStore
+  connectionManager: ConnectionManager
+  metrics?: Metrics
+}
+
 /**
  * A wrapper around `k-bucket`, to provide easy store and
  * retrieval for peers.
  */
-export class RoutingTable implements Startable, Initializable {
+export class RoutingTable implements Startable {
   public kBucketSize: number
   public kb?: KBucketTree
   public pingQueue: Queue
 
   private readonly log: Logger
-  private components: Components = new Components()
+  private readonly components: RoutingTableComponents
   private readonly lan: boolean
   private readonly pingTimeout: number
   private readonly pingConcurrency: number
@@ -85,9 +94,10 @@ export class RoutingTable implements Startable, Initializable {
   private readonly tagName: string
   private readonly tagValue: number
 
-  constructor (init: RoutingTableInit) {
+  constructor (components: RoutingTableComponents, init: RoutingTableInit) {
     const { kBucketSize, pingTimeout, lan, pingConcurrency, protocol, tagName, tagValue } = init
 
+    this.components = components
     this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table`)
     this.kBucketSize = kBucketSize ?? KBUCKET_SIZE
     this.pingTimeout = pingTimeout ?? PING_TIMEOUT
@@ -99,13 +109,13 @@ export class RoutingTable implements Startable, Initializable {
     this.tagValue = tagValue ?? KAD_CLOSE_TAG_VALUE
 
     const updatePingQueueSizeMetric = () => {
-      this.components.getMetrics()?.updateComponentMetric({
+      this.components.metrics?.updateComponentMetric({
         system: 'libp2p',
         component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
         metric: METRIC_PING_QUEUE_SIZE,
         value: this.pingQueue.size
       })
-      this.components.getMetrics()?.updateComponentMetric({
+      this.components.metrics?.updateComponentMetric({
         system: 'libp2p',
         component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
         metric: METRIC_PING_RUNNING,
@@ -120,10 +130,6 @@ export class RoutingTable implements Startable, Initializable {
     this._onPing = this._onPing.bind(this)
   }
 
-  init (components: Components): void {
-    this.components = components
-  }
-
   isStarted () {
     return this.running
   }
@@ -132,7 +138,7 @@ export class RoutingTable implements Startable, Initializable {
     this.running = true
 
     const kBuck: KBucketTree = new KBuck({
-      localNodeId: await utils.convertPeerId(this.components.getPeerId()),
+      localNodeId: await utils.convertPeerId(this.components.peerId),
       numberOfNodesPerKBucket: this.kBucketSize,
       numberOfNodesToPing: 1
     })
@@ -169,13 +175,13 @@ export class RoutingTable implements Startable, Initializable {
       Promise.resolve()
         .then(async () => {
           for (const peer of addedPeers) {
-            await this.components.getPeerStore().tagPeer(peer, this.tagName, {
+            await this.components.peerStore.tagPeer(peer, this.tagName, {
               value: this.tagValue
             })
           }
 
           for (const peer of removedPeers) {
-            await this.components.getPeerStore().unTagPeer(peer, this.tagName)
+            await this.components.peerStore.unTagPeer(peer, this.tagName)
           }
         })
         .catch(err => {
@@ -227,7 +233,7 @@ export class RoutingTable implements Startable, Initializable {
               }
 
               this.log('pinging old contact %p', oldContact.peer)
-              const connection = await this.components.getConnectionManager().openConnection(oldContact.peer, options)
+              const connection = await this.components.connectionManager.openConnection(oldContact.peer, options)
               const stream = await connection.newStream(this.protocol, options)
               stream.close()
               responded++
@@ -244,7 +250,7 @@ export class RoutingTable implements Startable, Initializable {
                 timeoutController.clear()
               }
 
-              this.components.getMetrics()?.updateComponentMetric({
+              this.components.metrics?.updateComponentMetric({
                 system: 'libp2p',
                 component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
                 metric: METRIC_ROUTING_TABLE_SIZE,
@@ -334,7 +340,7 @@ export class RoutingTable implements Startable, Initializable {
 
     this.log('added %p with kad id %b', peer, id)
 
-    this.components.getMetrics()?.updateComponentMetric({
+    this.components.metrics?.updateComponentMetric({
       system: 'libp2p',
       component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
       metric: METRIC_ROUTING_TABLE_SIZE,
@@ -354,7 +360,7 @@ export class RoutingTable implements Startable, Initializable {
 
     this.kb.remove(id)
 
-    this.components.getMetrics()?.updateComponentMetric({
+    this.components.metrics?.updateComponentMetric({
       system: 'libp2p',
       component: `kad-dht-${this.lan ? 'lan' : 'wan'}`,
       metric: METRIC_ROUTING_TABLE_SIZE,

package/src/routing-table/refresh.ts

@@ -10,7 +10,6 @@ import { TABLE_REFRESH_INTERVAL, TABLE_REFRESH_QUERY_TIMEOUT } from '../constant
 import type { RoutingTable } from './index.js'
 import type { Logger } from '@libp2p/logger'
 import type { PeerRouting } from '../peer-routing/index.js'
-import type { Components, Initializable } from '@libp2p/components'
 
 /**
  * Cannot generate random KadIds longer than this + 1
@@ -29,7 +28,7 @@ export interface RoutingTableRefreshInit {
  * A wrapper around `k-bucket`, to provide easy store and
  * retrieval for peers.
  */
-export class RoutingTableRefresh implements Initializable {
+export class RoutingTableRefresh {
   private readonly log: Logger
   private readonly peerRouting: PeerRouting
   private readonly routingTable: RoutingTable
@@ -50,10 +49,6 @@ export class RoutingTableRefresh implements Initializable {
     this.refreshTable = this.refreshTable.bind(this)
   }
 
-  init (components: Components): void {
-
-  }
-
   async start () {
     this.log(`refreshing routing table every ${this.refreshInterval}ms`)
     this.refreshTable(true)

package/src/rpc/handlers/add-provider.ts

@@ -5,7 +5,6 @@ import type { Providers } from '../../providers'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { DHTMessageHandler } from '../index.js'
 import type { Message } from '../../message/index.js'
-import type { Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:add-provider')
 
@@ -13,7 +12,7 @@ export interface AddProviderHandlerInit {
   providers: Providers
 }
 
-export class AddProviderHandler implements DHTMessageHandler, Initializable {
+export class AddProviderHandler implements DHTMessageHandler {
   private readonly providers: Providers
 
   constructor (init: AddProviderHandlerInit) {
@@ -21,10 +20,6 @@ export class AddProviderHandler implements DHTMessageHandler, Initializable {
     this.providers = providers
   }
 
-  init (): void {
-
-  }
-
   async handle (peerId: PeerId, msg: Message) {
     log('start')
 

package/src/rpc/handlers/find-node.ts

@@ -5,13 +5,12 @@ import {
   removePublicAddresses
 } from '../../utils.js'
 import { equals as uint8ArrayEquals } from 'uint8arrays'
-import { Components } from '@libp2p/components'
 import { protocols } from '@multiformats/multiaddr'
-import type { Initializable } from '@libp2p/components'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { DHTMessageHandler } from '../index.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:find-node')
 
@@ -20,19 +19,22 @@ export interface FindNodeHandlerInit {
   lan: boolean
 }
 
-export class FindNodeHandler implements DHTMessageHandler, Initializable {
+export interface FindNodeHandlerComponents {
+  peerId: PeerId
+  addressManager: AddressManager
+}
+
+export class FindNodeHandler implements DHTMessageHandler {
   private readonly peerRouting: PeerRouting
   private readonly lan: boolean
-  private components = new Components()
+  private readonly components: FindNodeHandlerComponents
 
-  constructor (init: FindNodeHandlerInit) {
+  constructor (components: FindNodeHandlerComponents, init: FindNodeHandlerInit) {
     const { peerRouting, lan } = init
-    this.peerRouting = peerRouting
-    this.lan = Boolean(lan)
-  }
 
-  init (components: Components): void {
     this.components = components
+    this.peerRouting = peerRouting
+    this.lan = Boolean(lan)
   }
 
   /**
@@ -43,10 +45,10 @@ export class FindNodeHandler implements DHTMessageHandler, Initializable {
 
     let closer: PeerInfo[] = []
 
-    if (uint8ArrayEquals(this.components.getPeerId().toBytes(), msg.key)) {
+    if (uint8ArrayEquals(this.components.peerId.toBytes(), msg.key)) {
       closer = [{
-        id: this.components.getPeerId(),
-        multiaddrs: this.components.getAddressManager().getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code)),
+        id: this.components.peerId,
+        multiaddrs: this.components.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code)),
         protocols: []
       }]
     } else {

package/src/rpc/handlers/get-providers.ts

@@ -11,7 +11,7 @@ import type { Providers } from '../../providers.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
-import { Components, Initializable } from '@libp2p/components'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-providers')
 
@@ -21,24 +21,25 @@ export interface GetProvidersHandlerInit {
   lan: boolean
 }
 
-export class GetProvidersHandler implements DHTMessageHandler, Initializable {
-  private components: Components = new Components()
+export interface GetProvidersHandlerComponents {
+  peerStore: PeerStore
+}
+
+export class GetProvidersHandler implements DHTMessageHandler {
+  private readonly components: GetProvidersHandlerComponents
   private readonly peerRouting: PeerRouting
   private readonly providers: Providers
   private readonly lan: boolean
 
-  constructor (init: GetProvidersHandlerInit) {
+  constructor (components: GetProvidersHandlerComponents, init: GetProvidersHandlerInit) {
     const { peerRouting, providers, lan } = init
 
+    this.components = components
     this.peerRouting = peerRouting
     this.providers = providers
     this.lan = Boolean(lan)
   }
 
-  init (components: Components): void {
-    this.components = components
-  }
-
   async handle (peerId: PeerId, msg: Message) {
     let cid
     try {
@@ -71,7 +72,7 @@ export class GetProvidersHandler implements DHTMessageHandler, Initializable {
   }
 
   async _getAddresses (peerId: PeerId) {
-    const addrs = await this.components.getPeerStore().addressBook.get(peerId)
+    const addrs = await this.components.peerStore.addressBook.get(peerId)
 
     return addrs.map(address => address.multiaddr)
   }

package/src/rpc/handlers/get-value.ts

@@ -9,7 +9,8 @@ import { logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerRouting } from '../../peer-routing/index.js'
-import { Components, Initializable } from '@libp2p/components'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { Datastore } from 'interface-datastore'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-value')
 
@@ -17,18 +18,20 @@ export interface GetValueHandlerInit {
   peerRouting: PeerRouting
 }
 
-export class GetValueHandler implements DHTMessageHandler, Initializable {
-  private components: Components = new Components()
+export interface GetValueHandlerComponents {
+  peerStore: PeerStore
+  datastore: Datastore
+}
+
+export class GetValueHandler implements DHTMessageHandler {
+  private readonly components: GetValueHandlerComponents
   private readonly peerRouting: PeerRouting
 
-  constructor (init: GetValueHandlerInit) {
+  constructor (components: GetValueHandlerComponents, init: GetValueHandlerInit) {
     const { peerRouting } = init
 
-    this.peerRouting = peerRouting
-  }
-
-  init (components: Components): void {
     this.components = components
+    this.peerRouting = peerRouting
   }
 
   async handle (peerId: PeerId, msg: Message) {
@@ -48,7 +51,7 @@ export class GetValueHandler implements DHTMessageHandler, Initializable {
       let pubKey: Uint8Array | undefined
 
       try {
-        const key = await this.components.getPeerStore().keyBook.get(idFromKey)
+        const key = await this.components.peerStore.keyBook.get(idFromKey)
 
         if (key == null) {
           throw errcode(new Error('No public key found in key book'), 'ERR_NOT_FOUND')
@@ -99,7 +102,7 @@ export class GetValueHandler implements DHTMessageHandler, Initializable {
     // Fetch value from ds
     let rawRecord
     try {
-      rawRecord = await this.components.getDatastore().get(dsKey)
+      rawRecord = await this.components.datastore.get(dsKey)
     } catch (err: any) {
       if (err.code === 'ERR_NOT_FOUND') {
         return undefined
@@ -118,7 +121,7 @@ export class GetValueHandler implements DHTMessageHandler, Initializable {
     if (record.timeReceived == null ||
       Date.now() - record.timeReceived.getTime() > MAX_RECORD_AGE) {
       // If record is bad delete it and return
-      await this.components.getDatastore().delete(dsKey)
+      await this.components.datastore.delete(dsKey)
       return undefined
     }
 

package/src/rpc/handlers/ping.ts

@@ -2,17 +2,12 @@ import { logger } from '@libp2p/logger'
 import type { Message } from '../../message/index.js'
 import type { DHTMessageHandler } from '../index.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:ping')
 
-export class PingHandler implements DHTMessageHandler, Initializable {
+export class PingHandler implements DHTMessageHandler {
   async handle (peerId: PeerId, msg: Message) {
     log('ping from %p', peerId)
     return msg
   }
-
-  init (): void {
-
-  }
 }

package/src/rpc/handlers/put-value.ts

@@ -6,28 +6,29 @@ import type { DHTMessageHandler } from '../index.js'
 import type { Validators } from '@libp2p/interface-dht'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Message } from '../../message/index.js'
-import { Components, Initializable } from '@libp2p/components'
+import type { Datastore } from 'interface-datastore'
 
 export interface PutValueHandlerInit {
   validators: Validators
 }
 
-export class PutValueHandler implements DHTMessageHandler, Initializable {
+export interface PutValueHandlerComponents {
+  datastore: Datastore
+}
+
+export class PutValueHandler implements DHTMessageHandler {
   private readonly log: Logger
-  private components: Components = new Components()
+  private readonly components: PutValueHandlerComponents
   private readonly validators: Validators
 
-  constructor (init: PutValueHandlerInit) {
+  constructor (components: PutValueHandlerComponents, init: PutValueHandlerInit) {
     const { validators } = init
 
+    this.components = components
     this.log = logger('libp2p:kad-dht:rpc:handlers:put-value')
     this.validators = validators
   }
 
-  init (components: Components): void {
-    this.components = components
-  }
-
   async handle (peerId: PeerId, msg: Message) {
     const key = msg.key
     this.log('%p asked us to store value for key %b', peerId, key)
@@ -46,7 +47,7 @@ export class PutValueHandler implements DHTMessageHandler, Initializable {
 
       record.timeReceived = new Date()
       const recordKey = bufferToRecordKey(record.key)
-      await this.components.getDatastore().put(recordKey, record.serialize().subarray())
+      await this.components.datastore.put(recordKey, record.serialize().subarray())
       this.log('put record for %b into datastore under key %k', key, recordKey)
     } catch (err: any) {
       this.log('did not put record for key %b into datastore %o', key, err)