@libp2p/kad-dht 11.0.8 → 12.0.0-28587d24f

package/src/routing-table/refresh.ts

@@ -21,7 +21,7 @@ export interface RoutingTableRefreshComponents {
 export interface RoutingTableRefreshInit {
   peerRouting: PeerRouting
   routingTable: RoutingTable
-  lan: boolean
+  logPrefix: string
   refreshInterval?: number
   refreshQueryTimeout?: number
 }
@@ -40,8 +40,8 @@ export class RoutingTableRefresh {
   private refreshTimeoutId?: ReturnType<typeof setTimeout>
 
   constructor (components: RoutingTableRefreshComponents, init: RoutingTableRefreshInit) {
-    const { peerRouting, routingTable, refreshInterval, refreshQueryTimeout, lan } = init
-    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:routing-table:refresh`)
+    const { peerRouting, routingTable, refreshInterval, refreshQueryTimeout, logPrefix } = init
+    this.log = components.logger.forComponent(`${logPrefix}:routing-table:refresh`)
     this.peerRouting = peerRouting
     this.routingTable = routingTable
     this.refreshInterval = refreshInterval ?? TABLE_REFRESH_INTERVAL
@@ -147,7 +147,7 @@ export class RoutingTableRefresh {
       maxCommonPrefix = MAX_COMMON_PREFIX_LENGTH
     }
 
-    const dates = []
+    const dates: Date[] = []
 
     for (let i = 0; i <= maxCommonPrefix; i++) {
       // defaults to the zero value if we haven't refreshed it yet.

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

@@ -1,6 +1,8 @@
 import { CodeError } from '@libp2p/interface'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { multiaddr } from '@multiformats/multiaddr'
 import { CID } from 'multiformats/cid'
-import type { Message } from '../../message/index.js'
+import type { Message } from '../../message/dht.js'
 import type { Providers } from '../../providers'
 import type { DHTMessageHandler } from '../index.js'
 import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
@@ -11,6 +13,7 @@ export interface AddProviderComponents {
 
 export interface AddProviderHandlerInit {
   providers: Providers
+  logPrefix: string
 }
 
 export class AddProviderHandler implements DHTMessageHandler {
@@ -18,7 +21,7 @@ export class AddProviderHandler implements DHTMessageHandler {
   private readonly log: Logger
 
   constructor (components: AddProviderComponents, init: AddProviderHandlerInit) {
-    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:add-provider')
+    this.log = components.logger.forComponent(`${init.logPrefix}:rpc:handlers:add-provider`)
     this.providers = init.providers
   }
 
@@ -37,14 +40,14 @@ export class AddProviderHandler implements DHTMessageHandler {
       throw new CodeError('Invalid CID', 'ERR_INVALID_CID')
     }
 
-    if (msg.providerPeers == null || msg.providerPeers.length === 0) {
+    if (msg.providers == null || msg.providers.length === 0) {
       this.log.error('no providers found in message')
     }
 
     await Promise.all(
-      msg.providerPeers.map(async (pi) => {
+      msg.providers.map(async (pi) => {
         // Ignore providers not from the originator
-        if (!pi.id.equals(peerId)) {
+        if (!peerId.equals(pi.id)) {
           this.log('invalid provider peer %p from %p', pi.id, peerId)
           return
         }
@@ -54,9 +57,9 @@ export class AddProviderHandler implements DHTMessageHandler {
           return
         }
 
-        this.log('received provider %p for %s (addrs %s)', peerId, cid, pi.multiaddrs.map((m) => m.toString()))
+        this.log('received provider %p for %s (addrs %s)', peerId, cid, pi.multiaddrs.map((m) => multiaddr(m).toString()))
 
-        await this.providers.addProvider(cid, pi.id)
+        await this.providers.addProvider(cid, peerIdFromBytes(pi.id))
       })
     )
 

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

@@ -1,10 +1,9 @@
+import { CodeError } from '@libp2p/interface'
 import { protocols } from '@multiformats/multiaddr'
 import { equals as uint8ArrayEquals } from 'uint8arrays'
-import { Message } from '../../message/index.js'
-import {
-  removePrivateAddresses,
-  removePublicAddresses
-} from '../../utils.js'
+import { MessageType } from '../../message/dht.js'
+import type { PeerInfoMapper } from '../../index.js'
+import type { Message } from '../../message/dht.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { DHTMessageHandler } from '../index.js'
 import type { ComponentLogger, Logger, PeerId, PeerInfo } from '@libp2p/interface'
@@ -12,7 +11,8 @@ import type { AddressManager } from '@libp2p/interface-internal'
 
 export interface FindNodeHandlerInit {
   peerRouting: PeerRouting
-  lan: boolean
+  logPrefix: string
+  peerInfoMapper: PeerInfoMapper
 }
 
 export interface FindNodeHandlerComponents {
@@ -23,19 +23,19 @@ export interface FindNodeHandlerComponents {
 
 export class FindNodeHandler implements DHTMessageHandler {
   private readonly peerRouting: PeerRouting
-  private readonly lan: boolean
+  private readonly peerInfoMapper: PeerInfoMapper
   private readonly peerId: PeerId
   private readonly addressManager: AddressManager
   private readonly log: Logger
 
   constructor (components: FindNodeHandlerComponents, init: FindNodeHandlerInit) {
-    const { peerRouting, lan } = init
+    const { peerRouting, logPrefix } = init
 
-    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:find-node')
+    this.log = components.logger.forComponent(`${logPrefix}:rpc:handlers:find-node`)
     this.peerId = components.peerId
     this.addressManager = components.addressManager
     this.peerRouting = peerRouting
-    this.lan = Boolean(lan)
+    this.peerInfoMapper = init.peerInfoMapper
   }
 
   /**
@@ -46,6 +46,10 @@ export class FindNodeHandler implements DHTMessageHandler {
 
     let closer: PeerInfo[] = []
 
+    if (msg.key == null) {
+      throw new CodeError('Invalid FIND_NODE message received - key was missing', 'ERR_INVALID_MESSAGE')
+    }
+
     if (uint8ArrayEquals(this.peerId.toBytes(), msg.key)) {
       closer = [{
         id: this.peerId,
@@ -55,15 +59,20 @@ export class FindNodeHandler implements DHTMessageHandler {
       closer = await this.peerRouting.getCloserPeersOffline(msg.key, peerId)
     }
 
-    closer = closer
-      .map(this.lan ? removePublicAddresses : removePrivateAddresses)
-      .filter(({ multiaddrs }) => multiaddrs.length)
-
-    const response = new Message(msg.type, new Uint8Array(0), msg.clusterLevel)
+    const response: Message = {
+      type: MessageType.FIND_NODE,
+      clusterLevel: msg.clusterLevel,
+      closer: closer
+        .map(this.peerInfoMapper)
+        .filter(({ multiaddrs }) => multiaddrs.length)
+        .map(peerInfo => ({
+          id: peerInfo.id.toBytes(),
+          multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
+        })),
+      providers: []
+    }
 
-    if (closer.length > 0) {
-      response.closerPeers = closer
-    } else {
+    if (response.closer.length === 0) {
       this.log('could not find any peers closer to %b than %p', msg.key, peerId)
     }
 

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

@@ -1,10 +1,8 @@
 import { CodeError } from '@libp2p/interface'
 import { CID } from 'multiformats/cid'
-import { Message } from '../../message/index.js'
-import {
-  removePrivateAddresses,
-  removePublicAddresses
-} from '../../utils.js'
+import { MessageType } from '../../message/dht.js'
+import type { PeerInfoMapper } from '../../index.js'
+import type { Message } from '../../message/dht.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { Providers } from '../../providers.js'
 import type { DHTMessageHandler } from '../index.js'
@@ -14,7 +12,8 @@ import type { Multiaddr } from '@multiformats/multiaddr'
 export interface GetProvidersHandlerInit {
   peerRouting: PeerRouting
   providers: Providers
-  lan: boolean
+  logPrefix: string
+  peerInfoMapper: PeerInfoMapper
 }
 
 export interface GetProvidersHandlerComponents {
@@ -25,21 +24,25 @@ export interface GetProvidersHandlerComponents {
 export class GetProvidersHandler implements DHTMessageHandler {
   private readonly peerRouting: PeerRouting
   private readonly providers: Providers
-  private readonly lan: boolean
   private readonly peerStore: PeerStore
+  private readonly peerInfoMapper: PeerInfoMapper
   private readonly log: Logger
 
   constructor (components: GetProvidersHandlerComponents, init: GetProvidersHandlerInit) {
-    const { peerRouting, providers, lan } = init
+    const { peerRouting, providers, logPrefix } = init
 
-    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:get-providers')
+    this.log = components.logger.forComponent(`${logPrefix}:rpc:handlers:get-providers`)
     this.peerStore = components.peerStore
     this.peerRouting = peerRouting
     this.providers = providers
-    this.lan = Boolean(lan)
+    this.peerInfoMapper = init.peerInfoMapper
   }
 
   async handle (peerId: PeerId, msg: Message): Promise<Message> {
+    if (msg.key == null) {
+      throw new CodeError('Invalid FIND_NODE message received - key was missing', 'ERR_INVALID_MESSAGE')
+    }
+
     let cid
     try {
       cid = CID.decode(msg.key)
@@ -56,17 +59,28 @@ export class GetProvidersHandler implements DHTMessageHandler {
 
     const providerPeers = await this._getPeers(peers)
     const closerPeers = await this._getPeers(closer.map(({ id }) => id))
-    const response = new Message(msg.type, msg.key, msg.clusterLevel)
-
-    if (providerPeers.length > 0) {
-      response.providerPeers = providerPeers
+    const response: Message = {
+      type: MessageType.GET_PROVIDERS,
+      key: msg.key,
+      clusterLevel: msg.clusterLevel,
+      closer: closerPeers
+        .map(this.peerInfoMapper)
+        .filter(({ multiaddrs }) => multiaddrs.length)
+        .map(peerInfo => ({
+          id: peerInfo.id.toBytes(),
+          multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
+        })),
+      providers: providerPeers
+        .map(this.peerInfoMapper)
+        .filter(({ multiaddrs }) => multiaddrs.length)
+        .map(peerInfo => ({
+          id: peerInfo.id.toBytes(),
+          multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
+        }))
     }
 
-    if (closerPeers.length > 0) {
-      response.closerPeers = closerPeers
-    }
+    this.log('got %s providers %s closerPeers', response.providers.length, response.closer.length)
 
-    this.log('got %s providers %s closerPeers', providerPeers.length, closerPeers.length)
     return response
   }
 
@@ -76,13 +90,12 @@ export class GetProvidersHandler implements DHTMessageHandler {
 
   async _getPeers (peerIds: PeerId[]): Promise<PeerInfo[]> {
     const output: PeerInfo[] = []
-    const addrFilter = this.lan ? removePublicAddresses : removePrivateAddresses
 
     for (const peerId of peerIds) {
       try {
         const peer = await this.peerStore.get(peerId)
 
-        const peerAfterFilter = addrFilter({
+        const peerAfterFilter = this.peerInfoMapper({
           id: peerId,
           multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
         })

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

@@ -2,9 +2,10 @@ import { CodeError } from '@libp2p/interface'
 import {
   MAX_RECORD_AGE
 } from '../../constants.js'
-import { Message, MESSAGE_TYPE } from '../../message/index.js'
+import { MessageType } from '../../message/dht.js'
 import { Libp2pRecord } from '../../record/index.js'
 import { bufferToRecordKey, isPublicKeyKey, fromPublicKeyKey } from '../../utils.js'
+import type { Message } from '../../message/dht.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { DHTMessageHandler } from '../index.js'
 import type { ComponentLogger, Logger, PeerId, PeerStore } from '@libp2p/interface'
@@ -12,6 +13,7 @@ import type { Datastore } from 'interface-datastore'
 
 export interface GetValueHandlerInit {
   peerRouting: PeerRouting
+  logPrefix: string
 }
 
 export interface GetValueHandlerComponents {
@@ -27,7 +29,7 @@ export class GetValueHandler implements DHTMessageHandler {
   private readonly log: Logger
 
   constructor (components: GetValueHandlerComponents, init: GetValueHandlerInit) {
-    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:get-value')
+    this.log = components.logger.forComponent(`${init.logPrefix}:rpc:handlers:get-value`)
     this.peerStore = components.peerStore
     this.datastore = components.datastore
     this.peerRouting = init.peerRouting
@@ -42,7 +44,13 @@ export class GetValueHandler implements DHTMessageHandler {
       throw new CodeError('Invalid key', 'ERR_INVALID_KEY')
     }
 
-    const response = new Message(MESSAGE_TYPE.GET_VALUE, key, msg.clusterLevel)
+    const response: Message = {
+      type: MessageType.GET_VALUE,
+      key,
+      clusterLevel: msg.clusterLevel,
+      closer: [],
+      providers: []
+    }
 
     if (isPublicKeyKey(key)) {
       this.log('is public key')
@@ -65,24 +73,27 @@ export class GetValueHandler implements DHTMessageHandler {
 
       if (pubKey != null) {
         this.log('returning found public key')
-        response.record = new Libp2pRecord(key, pubKey, new Date())
+        response.record = new Libp2pRecord(key, pubKey, new Date()).serialize()
         return response
       }
     }
 
     const [record, closer] = await Promise.all([
       this._checkLocalDatastore(key),
-      this.peerRouting.getCloserPeersOffline(msg.key, peerId)
+      this.peerRouting.getCloserPeersOffline(key, peerId)
     ])
 
     if (record != null) {
       this.log('had record for %b in local datastore', key)
-      response.record = record
+      response.record = record.serialize()
     }
 
     if (closer.length > 0) {
       this.log('had %s closer peers in routing table', closer.length)
-      response.closerPeers = closer
+      response.closer = closer.map(peerInfo => ({
+        id: peerInfo.id.toBytes(),
+        multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
+      }))
     }
 
     return response

package/src/rpc/handlers/ping.ts

@@ -1,4 +1,4 @@
-import type { Message } from '../../message/index.js'
+import type { Message } from '../../message/dht.js'
 import type { DHTMessageHandler } from '../index.js'
 import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 
@@ -6,11 +6,15 @@ export interface PingComponents {
   logger: ComponentLogger
 }
 
+export interface PingHandlerInit {
+  logPrefix: string
+}
+
 export class PingHandler implements DHTMessageHandler {
   private readonly log: Logger
 
-  constructor (components: PingComponents) {
-    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:ping')
+  constructor (components: PingComponents, init: PingHandlerInit) {
+    this.log = components.logger.forComponent(`${init.logPrefix}:rpc:handlers:ping`)
   }
 
   async handle (peerId: PeerId, msg: Message): Promise<Message> {

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

@@ -1,14 +1,16 @@
 import { CodeError } from '@libp2p/interface'
+import { Libp2pRecord } from '../../record/index.js'
 import { verifyRecord } from '../../record/validators.js'
 import { bufferToRecordKey } from '../../utils.js'
 import type { Validators } from '../../index.js'
-import type { Message } from '../../message/index.js'
+import type { Message } from '../../message/dht.js'
 import type { DHTMessageHandler } from '../index.js'
 import type { ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
 
 export interface PutValueHandlerInit {
   validators: Validators
+  logPrefix: string
 }
 
 export interface PutValueHandlerComponents {
@@ -25,7 +27,7 @@ export class PutValueHandler implements DHTMessageHandler {
     const { validators } = init
 
     this.components = components
-    this.log = components.logger.forComponent('libp2p:kad-dht:rpc:handlers:put-value')
+    this.log = components.logger.forComponent(`${init.logPrefix}:rpc:handlers:put-value`)
     this.validators = validators
   }
 
@@ -33,9 +35,7 @@ export class PutValueHandler implements DHTMessageHandler {
     const key = msg.key
     this.log('%p asked us to store value for key %b', peerId, key)
 
-    const record = msg.record
-
-    if (record == null) {
+    if (msg.record == null) {
       const errMsg = `Empty record from: ${peerId.toString()}`
 
       this.log.error(errMsg)
@@ -43,11 +43,13 @@ export class PutValueHandler implements DHTMessageHandler {
     }
 
     try {
-      await verifyRecord(this.validators, record)
+      const deserializedRecord = Libp2pRecord.deserialize(msg.record)
+
+      await verifyRecord(this.validators, deserializedRecord)
 
-      record.timeReceived = new Date()
-      const recordKey = bufferToRecordKey(record.key)
-      await this.components.datastore.put(recordKey, record.serialize().subarray())
+      deserializedRecord.timeReceived = new Date()
+      const recordKey = bufferToRecordKey(deserializedRecord.key)
+      await this.components.datastore.put(recordKey, deserializedRecord.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)

package/src/rpc/index.ts

@@ -1,13 +1,13 @@
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
-import { Message, MESSAGE_TYPE } from '../message/index.js'
+import { Message, MessageType } from '../message/dht.js'
 import { AddProviderHandler } from './handlers/add-provider.js'
 import { FindNodeHandler, type FindNodeHandlerComponents } from './handlers/find-node.js'
 import { GetProvidersHandler, type GetProvidersHandlerComponents } from './handlers/get-providers.js'
 import { GetValueHandler, type GetValueHandlerComponents } from './handlers/get-value.js'
 import { PingHandler } from './handlers/ping.js'
 import { PutValueHandler, type PutValueHandlerComponents } from './handlers/put-value.js'
-import type { Validators } from '../index.js'
+import type { PeerInfoMapper, Validators } from '../index.js'
 import type { PeerRouting } from '../peer-routing'
 import type { Providers } from '../providers'
 import type { RoutingTable } from '../routing-table'
@@ -23,7 +23,8 @@ export interface RPCInit {
   providers: Providers
   peerRouting: PeerRouting
   validators: Validators
-  lan: boolean
+  logPrefix: string
+  peerInfoMapper: PeerInfoMapper
 }
 
 export interface RPCComponents extends GetValueHandlerComponents, PutValueHandlerComponents, FindNodeHandlerComponents, GetProvidersHandlerComponents {
@@ -36,17 +37,17 @@ export class RPC {
   private readonly log: Logger
 
   constructor (components: RPCComponents, init: RPCInit) {
-    const { providers, peerRouting, validators, lan } = init
+    const { providers, peerRouting, validators, logPrefix, peerInfoMapper } = init
 
-    this.log = components.logger.forComponent('libp2p:kad-dht:rpc')
+    this.log = components.logger.forComponent(`${logPrefix}:rpc`)
     this.routingTable = init.routingTable
     this.handlers = {
-      [MESSAGE_TYPE.GET_VALUE]: new GetValueHandler(components, { peerRouting }),
-      [MESSAGE_TYPE.PUT_VALUE]: new PutValueHandler(components, { validators }),
-      [MESSAGE_TYPE.FIND_NODE]: new FindNodeHandler(components, { peerRouting, lan }),
-      [MESSAGE_TYPE.ADD_PROVIDER]: new AddProviderHandler(components, { providers }),
-      [MESSAGE_TYPE.GET_PROVIDERS]: new GetProvidersHandler(components, { peerRouting, providers, lan }),
-      [MESSAGE_TYPE.PING]: new PingHandler(components)
+      [MessageType.GET_VALUE.toString()]: new GetValueHandler(components, { peerRouting, logPrefix }),
+      [MessageType.PUT_VALUE.toString()]: new PutValueHandler(components, { validators, logPrefix }),
+      [MessageType.FIND_NODE.toString()]: new FindNodeHandler(components, { peerRouting, logPrefix, peerInfoMapper }),
+      [MessageType.ADD_PROVIDER.toString()]: new AddProviderHandler(components, { providers, logPrefix }),
+      [MessageType.GET_PROVIDERS.toString()]: new GetProvidersHandler(components, { peerRouting, providers, logPrefix, peerInfoMapper }),
+      [MessageType.PING.toString()]: new PingHandler(components, { logPrefix })
     }
   }
 
@@ -93,13 +94,13 @@ export class RPC {
         async function * (source) {
           for await (const msg of source) {
             // handle the message
-            const desMessage = Message.deserialize(msg)
+            const desMessage = Message.decode(msg)
             self.log('incoming %s from %p', desMessage.type, peerId)
             const res = await self.handleMessage(peerId, desMessage)
 
             // Not all handlers will return a response
             if (res != null) {
-              yield res.serialize()
+              yield Message.encode(res)
             }
           }
         },

package/src/topology-listener.ts

@@ -4,7 +4,7 @@ import type { Logger, PeerId, Startable } from '@libp2p/interface'
 
 export interface TopologyListenerInit {
   protocol: string
-  lan: boolean
+  logPrefix: string
 }
 
 export interface TopologyListenerEvents {
@@ -24,10 +24,10 @@ export class TopologyListener extends TypedEventEmitter<TopologyListenerEvents>
   constructor (components: KadDHTComponents, init: TopologyListenerInit) {
     super()
 
-    const { protocol, lan } = init
+    const { protocol, logPrefix } = init
 
     this.components = components
-    this.log = components.logger.forComponent(`libp2p:kad-dht:topology-listener:${lan ? 'lan' : 'wan'}`)
+    this.log = components.logger.forComponent(`${logPrefix}:topology-listener`)
     this.running = false
     this.protocol = protocol
   }

package/src/utils.ts

@@ -8,11 +8,12 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { RECORD_KEY_PREFIX } from './constants.js'
 import { Libp2pRecord } from './record/index.js'
 import type { PeerId, PeerInfo } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 // const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
 const PK_PREFIX = uint8ArrayFromString('/pk/')
 
-export function removePrivateAddresses (peer: PeerInfo): PeerInfo {
+export function removePrivateAddressesMapper (peer: PeerInfo): PeerInfo {
   return {
     ...peer,
     multiaddrs: peer.multiaddrs.filter(multiaddr => {
@@ -48,7 +49,7 @@ export function removePrivateAddresses (peer: PeerInfo): PeerInfo {
   }
 }
 
-export function removePublicAddresses (peer: PeerInfo): PeerInfo {
+export function removePublicAddressesMapper (peer: PeerInfo): PeerInfo {
   return {
     ...peer,
     multiaddrs: peer.multiaddrs.filter(multiaddr => {
@@ -78,6 +79,10 @@ export function removePublicAddresses (peer: PeerInfo): PeerInfo {
   }
 }
 
+export function passthroughMapper (info: PeerInfo): PeerInfo {
+  return info
+}
+
 /**
  * Creates a DHT ID by hashing a given Uint8Array
  */
@@ -148,3 +153,37 @@ export function debounce (callback: () => void, wait: number = 100): () => void
     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
+}

package/dist/src/dual-kad-dht.d.ts

@@ -1,69 +0,0 @@
-import { contentRoutingSymbol, peerDiscoverySymbol, peerRoutingSymbol, TypedEventEmitter } from '@libp2p/interface';
-import { DefaultKadDHT } from './kad-dht.js';
-import type { DualKadDHT, KadDHTComponents, KadDHTInit, QueryEvent, QueryOptions } from './index.js';
-import type { PeerDiscovery, PeerDiscoveryEvents, PeerRouting, ContentRouting, PeerId } from '@libp2p/interface';
-import type { CID } from 'multiformats/cid';
-/**
- * A DHT implementation modelled after Kademlia with S/Kademlia modifications.
- * Original implementation in go: https://github.com/libp2p/go-libp2p-kad-dht.
- */
-export declare class DefaultDualKadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements DualKadDHT, PeerDiscovery {
-    readonly wan: DefaultKadDHT;
-    readonly lan: DefaultKadDHT;
-    readonly components: KadDHTComponents;
-    private readonly contentRouting;
-    private readonly peerRouting;
-    private readonly log;
-    constructor(components: KadDHTComponents, init?: KadDHTInit);
-    readonly [Symbol.toStringTag] = "@libp2p/dual-kad-dht";
-    get [contentRoutingSymbol](): ContentRouting;
-    get [peerRoutingSymbol](): PeerRouting;
-    get [peerDiscoverySymbol](): PeerDiscovery;
-    /**
-     * Is this DHT running.
-     */
-    isStarted(): boolean;
-    /**
-     * If 'server' this node will respond to DHT queries, if 'client' this node will not
-     */
-    getMode(): Promise<'client' | 'server'>;
-    /**
-     * If 'server' this node will respond to DHT queries, if 'client' this node will not
-     */
-    setMode(mode: 'client' | 'server'): Promise<void>;
-    /**
-     * Start listening to incoming connections.
-     */
-    start(): Promise<void>;
-    /**
-     * Stop accepting incoming connections and sending outgoing
-     * messages.
-     */
-    stop(): Promise<void>;
-    /**
-     * Store the given key/value pair in the DHT
-     */
-    put(key: Uint8Array, value: Uint8Array, options?: QueryOptions): AsyncGenerator<QueryEvent>;
-    /**
-     * Get the value that corresponds to the passed key
-     */
-    get(key: Uint8Array, options?: QueryOptions): AsyncGenerator<QueryEvent>;
-    /**
-     * Announce to the network that we can provide given key's value
-     */
-    provide(key: CID, options?: QueryOptions): AsyncGenerator<QueryEvent>;
-    /**
-     * Search the dht for up to `K` providers of the given CID
-     */
-    findProviders(key: CID, options?: QueryOptions): AsyncGenerator<QueryEvent, void, undefined>;
-    /**
-     * Search for a peer with the given ID
-     */
-    findPeer(id: PeerId, options?: QueryOptions): AsyncGenerator<QueryEvent>;
-    /**
-     * Kademlia 'node lookup' operation
-     */
-    getClosestPeers(key: Uint8Array, options?: QueryOptions): AsyncGenerator<QueryEvent, void, undefined>;
-    refreshRoutingTable(): Promise<void>;
-}
-//# sourceMappingURL=dual-kad-dht.d.ts.map