@libp2p/kad-dht 9.3.6-3dfc236e → 9.3.6-6fdaa7dc

package/src/index.ts

@@ -1,15 +1,14 @@
 import { DefaultDualKadDHT } from './dual-kad-dht.js'
 import type { ProvidersInit } from './providers.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 { 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 { Registrar } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { EventEmitter } from '@libp2p/interface/events'
+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 { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats/cid'
 import type { ProgressOptions, ProgressEvent } from 'progress-events'

package/src/kad-dht.ts

@@ -1,7 +1,5 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { CustomEvent, EventEmitter } from '@libp2p/interface/events'
 import { type Logger, logger } from '@libp2p/logger'
-import { selectors as recordSelectors } from '@libp2p/record/selectors'
-import { validators as recordValidators } from '@libp2p/record/validators'
 import pDefer from 'p-defer'
 import { PROTOCOL_DHT, PROTOCOL_PREFIX, LAN_PREFIX } from './constants.js'
 import { ContentFetching } from './content-fetching/index.js'
@@ -11,6 +9,8 @@ import { PeerRouting } from './peer-routing/index.js'
 import { Providers } from './providers.js'
 import { QueryManager } from './query/manager.js'
 import { QuerySelf } from './query-self.js'
+import { selectors as recordSelectors } from './record/selectors.js'
+import { validators as recordValidators } from './record/validators.js'
 import { RoutingTable } from './routing-table/index.js'
 import { RoutingTableRefresh } from './routing-table/refresh.js'
 import { RPC } from './rpc/index.js'
@@ -20,9 +20,9 @@ import {
   removePublicAddresses
 } from './utils.js'
 import type { KadDHTComponents, KadDHTInit, QueryOptions, Validators, Selectors, KadDHT, QueryEvent } from './index.js'
-import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerDiscoveryEvents } from '@libp2p/interface/peer-discovery'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
 import type { CID } from 'multiformats/cid'
 
 export const DEFAULT_MAX_INBOUND_STREAMS = 32

package/src/message/index.ts

@@ -1,8 +1,8 @@
 import { peerIdFromBytes } from '@libp2p/peer-id'
-import { Libp2pRecord } from '@libp2p/record'
 import { multiaddr } from '@multiformats/multiaddr'
+import { Libp2pRecord } from '../record/index.js'
 import { Message as PBMessage } from './dht.js'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export const MESSAGE_TYPE = PBMessage.MessageType

package/src/network.ts

@@ -1,5 +1,5 @@
-import { CodeError } from '@libp2p/interfaces/errors'
-import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
+import { CodeError } from '@libp2p/interface/errors'
+import { EventEmitter, CustomEvent } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { abortableDuplex } from 'abortable-iterator'
 import drain from 'it-drain'
@@ -14,11 +14,11 @@ import {
   queryErrorEvent
 } from './query/events.js'
 import type { KadDHTComponents, QueryEvent, QueryOptions } from './index.js'
-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 { AbortOptions } from '@libp2p/interfaces'
-import type { Startable } from '@libp2p/interfaces/startable'
+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'

package/src/peer-list/index.ts

@@ -1,4 +1,4 @@
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 
 /**
  * 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/peer-id'
 
 interface PeerDistance {
   peerId: PeerId

package/src/peer-routing/index.ts

@@ -1,9 +1,7 @@
 import { keys } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { peerIdFromKeys } from '@libp2p/peer-id'
-import { Libp2pRecord } from '@libp2p/record'
-import { verifyRecord } from '@libp2p/record/validators'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { Message, MESSAGE_TYPE } from '../message/index.js'
 import { PeerDistanceList } from '../peer-list/peer-distance-list.js'
@@ -12,15 +10,17 @@ import {
   finalPeerEvent,
   valueEvent
 } from '../query/events.js'
+import { Libp2pRecord } from '../record/index.js'
+import { verifyRecord } from '../record/validators.js'
 import * as utils from '../utils.js'
 import type { KadDHTComponents, DHTRecord, DialPeerEvent, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
 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 { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { AbortOptions } from '@libp2p/interfaces'
+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'
 
 export interface PeerRoutingInit {

package/src/providers.ts

@@ -11,8 +11,8 @@ import {
   PROVIDERS_LRU_CACHE_SIZE,
   PROVIDER_KEY_PREFIX
 } from './constants.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats'
 

package/src/query/events.ts

@@ -1,10 +1,10 @@
-import { CustomEvent } from '@libp2p/interfaces/events'
+import { CustomEvent } from '@libp2p/interface/events'
 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 { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { Libp2pRecord } from '@libp2p/record'
+import type { Libp2pRecord } from '../record/index.js'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
 
 export interface QueryEventFields {
   to: PeerId

package/src/query/manager.ts

@@ -1,6 +1,6 @@
 import { setMaxListeners } from 'events'
-import { AbortError } from '@libp2p/interfaces/errors'
-import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
+import { AbortError } from '@libp2p/interface/errors'
+import { EventEmitter, CustomEvent } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { anySignal } from 'any-signal'
@@ -14,9 +14,9 @@ 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/interfaces/startable'
+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 { DeferredPromise } from 'p-defer'
 
 export interface CleanUpEvents {

package/src/query/query-path.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { anySignal } from 'any-signal'
 import defer from 'p-defer'
 import Queue from 'p-queue'
@@ -9,8 +9,8 @@ import { queryErrorEvent } from './events.js'
 import type { CleanUpEvents } from './manager.js'
 import type { QueryEvent, QueryOptions } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Logger } from '@libp2p/logger'
 import type { PeerSet } from '@libp2p/peer-collections'
 

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/peer-id'
 
 export interface QueryContext {
   // the key we are looking up

package/src/query-self.ts

@@ -9,8 +9,8 @@ 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/interfaces/startable'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
 import type { DeferredPromise } from 'p-defer'
 
 export interface QuerySelfInit {

package/src/record/index.ts

@@ -0,0 +1,70 @@
+import {
+  Record
+} from './record.js'
+import * as utils from './utils.js'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export class Libp2pRecord {
+  public key: Uint8Array
+  public value: Uint8Array
+  public timeReceived: Date
+
+  constructor (key: Uint8Array, value: Uint8Array, timeReceived: Date) {
+    if (!(key instanceof Uint8Array)) {
+      throw new Error('key must be a Uint8Array')
+    }
+
+    if (!(value instanceof Uint8Array)) {
+      throw new Error('value must be a Uint8Array')
+    }
+
+    this.key = key
+    this.value = value
+    this.timeReceived = timeReceived
+  }
+
+  serialize (): Uint8Array {
+    return Record.encode(this.prepareSerialize())
+  }
+
+  /**
+   * Return the object format ready to be given to the protobuf library.
+   */
+  prepareSerialize (): Record {
+    return {
+      key: this.key,
+      value: this.value,
+      timeReceived: utils.toRFC3339(this.timeReceived)
+    }
+  }
+
+  /**
+   * Decode a protobuf encoded record
+   */
+  static deserialize (raw: Uint8Array | Uint8ArrayList): Libp2pRecord {
+    const rec = Record.decode(raw)
+
+    return new Libp2pRecord(rec.key, rec.value, new Date(rec.timeReceived))
+  }
+
+  /**
+   * Create a record from the raw object returned from the protobuf library
+   */
+  static fromDeserialized (obj: Record): Libp2pRecord {
+    const recvtime = utils.parseRFC3339(obj.timeReceived)
+
+    if (obj.key == null) {
+      throw new Error('key missing from deserialized object')
+    }
+
+    if (obj.value == null) {
+      throw new Error('value missing from deserialized object')
+    }
+
+    const rec = new Libp2pRecord(
+      obj.key, obj.value, recvtime
+    )
+
+    return rec
+  }
+}

package/src/record/record.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+// Record represents a dht record that contains a value
+// for a key value pair
+message Record {
+  // The key that references this record
+  bytes key = 1;
+
+  // The actual value this record is storing
+  bytes value = 2;
+
+  // Note: These fields were removed from the Record message
+  // hash of the authors public key
+  // optional bytes author = 3;
+  // A PKI signature for the key+value+author
+  // optional bytes signature = 4;
+
+  // Time the record was received, set by receiver
+  string timeReceived = 5;
+}

package/src/record/record.ts

@@ -0,0 +1,87 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+
+import { encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface Record {
+  key: Uint8Array
+  value: Uint8Array
+  timeReceived: string
+}
+
+export namespace Record {
+  let _codec: Codec<Record>
+
+  export const codec = (): Codec<Record> => {
+    if (_codec == null) {
+      _codec = message<Record>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if ((obj.key != null && obj.key.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.key)
+        }
+
+        if ((obj.value != null && obj.value.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.value)
+        }
+
+        if ((obj.timeReceived != null && obj.timeReceived !== '')) {
+          w.uint32(42)
+          w.string(obj.timeReceived)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {
+          key: new Uint8Array(0),
+          value: new Uint8Array(0),
+          timeReceived: ''
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.key = reader.bytes()
+              break
+            case 2:
+              obj.value = reader.bytes()
+              break
+            case 5:
+              obj.timeReceived = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<Record>): Uint8Array => {
+    return encodeMessage(obj, Record.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Record => {
+    return decodeMessage(buf, Record.codec())
+  }
+}

package/src/record/selectors.ts

@@ -0,0 +1,50 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { Selectors } from '../index.js'
+
+/**
+ * Select the best record out of the given records
+ */
+export function bestRecord (selectors: Selectors, k: Uint8Array, records: Uint8Array[]): number {
+  if (records.length === 0) {
+    const errMsg = 'No records given'
+
+    throw new CodeError(errMsg, 'ERR_NO_RECORDS_RECEIVED')
+  }
+
+  const kStr = uint8ArrayToString(k)
+  const parts = kStr.split('/')
+
+  if (parts.length < 3) {
+    const errMsg = 'Record key does not have a selector function'
+
+    throw new CodeError(errMsg, 'ERR_NO_SELECTOR_FUNCTION_FOR_RECORD_KEY')
+  }
+
+  const selector = selectors[parts[1].toString()]
+
+  if (selector == null) {
+    const errMsg = `Unrecognized key prefix: ${parts[1]}`
+
+    throw new CodeError(errMsg, 'ERR_UNRECOGNIZED_KEY_PREFIX')
+  }
+
+  if (records.length === 1) {
+    return 0
+  }
+
+  return selector(k, records)
+}
+
+/**
+ * Best record selector, for public key records.
+ * Simply returns the first record, as all valid public key
+ * records are equal
+ */
+function publickKey (k: Uint8Array, records: Uint8Array[]): number {
+  return 0
+}
+
+export const selectors: Selectors = {
+  pk: publickKey
+}

package/src/record/utils.ts

@@ -0,0 +1,46 @@
+/**
+ * Convert a JavaScript date into an `RFC3339Nano` formatted
+ * string
+ */
+export function toRFC3339 (time: Date): string {
+  const year = time.getUTCFullYear()
+  const month = String(time.getUTCMonth() + 1).padStart(2, '0')
+  const day = String(time.getUTCDate()).padStart(2, '0')
+  const hour = String(time.getUTCHours()).padStart(2, '0')
+  const minute = String(time.getUTCMinutes()).padStart(2, '0')
+  const seconds = String(time.getUTCSeconds()).padStart(2, '0')
+  const milliseconds = time.getUTCMilliseconds()
+  const nanoseconds = String(milliseconds * 1000 * 1000).padStart(9, '0')
+
+  return `${year}-${month}-${day}T${hour}:${minute}:${seconds}.${nanoseconds}Z`
+}
+
+/**
+ * Parses a date string formatted as `RFC3339Nano` into a
+ * JavaScript Date object
+ */
+export function parseRFC3339 (time: string): Date {
+  const rfc3339Matcher = new RegExp(
+    // 2006-01-02T
+    '(\\d{4})-(\\d{2})-(\\d{2})T' +
+    // 15:04:05
+    '(\\d{2}):(\\d{2}):(\\d{2})' +
+    // .999999999Z
+    '\\.(\\d+)Z'
+  )
+  const m = String(time).trim().match(rfc3339Matcher)
+
+  if (m == null) {
+    throw new Error('Invalid format')
+  }
+
+  const year = parseInt(m[1], 10)
+  const month = parseInt(m[2], 10) - 1
+  const date = parseInt(m[3], 10)
+  const hour = parseInt(m[4], 10)
+  const minute = parseInt(m[5], 10)
+  const second = parseInt(m[6], 10)
+  const millisecond = parseInt(m[7].slice(0, -6), 10)
+
+  return new Date(Date.UTC(year, month, date, hour, minute, second, millisecond))
+}

package/src/record/validators.ts

@@ -0,0 +1,69 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { Libp2pRecord } from './index.js'
+import type { Validators } from '../index.js'
+
+/**
+ * Checks a record and ensures it is still valid.
+ * It runs the needed validators.
+ * If verification fails the returned Promise will reject with the error.
+ */
+export async function verifyRecord (validators: Validators, record: Libp2pRecord): Promise<void> {
+  const key = record.key
+  const keyString = uint8ArrayToString(key)
+  const parts = keyString.split('/')
+
+  if (parts.length < 3) {
+    // No validator available
+    return
+  }
+
+  const validator = validators[parts[1].toString()]
+
+  if (validator == null) {
+    const errMsg = 'Invalid record keytype'
+
+    throw new CodeError(errMsg, 'ERR_INVALID_RECORD_KEY_TYPE')
+  }
+
+  await validator(key, record.value)
+}
+
+/**
+ * Validator for public key records.
+ * Verifies that the passed in record value is the PublicKey
+ * that matches the passed in key.
+ * If validation fails the returned Promise will reject with the error.
+ *
+ * @param {Uint8Array} key - A valid key is of the form `'/pk/<keymultihash>'`
+ * @param {Uint8Array} publicKey - The public key to validate against (protobuf encoded).
+ */
+const validatePublicKeyRecord = async (key: Uint8Array, publicKey: Uint8Array): Promise<void> => {
+  if (!(key instanceof Uint8Array)) {
+    throw new CodeError('"key" must be a Uint8Array', 'ERR_INVALID_RECORD_KEY_NOT_BUFFER')
+  }
+
+  if (key.byteLength < 5) {
+    throw new CodeError('invalid public key record', 'ERR_INVALID_RECORD_KEY_TOO_SHORT')
+  }
+
+  const prefix = uint8ArrayToString(key.subarray(0, 4))
+
+  if (prefix !== '/pk/') {
+    throw new CodeError('key was not prefixed with /pk/', 'ERR_INVALID_RECORD_KEY_BAD_PREFIX')
+  }
+
+  const keyhash = key.slice(4)
+
+  const publicKeyHash = await sha256.digest(publicKey)
+
+  if (!uint8ArrayEquals(keyhash, publicKeyHash.bytes)) {
+    throw new CodeError('public key does not match passed in key', 'ERR_INVALID_RECORD_HASH_MISMATCH')
+  }
+}
+
+export const validators: Validators = {
+  pk: validatePublicKeyRecord
+}

package/src/routing-table/index.ts

@@ -1,14 +1,14 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 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 { ConnectionManager } from '@libp2p/interface-connection-manager'
-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/interfaces/startable'
+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'
 
 export const KAD_CLOSE_TAG_NAME = 'kad-close'

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 { EventEmitter } from '@libp2p/interfaces/events'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import { EventEmitter } from '@libp2p/interface/events'
+import type { PeerId } from '@libp2p/interface/peer-id'
 
 function arrayEquals (array1: Uint8Array, array2: Uint8Array): boolean {
   if (array1 === array2) {

package/src/routing-table/refresh.ts

@@ -8,7 +8,7 @@ import { TABLE_REFRESH_INTERVAL, TABLE_REFRESH_QUERY_TIMEOUT } from '../constant
 import GENERATED_PREFIXES from './generated-prefix-list.js'
 import type { RoutingTable } from './index.js'
 import type { PeerRouting } from '../peer-routing/index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Logger } from '@libp2p/logger'
 
 /**

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

@@ -1,10 +1,10 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { CID } from 'multiformats/cid'
 import type { Message } from '../../message/index.js'
 import type { Providers } from '../../providers'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:add-provider')
 

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

@@ -8,9 +8,9 @@ import {
 } from '../../utils.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:find-node')