@libp2p/kad-dht 1.0.16 → 3.0.1

package/src/content-routing/index.ts

@@ -10,7 +10,7 @@ import {
   providerEvent
 } from '../query/events.js'
 import { logger } from '@libp2p/logger'
-import type { QueryEvent, QueryOptions } from '@libp2p/interfaces/dht'
+import type { QueryEvent, QueryOptions } from '@libp2p/interface-dht'
 import type { PeerRouting } from '../peer-routing/index.js'
 import type { QueryManager } from '../query/manager.js'
 import type { RoutingTable } from '../routing-table/index.js'
@@ -21,8 +21,8 @@ import type { QueryFunc } from '../query/types.js'
 import type { CID } from 'multiformats/cid'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import { Components, Initializable } from '@libp2p/components'
 
 export interface ContentRoutingInit {
   network: Network

package/src/dual-kad-dht.ts

@@ -3,14 +3,14 @@ import errCode from 'err-code'
 import merge from 'it-merge'
 import { queryErrorEvent } from './query/events.js'
 import type { KadDHT } from './kad-dht.js'
-import type { DualDHT, QueryOptions } from '@libp2p/interfaces/dht'
+import type { DualDHT, QueryOptions } from '@libp2p/interface-dht'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
 import type { CID } from 'multiformats'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { PeerDiscoveryEvents } from '@libp2p/interfaces/peer-discovery'
-import { Components, Initializable } from '@libp2p/interfaces/components'
-import { symbol } from '@libp2p/interfaces/peer-discovery'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery'
+import { Components, Initializable } from '@libp2p/components'
+import { symbol } from '@libp2p/interface-peer-discovery'
 
 const log = logger('libp2p:kad-dht')
 

package/src/index.ts

@@ -1,6 +1,6 @@
 import { KadDHT as SingleKadDHT } from './kad-dht.js'
 import { DualKadDHT } from './dual-kad-dht.js'
-import type { Selectors, Validators } from '@libp2p/interfaces/dht'
+import type { Selectors, Validators } from '@libp2p/interface-dht'
 
 export interface KadDHTInit {
   /**
@@ -45,6 +45,16 @@ export interface KadDHTInit {
    * be evicted from the routing table or not (default 10)
    */
   pingConcurrency?: number
+
+  /**
+   * How many parallel incoming streams to allow on the DHT protocol per-connection
+   */
+  maxInboundStreams?: number
+
+  /**
+   * How many parallel outgoing streams to allow on the DHT protocol per-connection
+   */
+  maxOutboundStreams?: number
 }
 
 export class KadDHT extends DualKadDHT {

package/src/kad-dht.ts

@@ -14,19 +14,22 @@ import {
   removePublicAddresses
 } from './utils.js'
 import { Logger, logger } from '@libp2p/logger'
-import type { QueryOptions, Validators, Selectors, DHT } from '@libp2p/interfaces/dht'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { QueryOptions, Validators, Selectors, DHT } from '@libp2p/interface-dht'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { CID } from 'multiformats/cid'
-import type { PeerDiscoveryEvents } from '@libp2p/interfaces/peer-discovery'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery'
+import { Components, Initializable } from '@libp2p/components'
 import type { KadDHTInit } from './index.js'
 import { validators as recordValidators } from '@libp2p/record/validators'
 import { selectors as recordSelectors } from '@libp2p/record/selectors'
-import { symbol } from '@libp2p/interfaces/peer-discovery'
+import { symbol } from '@libp2p/interface-peer-discovery'
 import { PROTOCOL_DHT, PROTOCOL_PREFIX, LAN_PREFIX } from './constants.js'
 
+export const DEFAULT_MAX_INBOUND_STREAMS = 32
+export const DEFAULT_MAX_OUTBOUND_STREAMS = 64
+
 export interface SingleKadDHTInit extends KadDHTInit {
   /**
    * Whether to start up in lan or wan mode
@@ -60,6 +63,8 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT, In
   private readonly rpc: RPC
   private readonly topologyListener: TopologyListener
   private readonly querySelf: QuerySelf
+  private readonly maxInboundStreams: number
+  private readonly maxOutboundStreams: number
 
   /**
    * Create a new KadDHT
@@ -76,7 +81,9 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT, In
       lan,
       protocolPrefix,
       pingTimeout,
-      pingConcurrency
+      pingConcurrency,
+      maxInboundStreams,
+      maxOutboundStreams
     } = init
 
     this.running = false
@@ -85,6 +92,8 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT, In
     this.protocol = `${protocolPrefix ?? PROTOCOL_PREFIX}${lan === true ? LAN_PREFIX : ''}${PROTOCOL_DHT}`
     this.kBucketSize = kBucketSize ?? 20
     this.clientMode = clientMode ?? true
+    this.maxInboundStreams = maxInboundStreams ?? DEFAULT_MAX_INBOUND_STREAMS
+    this.maxOutboundStreams = maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS
     this.routingTable = new RoutingTable({
       kBucketSize,
       lan: this.lan,
@@ -264,7 +273,10 @@ export class KadDHT extends EventEmitter<PeerDiscoveryEvents> implements DHT, In
     } else {
       this.log('enabling server mode')
       this.clientMode = false
-      await this.components.getRegistrar().handle(this.protocol, this.rpc.onIncomingStream.bind(this.rpc))
+      await this.components.getRegistrar().handle(this.protocol, this.rpc.onIncomingStream.bind(this.rpc), {
+        maxInboundStreams: this.maxInboundStreams,
+        maxOutboundStreams: this.maxOutboundStreams
+      })
     }
   }
 

package/src/message/dht.ts

@@ -3,6 +3,7 @@
 
 import { encodeMessage, decodeMessage, message, bytes, string, enumeration, int32 } from 'protons-runtime'
 import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Record {
   key?: Uint8Array
@@ -23,11 +24,11 @@ export namespace Record {
     })
   }
 
-  export const encode = (obj: Record): Uint8Array => {
+  export const encode = (obj: Record): Uint8ArrayList => {
     return encodeMessage(obj, Record.codec())
   }
 
-  export const decode = (buf: Uint8Array): Record => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Record => {
     return decodeMessage(buf, Record.codec())
   }
 }
@@ -101,11 +102,11 @@ export namespace Message {
       })
     }
 
-    export const encode = (obj: Peer): Uint8Array => {
+    export const encode = (obj: Peer): Uint8ArrayList => {
       return encodeMessage(obj, Peer.codec())
     }
 
-    export const decode = (buf: Uint8Array): Peer => {
+    export const decode = (buf: Uint8Array | Uint8ArrayList): Peer => {
       return decodeMessage(buf, Peer.codec())
     }
   }
@@ -121,11 +122,11 @@ export namespace Message {
     })
   }
 
-  export const encode = (obj: Message): Uint8Array => {
+  export const encode = (obj: Message): Uint8ArrayList => {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array): Message => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
     return decodeMessage(buf, Message.codec())
   }
 }

package/src/message/index.ts

@@ -2,7 +2,8 @@ import { peerIdFromBytes } from '@libp2p/peer-id'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { Libp2pRecord } from '@libp2p/record'
 import { Message as PBMessage } from './dht.js'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export const MESSAGE_TYPE = PBMessage.MessageType
 export const CONNECTION_TYPE = PBMessage.ConnectionType
@@ -71,7 +72,7 @@ export class Message {
   /**
    * Decode from protobuf
    */
-  static deserialize (raw: Uint8Array) {
+  static deserialize (raw: Uint8ArrayList | Uint8Array) {
     const dec = PBMessage.decode(raw)
 
     const msg = new Message(dec.type ?? PBMessage.MessageType.PUT_VALUE, dec.key ?? Uint8Array.from([]), dec.clusterLevelRaw ?? 0)

package/src/network.ts

@@ -12,15 +12,16 @@ import {
   queryErrorEvent
 } from './query/events.js'
 import { logger } from '@libp2p/logger'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Logger } from '@libp2p/logger'
 import type { Duplex } from 'it-stream-types'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
-import { Components, Initializable } from '@libp2p/interfaces/components'
-import type { Stream } from '@libp2p/interfaces/connection'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import { Components, Initializable } from '@libp2p/components'
+import type { Stream } from '@libp2p/interface-connection'
 import { abortableDuplex } from 'abortable-iterator'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface NetworkInit {
   protocol: string
@@ -97,8 +98,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
 
     try {
       const connection = await this.components.getConnectionManager().openConnection(to, options)
-      const streamData = await connection.newStream(this.protocol, options)
-      stream = streamData.stream
+      const stream = await connection.newStream(this.protocol, options)
 
       const response = await this._writeReadMessage(stream, msg.serialize(), options)
 
@@ -134,8 +134,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
 
     try {
       const connection = await this.components.getConnectionManager().openConnection(to, options)
-      const data = await connection.newStream(this.protocol, options)
-      stream = data.stream
+      const stream = await connection.newStream(this.protocol, options)
 
       await this._writeMessage(stream, msg.serialize(), options)
 
@@ -152,7 +151,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
   /**
    * Write a message to the given stream
    */
-  async _writeMessage (stream: Duplex<Uint8Array>, msg: Uint8Array, options: AbortOptions) {
+  async _writeMessage (stream: Duplex<Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }
@@ -170,7 +169,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
    * If no response is received after the specified timeout
    * this will error out.
    */
-  async _writeReadMessage (stream: Duplex<Uint8Array>, msg: Uint8Array, options: AbortOptions) {
+  async _writeReadMessage (stream: Duplex<Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }

package/src/peer-list/index.ts

@@ -1,4 +1,4 @@
-import type { PeerId } from '@libp2p/interfaces/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 * as utils from '../utils.js'
 import { compare as uint8ArrayCompare } from 'uint8arrays/compare'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 interface PeerDistance {
   peerId: PeerId

package/src/peer-routing/index.ts

@@ -13,16 +13,16 @@ import { Libp2pRecord } from '@libp2p/record'
 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 { DHTRecord, QueryOptions, Validators } from '@libp2p/interface-dht'
 import type { RoutingTable } from '../routing-table/index.js'
 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 { PeerInfo } from '@libp2p/interfaces/peer-info'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { Components, Initializable } from '@libp2p/components'
 
 export interface PeerRoutingInit {
   routingTable: RoutingTable

package/src/providers.ts

@@ -14,8 +14,8 @@ import { peerIdFromString } from '@libp2p/peer-id'
 import type { Datastore } from 'interface-datastore'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { Components, Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:providers')
 

package/src/query/events.ts

@@ -1,8 +1,8 @@
 import { MESSAGE_TYPE_LOOKUP } from '../message/index.js'
 import type { Message } from '../message/dht.js'
-import type { SendingQueryEvent, PeerResponseEvent, DialingPeerEvent, AddingPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '@libp2p/interfaces/dht'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { SendingQueryEvent, PeerResponseEvent, DialingPeerEvent, AddingPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '@libp2p/interface-dht'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Libp2pRecord } from '@libp2p/record'
 
 export interface QueryEventFields {

package/src/query/manager.ts

@@ -9,11 +9,11 @@ import merge from 'it-merge'
 import { setMaxListeners } from 'events'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
 import { logger } from '@libp2p/logger'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+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/interfaces/dht'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { QueryOptions } from '@libp2p/interface-dht'
+import { Components, Initializable } from '@libp2p/components'
 
 const METRIC_RUNNING_QUERIES = 'running-queries'
 

package/src/query/query-path.ts

@@ -7,12 +7,12 @@ import { convertPeerId, convertBuffer } from '../utils.js'
 import { TimeoutController } from 'timeout-abort-controller'
 import { anySignal } from 'any-signal'
 import { queryErrorEvent } from './events.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { CleanUpEvents } from './manager.js'
 import type { Logger } from '@libp2p/logger'
 import type { QueryFunc } from '../query/types.js'
-import type { QueryEvent } from '@libp2p/interfaces/dht'
+import type { QueryEvent } from '@libp2p/interface-dht'
 
 const MAX_XOR = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
 

package/src/query/types.ts

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

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/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
 
 export interface QuerySelfInit {
   lan: boolean

package/src/routing-table/index.ts

@@ -4,10 +4,10 @@ import * as utils from '../utils.js'
 import Queue from 'p-queue'
 import { TimeoutController } from 'timeout-abort-controller'
 import { logger } from '@libp2p/logger'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+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/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
 
 export interface KBucketPeer {
   id: Uint8Array
@@ -158,7 +158,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 { stream } = await connection.newStream(this.protocol, options)
+              const stream = await connection.newStream(this.protocol, options)
               stream.close()
               responded++
             } catch (err: any) {

package/src/routing-table/refresh.ts

@@ -10,7 +10,7 @@ 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/interfaces/components'
+import type { Components, Initializable } from '@libp2p/components'
 
 /**
  * Cannot generate random KadIds longer than this + 1

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

@@ -2,10 +2,10 @@ import { CID } from 'multiformats/cid'
 import errcode from 'err-code'
 import { logger } from '@libp2p/logger'
 import type { Providers } from '../../providers'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+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/interfaces/components'
+import type { Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:add-provider')
 

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

@@ -5,13 +5,13 @@ import {
   removePublicAddresses
 } from '../../utils.js'
 import { equals as uint8ArrayEquals } from 'uint8arrays'
-import { Components } from '@libp2p/interfaces/components'
+import { Components } from '@libp2p/components'
 import { protocols } from '@multiformats/multiaddr'
-import type { Initializable } from '@libp2p/interfaces/components'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+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/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:find-node')
 

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

@@ -9,9 +9,9 @@ import { logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
 import type { Providers } from '../../providers.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import { Components, Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-providers')
 

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

@@ -7,9 +7,9 @@ import {
 import { bufferToRecordKey, isPublicKeyKey, fromPublicKeyKey } from '../../utils.js'
 import { logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerRouting } from '../../peer-routing/index.js'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-value')
 

package/src/rpc/handlers/ping.ts

@@ -1,8 +1,8 @@
 import { logger } from '@libp2p/logger'
 import type { Message } from '../../message/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { Initializable } from '@libp2p/interfaces/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:ping')
 

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

@@ -3,10 +3,10 @@ import errcode from 'err-code'
 import { verifyRecord } from '@libp2p/record/validators'
 import { Logger, logger } from '@libp2p/logger'
 import type { DHTMessageHandler } from '../index.js'
-import type { Validators } from '@libp2p/interfaces/dht'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+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/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
 
 export interface PutValueHandlerInit {
   validators: Validators

package/src/rpc/index.ts

@@ -2,7 +2,7 @@ import { pipe } from 'it-pipe'
 import * as lp from 'it-length-prefixed'
 import { Logger, logger } from '@libp2p/logger'
 import type { RoutingTable } from '../routing-table'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { Message, MESSAGE_TYPE } from '../message/index.js'
 import { AddProviderHandler } from './handlers/add-provider.js'
 import { FindNodeHandler } from './handlers/find-node.js'
@@ -10,11 +10,11 @@ import { GetProvidersHandler } from './handlers/get-providers.js'
 import { GetValueHandler } from './handlers/get-value.js'
 import { PingHandler } from './handlers/ping.js'
 import { PutValueHandler } from './handlers/put-value.js'
-import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
 import type { Providers } from '../providers'
 import type { PeerRouting } from '../peer-routing'
-import type { Validators } from '@libp2p/interfaces/dht'
-import type { Components, Initializable } from '@libp2p/interfaces/components'
+import type { Validators } from '@libp2p/interface-dht'
+import type { Components, Initializable } from '@libp2p/components'
 
 export interface DHTMessageHandler extends Initializable {
   handle: (peerId: PeerId, msg: Message) => Promise<Message | undefined>

package/src/topology-listener.ts

@@ -3,8 +3,8 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { logger } from '@libp2p/logger'
 import type { Logger } from '@libp2p/logger'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { Components, Initializable } from '@libp2p/components'
 
 export interface TopologyListenerInit {
   protocol: string

package/src/utils.ts

@@ -5,9 +5,9 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import isPrivateIp from 'private-ip'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { peerIdFromBytes } from '@libp2p/peer-id'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { RECORD_KEY_PREFIX } from './constants.js'
 
 // const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
@@ -92,15 +92,15 @@ export function keyForPublicKey (peer: PeerId) {
 }
 
 export function isPublicKeyKey (key: Uint8Array) {
-  return uint8ArrayToString(key.slice(0, 4)) === '/pk/'
+  return uint8ArrayToString(key.subarray(0, 4)) === '/pk/'
 }
 
 export function isIPNSKey (key: Uint8Array) {
-  return uint8ArrayToString(key.slice(0, 4)) === '/ipns/'
+  return uint8ArrayToString(key.subarray(0, 4)) === '/ipns/'
 }
 
 export function fromPublicKeyKey (key: Uint8Array) {
-  return peerIdFromBytes(key.slice(4))
+  return peerIdFromBytes(key.subarray(4))
 }
 
 /**