@libp2p/kad-dht 15.1.11 → 16.0.0-049bfa0fa

package/src/query/manager.ts

@@ -1,4 +1,4 @@
-import { createScalableCuckooFilter } from '@libp2p/utils/filters'
+import { createScalableCuckooFilter } from '@libp2p/utils'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
 import { setMaxListeners } from 'main-event'

package/src/query/query-path.ts

@@ -1,5 +1,5 @@
 import { AbortError } from '@libp2p/interface'
-import { Queue } from '@libp2p/utils/queue'
+import { Queue } from '@libp2p/utils'
 import { pushable } from 'it-pushable'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
@@ -9,7 +9,7 @@ import type { QueryEvent } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
 import type { Logger, PeerId, RoutingOptions, AbortOptions, PeerInfo } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
-import type { Filter } from '@libp2p/utils/filters'
+import type { Filter } from '@libp2p/utils'
 
 export interface QueryPathOptions extends RoutingOptions {
   /**
@@ -171,7 +171,7 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
 
                 // only continue query if closer peer is actually closer
                 if (uint8ArrayXorCompare(closerPeerXor, peerXor) !== -1) { // eslint-disable-line max-depth
-                  log('skipping %p as they are not closer to %b than %p', closerPeer.id, key, peer)
+                  log('skipping %p as they are not closer to %b than %p', closerPeer.id, key, peer.id)
                   continue
                 }
 

package/src/reprovider.ts

@@ -1,5 +1,4 @@
-import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
-import { Queue } from '@libp2p/utils/queue'
+import { AdaptiveTimeout, Queue } from '@libp2p/utils'
 import drain from 'it-drain'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { PROVIDERS_VALIDITY, REPROVIDE_CONCURRENCY, REPROVIDE_INTERVAL, REPROVIDE_MAX_QUEUE_SIZE, REPROVIDE_THRESHOLD, REPROVIDE_TIMEOUT } from './constants.js'
@@ -8,7 +7,7 @@ import type { ContentRouting } from './content-routing/index.js'
 import type { OperationMetrics } from './kad-dht.js'
 import type { AbortOptions, ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { AddressManager } from '@libp2p/interface-internal'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats/cid'
 

package/src/routing-table/index.ts

@@ -1,6 +1,5 @@
 import { start, stop } from '@libp2p/interface'
-import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
-import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { AdaptiveTimeout, PeerQueue } from '@libp2p/utils'
 import { anySignal } from 'any-signal'
 import parallel from 'it-parallel'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
@@ -11,7 +10,7 @@ import type { Bucket, GetClosestPeersOptions, LeafBucket, Peer } from './k-bucke
 import type { Network } from '../network.js'
 import type { AbortOptions, ComponentLogger, CounterGroup, Logger, Metric, Metrics, PeerId, PeerStore, Startable, Stream } from '@libp2p/interface'
 import type { Ping } from '@libp2p/ping'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 
 export const KBUCKET_SIZE = 20
 export const PREFIX_LENGTH = 6

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

@@ -1,5 +1,5 @@
 import { InvalidMessageError } from '@libp2p/interface'
-import { protocols } from '@multiformats/multiaddr'
+import { CODE_P2P } from '@multiformats/multiaddr'
 import { equals as uint8ArrayEquals } from 'uint8arrays'
 import { MessageType } from '../../message/dht.js'
 import type { PeerInfoMapper } from '../../index.js'
@@ -61,7 +61,7 @@ export class FindNodeHandler implements DHTMessageHandler {
       if (uint8ArrayEquals(this.peerId.toMultihash().bytes, msg.key)) {
         closer.push({
           id: this.peerId,
-          multiaddrs: this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
+          multiaddrs: this.addressManager.getAddresses().map(ma => ma.decapsulateCode(CODE_P2P))
         })
       }
 

package/src/rpc/index.ts

@@ -1,5 +1,5 @@
 import { TimeoutError } from '@libp2p/interface'
-import { pbStream } from 'it-protobuf-stream'
+import { pbStream } from '@libp2p/utils'
 import { Message, MessageType } from '../message/dht.js'
 import { AddProviderHandler } from './handlers/add-provider.js'
 import { FindNodeHandler } from './handlers/find-node.js'
@@ -15,7 +15,7 @@ import type { GetProvidersHandlerComponents } from './handlers/get-providers.js'
 import type { GetValueHandlerComponents } from './handlers/get-value.js'
 import type { PutValueHandlerComponents } from './handlers/put-value.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { CounterGroup, Logger, Metrics, PeerId, IncomingStreamData, MetricGroup } from '@libp2p/interface'
+import type { CounterGroup, Logger, Metrics, PeerId, MetricGroup, Connection, Stream } from '@libp2p/interface'
 
 export interface DHTMessageHandler {
   handle(peerId: PeerId, msg: Message): Promise<Message | undefined>
@@ -95,65 +95,61 @@ export class RPC {
   /**
    * Handle incoming streams on the dht protocol
    */
-  onIncomingStream (data: IncomingStreamData): void {
-    const message = 'unknown'
+  async onIncomingStream (stream: Stream, connection: Connection): Promise<void> {
+    const abortListener = (): void => {
+      stream.abort(new TimeoutError())
+    }
+
+    let signal = AbortSignal.timeout(this.incomingMessageTimeout)
+    signal.addEventListener('abort', abortListener)
+
+    const messages = pbStream(stream).pb(Message)
 
-    Promise.resolve().then(async () => {
-      const { stream, connection } = data
+    while (true) {
+      // the remote will not send any more data
+      if (stream.readStatus !== 'readable') {
+        await stream.close({
+          signal
+        })
 
-      const abortListener = (): void => {
-        stream.abort(new TimeoutError())
+        break
       }
 
-      let signal = AbortSignal.timeout(this.incomingMessageTimeout)
-      signal.addEventListener('abort', abortListener)
+      const message = await messages.read({
+        signal
+      })
 
-      const messages = pbStream(stream).pb(Message)
+      const stopSuccessTimer = this.metrics?.rpcTime?.timer(message.type.toString())
+      const stopErrorTimer = this.metrics?.rpcTime?.timer(message.type.toString())
+      let errored = false
 
       try {
-        while (true) {
-          const message = await messages.read({
+        // handle the message
+        this.log('incoming %s from %p', message.type, connection.remotePeer)
+        const res = await this.handleMessage(connection.remotePeer, message)
+
+        // Not all handlers will return a response
+        if (res != null) {
+          await messages.write(res, {
             signal
           })
-
-          const stopSuccessTimer = this.metrics?.rpcTime?.timer(message.type.toString())
-          const stopErrorTimer = this.metrics?.rpcTime?.timer(message.type.toString())
-          let errored = false
-
-          try {
-            // handle the message
-            this.log('incoming %s from %p', message.type, connection.remotePeer)
-            const res = await this.handleMessage(connection.remotePeer, message)
-
-            // Not all handlers will return a response
-            if (res != null) {
-              await messages.write(res, {
-                signal
-              })
-            }
-          } catch (err) {
-            errored = true
-            stopErrorTimer?.()
-
-            throw err
-          } finally {
-            if (!errored) {
-              stopSuccessTimer?.()
-            }
-          }
-
-          // we have received a message so reset the timeout controller to
-          // allow the remote to send another
-          signal.removeEventListener('abort', abortListener)
-          signal = AbortSignal.timeout(this.incomingMessageTimeout)
-          signal.addEventListener('abort', abortListener)
         }
-      } catch (err: any) {
-        stream.abort(err)
+      } catch (err) {
+        errored = true
+        stopErrorTimer?.()
+
+        throw err
+      } finally {
+        if (!errored) {
+          stopSuccessTimer?.()
+        }
       }
-    })
-      .catch(err => {
-        this.log.error('error handling %s RPC message from %p - %e', message, data.connection.remotePeer, err)
-      })
+
+      // we have received a message so reset the timeout controller to
+      // allow the remote to send another
+      signal.removeEventListener('abort', abortListener)
+      signal = AbortSignal.timeout(this.incomingMessageTimeout)
+      signal.addEventListener('abort', abortListener)
+    }
   }
 }

package/src/utils.ts

@@ -1,6 +1,6 @@
 import { peerIdFromMultihash, peerIdFromString } from '@libp2p/peer-id'
 import { Libp2pRecord } from '@libp2p/record'
-import { isPrivateIp } from '@libp2p/utils/private-ip'
+import { isPrivate } from '@libp2p/utils'
 import { Key } from 'interface-datastore/key'
 import { CID } from 'multiformats/cid'
 import * as raw from 'multiformats/codecs/raw'
@@ -12,7 +12,6 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import type { Operation, OperationMetrics } from './kad-dht.js'
 import type { AbortOptions, PeerId, PeerInfo } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
 
 // const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
 const PK_PREFIX = uint8ArrayFromString('/pk/')
@@ -21,34 +20,7 @@ export function removePrivateAddressesMapper (peer: PeerInfo): PeerInfo {
   return {
     ...peer,
     multiaddrs: peer.multiaddrs.filter(multiaddr => {
-      const [[type, addr]] = multiaddr.stringTuples()
-
-      // treat /dns, /dns4, and /dns6 addrs as public
-      if (type === 53 || type === 54 || type === 55) {
-        // localhost can be a dns address but it's private
-        if (addr === 'localhost') {
-          return false
-        }
-
-        return true
-      }
-
-      if (type !== 4 && type !== 6) {
-        return false
-      }
-
-      if (addr == null) {
-        return false
-      }
-
-      const isPrivate = isPrivateIp(addr)
-
-      if (isPrivate == null) {
-        // not an ip address
-        return true
-      }
-
-      return !isPrivate
+      return !isPrivate(multiaddr)
     })
   }
 }
@@ -57,28 +29,7 @@ export function removePublicAddressesMapper (peer: PeerInfo): PeerInfo {
   return {
     ...peer,
     multiaddrs: peer.multiaddrs.filter(multiaddr => {
-      const [[type, addr]] = multiaddr.stringTuples()
-
-      if (addr === 'localhost') {
-        return true
-      }
-
-      if (type !== 4 && type !== 6) {
-        return false
-      }
-
-      if (addr == null) {
-        return false
-      }
-
-      const isPrivate = isPrivateIp(addr)
-
-      if (isPrivate == null) {
-        // not an ip address
-        return false
-      }
-
-      return isPrivate
+      return isPrivate(multiaddr)
     })
   }
 }
@@ -160,49 +111,6 @@ export function createPutRecord (key: Uint8Array, value: Uint8Array): Uint8Array
   return rec.serialize()
 }
 
-export function debounce (callback: () => void, wait: number = 100): () => void {
-  let timeout: ReturnType<typeof setTimeout>
-
-  return (): void => {
-    clearTimeout(timeout)
-    timeout = setTimeout(() => { callback() }, wait)
-  }
-}
-
-// see https://github.com/multiformats/multiaddr/blob/master/protocols.csv
-const P2P_CIRCUIT_CODE = 290
-const DNS4_CODE = 54
-const DNS6_CODE = 55
-const DNSADDR_CODE = 56
-const IP4_CODE = 4
-const IP6_CODE = 41
-
-export function multiaddrIsPublic (multiaddr: Multiaddr): boolean {
-  const tuples = multiaddr.stringTuples()
-
-  // p2p-circuit should not enable server mode
-  for (const tuple of tuples) {
-    if (tuple[0] === P2P_CIRCUIT_CODE) {
-      return false
-    }
-  }
-
-  // dns4 or dns6 or dnsaddr
-  if (tuples[0][0] === DNS4_CODE || tuples[0][0] === DNS6_CODE || tuples[0][0] === DNSADDR_CODE) {
-    return true
-  }
-
-  // ip4 or ip6
-  if (tuples[0][0] === IP4_CODE || tuples[0][0] === IP6_CODE) {
-    const result = isPrivateIp(`${tuples[0][1]}`)
-    const isPublic = result == null || !result
-
-    return isPublic
-  }
-
-  return false
-}
-
 /**
  * Parse the CID and provider peer id from the key
  */

package/dist/typedoc-urls.json

@@ -1,65 +0,0 @@
-{
-  "codec": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad-dht.MessageType.codec.html",
-  "EventTypes": "https://libp2p.github.io/js-libp2p/enums/_libp2p_kad-dht.EventTypes.html",
-  ".:EventTypes": "https://libp2p.github.io/js-libp2p/enums/_libp2p_kad-dht.EventTypes.html",
-  "MessageType": "https://libp2p.github.io/js-libp2p/enums/_libp2p_kad-dht.MessageType.html",
-  "AddPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.AddPeerEvent.html",
-  ".:AddPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.AddPeerEvent.html",
-  "DHTRecord": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DHTRecord.html",
-  ".:DHTRecord": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DHTRecord.html",
-  "DialPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DialPeerEvent.html",
-  ".:DialPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DialPeerEvent.html",
-  "DisjointPath": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DisjointPath.html",
-  ".:DisjointPath": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.DisjointPath.html",
-  "FinalPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.FinalPeerEvent.html",
-  ".:FinalPeerEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.FinalPeerEvent.html",
-  "KadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.KadDHT.html",
-  ".:KadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.KadDHT.html",
-  "KadDHTComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.KadDHTComponents.html",
-  ".:KadDHTComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.KadDHTComponents.html",
-  "KadDHTInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.KadDHTInit.html",
-  ".:KadDHTInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.KadDHTInit.html",
-  "PathEndedEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PathEndedEvent.html",
-  ".:PathEndedEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PathEndedEvent.html",
-  "PeerInfoMapper": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PeerInfoMapper.html",
-  ".:PeerInfoMapper": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PeerInfoMapper.html",
-  "PeerResponseEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PeerResponseEvent.html",
-  ".:PeerResponseEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.PeerResponseEvent.html",
-  "ProviderEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ProviderEvent.html",
-  ".:ProviderEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ProviderEvent.html",
-  "ProvidersInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ProvidersInit.html",
-  ".:ProvidersInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ProvidersInit.html",
-  "QueryErrorEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.QueryErrorEvent.html",
-  ".:QueryErrorEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.QueryErrorEvent.html",
-  "ReProvideInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ReProvideInit.html",
-  ".:ReProvideInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ReProvideInit.html",
-  "RoutingTable": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.RoutingTable.html",
-  ".:RoutingTable": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.RoutingTable.html",
-  "SelectFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SelectFn.html",
-  ".:SelectFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SelectFn.html",
-  "SendQueryEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SendQueryEvent.html",
-  ".:SendQueryEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SendQueryEvent.html",
-  "SetModeOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SetModeOptions.html",
-  ".:SetModeOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SetModeOptions.html",
-  "SingleKadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SingleKadDHT.html",
-  ".:SingleKadDHT": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.SingleKadDHT.html",
-  "ValidateFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ValidateFn.html",
-  ".:ValidateFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ValidateFn.html",
-  "ValueEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ValueEvent.html",
-  ".:ValueEvent": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_kad-dht.ValueEvent.html",
-  "DHTProgressEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.DHTProgressEvents.html",
-  ".:DHTProgressEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.DHTProgressEvents.html",
-  "MessageName": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.MessageName.html",
-  ".:MessageName": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.MessageName.html",
-  "QueryEvent": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.QueryEvent.html",
-  ".:QueryEvent": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.QueryEvent.html",
-  "Selectors": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.Selectors.html",
-  ".:Selectors": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.Selectors.html",
-  "Validators": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.Validators.html",
-  ".:Validators": "https://libp2p.github.io/js-libp2p/types/_libp2p_kad-dht.Validators.html",
-  "kadDHT": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad-dht.kadDHT.html",
-  ".:kadDHT": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad-dht.kadDHT.html",
-  "passthroughMapper": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad-dht.passthroughMapper.html",
-  "removePrivateAddressesMapper": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad-dht.removePrivateAddressesMapper.html",
-  "removePublicAddressesMapper": "https://libp2p.github.io/js-libp2p/functions/_libp2p_kad-dht.removePublicAddressesMapper.html"
-}