web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@libp2p/kad-dht/dist/src/index.js

@@ -0,0 +1,145 @@
+'use strict';
+
+var kadDht = require('./kad-dht.js');
+
+/**
+ * @packageDocumentation
+ *
+ * This module implements the [libp2p Kademlia spec](https://github.com/libp2p/specs/blob/master/kad-dht/README.md) in TypeScript.
+ *
+ * The Kademlia DHT allow for several operations such as finding peers, searching for providers of DHT records, etc.
+ *
+ * @example Using with libp2p
+ *
+ * ```TypeScript
+ * import { kadDHT } from '@libp2p/kad-dht'
+ * import { createLibp2p } from 'libp2p'
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ *
+ * const node = await createLibp2p({
+ *   services: {
+ *     dht: kadDHT({
+ *       // DHT options
+ *     })
+ *   }
+ * })
+ *
+ * const peerId = peerIdFromString('QmFoo')
+ * const peerInfo = await node.peerRouting.findPeer(peerId)
+ *
+ * console.info(peerInfo) // peer id, multiaddrs
+ * ```
+ *
+ * @example Connecting to the IPFS Amino DHT
+ *
+ * The [Amino DHT](https://blog.ipfs.tech/2023-09-amino-refactoring/) is a public-good DHT used by IPFS to fetch content, find peers, etc.
+ *
+ * If you are trying to access content on the public internet, this is the implementation you want.
+ *
+ * ```TypeScript
+ * import { kadDHT, removePrivateAddressesMapper } from '@libp2p/kad-dht'
+ * import { createLibp2p } from 'libp2p'
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ *
+ * const node = await createLibp2p({
+ *   services: {
+ *     aminoDHT: kadDHT({
+ *       protocol: '/ipfs/kad/1.0.0',
+ *       peerInfoMapper: removePrivateAddressesMapper
+ *     })
+ *   }
+ * })
+ *
+ * const peerId = peerIdFromString('QmFoo')
+ * const peerInfo = await node.peerRouting.findPeer(peerId)
+ *
+ * console.info(peerInfo) // peer id, multiaddrs
+ * ```
+ *
+ * @example Connecting to a LAN-only DHT
+ *
+ * This DHT only works with privately dialable peers.
+ *
+ * This is for use when peers are on the local area network.
+ *
+ * ```TypeScript
+ * import { kadDHT, removePublicAddressesMapper } from '@libp2p/kad-dht'
+ * import { createLibp2p } from 'libp2p'
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ *
+ * const node = await createLibp2p({
+ *   services: {
+ *     lanDHT: kadDHT({
+ *       protocol: '/ipfs/lan/kad/1.0.0',
+ *       peerInfoMapper: removePublicAddressesMapper,
+ *       clientMode: false
+ *     })
+ *   }
+ * })
+ *
+ * const peerId = peerIdFromString('QmFoo')
+ * const peerInfo = await node.peerRouting.findPeer(peerId)
+ *
+ * console.info(peerInfo) // peer id, multiaddrs
+ * ```
+ *
+ * @example Connecting to both a LAN-only DHT and the IPFS Amino DHT
+ *
+ * When using multiple DHTs, you should specify distinct datastore, metrics and
+ * log prefixes to ensure that data is kept separate for each instance.
+ *
+ * ```TypeScript
+ * import { kadDHT, removePublicAddressesMapper, removePrivateAddressesMapper } from '@libp2p/kad-dht'
+ * import { createLibp2p } from 'libp2p'
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ *
+ * const node = await createLibp2p({
+ *   services: {
+ *     lanDHT: kadDHT({
+ *       protocol: '/ipfs/lan/kad/1.0.0',
+ *       peerInfoMapper: removePublicAddressesMapper,
+ *       clientMode: false,
+ *       logPrefix: 'libp2p:dht-lan',
+ *       datastorePrefix: '/dht-lan',
+ *       metricsPrefix: 'libp2p_dht_lan'
+ *     }),
+ *     aminoDHT: kadDHT({
+ *       protocol: '/ipfs/kad/1.0.0',
+ *       peerInfoMapper: removePrivateAddressesMapper,
+ *       logPrefix: 'libp2p:dht-amino',
+ *       datastorePrefix: '/dht-amino',
+ *       metricsPrefix: 'libp2p_dht_amino'
+ *     })
+ *   }
+ * })
+ *
+ * const peerId = peerIdFromString('QmFoo')
+ * const peerInfo = await node.peerRouting.findPeer(peerId)
+ *
+ * console.info(peerInfo) // peer id, multiaddrs
+ * ```
+ */
+/**
+ * The types of events emitted during DHT queries
+ */
+exports.EventTypes = void 0;
+(function (EventTypes) {
+  EventTypes[EventTypes["SEND_QUERY"] = 0] = "SEND_QUERY";
+  EventTypes[EventTypes["PEER_RESPONSE"] = 1] = "PEER_RESPONSE";
+  EventTypes[EventTypes["FINAL_PEER"] = 2] = "FINAL_PEER";
+  EventTypes[EventTypes["QUERY_ERROR"] = 3] = "QUERY_ERROR";
+  EventTypes[EventTypes["PROVIDER"] = 4] = "PROVIDER";
+  EventTypes[EventTypes["VALUE"] = 5] = "VALUE";
+  EventTypes[EventTypes["ADD_PEER"] = 6] = "ADD_PEER";
+  EventTypes[EventTypes["DIAL_PEER"] = 7] = "DIAL_PEER";
+})(exports.EventTypes || (exports.EventTypes = {}));
+/**
+ * Creates a custom DHT implementation, please ensure you pass a `protocol`
+ * string as an option.
+ */
+function kadDHT() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new kadDht.KadDHT(components, init);
+}
+
+exports.kadDHT = kadDHT;

package/dist/cjs/node_modules/@libp2p/kad-dht/dist/src/kad-dht.js

@@ -0,0 +1,531 @@
+'use strict';
+
+var index$7 = require('../../../interface/dist/src/index.js');
+var index$8 = require('../../../../it-drain/dist/src/index.js');
+var index = require('../../../../mortice/dist/src/index.js');
+var index$2 = require('../../../../p-defer/index.js');
+var constants = require('./constants.js');
+var index$4 = require('./content-fetching/index.js');
+var index$5 = require('./content-routing/index.js');
+var network = require('./network.js');
+var index$3 = require('./peer-routing/index.js');
+var providers = require('./providers.js');
+var manager = require('./query/manager.js');
+var querySelf = require('./query-self.js');
+var selectors = require('./record/selectors.js');
+var validators = require('./record/validators.js');
+var reprovider = require('./reprovider.js');
+var index$1 = require('./routing-table/index.js');
+var refresh = require('./routing-table/refresh.js');
+var index$6 = require('./rpc/index.js');
+var topologyListener = require('./topology-listener.js');
+var utils = require('./utils.js');
+var eventTarget = require('../../../interface/dist/src/event-target.js');
+var contentRouting = require('../../../interface/dist/src/content-routing.js');
+var peerRouting = require('../../../interface/dist/src/peer-routing.js');
+var peerDiscovery = require('../../../interface/dist/src/peer-discovery.js');
+var startable = require('../../../interface/dist/src/startable.js');
+var errors = require('../../../interface/dist/src/errors.js');
+
+/**
+ * Wrapper class to convert events into returned values
+ */
+class DHTContentRouting {
+  dht;
+  constructor(dht) {
+    this.dht = dht;
+  }
+  async provide(cid) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    await index$8.default(this.dht.provide(cid, options));
+  }
+  async cancelReprovide(key) {
+    await this.dht.cancelReprovide(key);
+  }
+  findProviders(cid) {
+    try {
+      var _this = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        for await (const event of _this.dht.findProviders(cid, options)) {
+          if (event.name === 'PROVIDER') {
+            yield* event.providers;
+          }
+        }
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  async put(key, value, options) {
+    await index$8.default(this.dht.put(key, value, options));
+  }
+  async get(key, options) {
+    for await (const event of this.dht.get(key, options)) {
+      if (event.name === 'VALUE') {
+        return event.value;
+      }
+    }
+    throw new errors.NotFoundError('Could not find value for key');
+  }
+}
+/**
+ * Wrapper class to convert events into returned values
+ */
+class DHTPeerRouting {
+  dht;
+  constructor(dht) {
+    this.dht = dht;
+  }
+  async findPeer(peerId) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    for await (const event of this.dht.findPeer(peerId, options)) {
+      if (event.name === 'FINAL_PEER') {
+        return event.peer;
+      }
+    }
+    throw new errors.NotFoundError('Peer not found');
+  }
+  getClosestPeers(key) {
+    try {
+      var _this2 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        for await (const event of _this2.dht.getClosestPeers(key, options)) {
+          if (event.name === 'FINAL_PEER') {
+            yield event.peer;
+          }
+        }
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+}
+const DEFAULT_MAX_INBOUND_STREAMS = 32;
+const DEFAULT_MAX_OUTBOUND_STREAMS = 64;
+/**
+ * A DHT implementation modelled after Kademlia with S/Kademlia modifications.
+ * Original implementation in go: https://github.com/libp2p/go-libp2p-kad-dht.
+ */
+class KadDHT extends eventTarget.TypedEventEmitter {
+  protocol;
+  routingTable;
+  providers;
+  network;
+  peerRouting;
+  components;
+  log;
+  running;
+  kBucketSize;
+  clientMode;
+  validators;
+  selectors;
+  queryManager;
+  contentFetching;
+  contentRouting;
+  routingTableRefresh;
+  rpc;
+  topologyListener;
+  querySelf;
+  maxInboundStreams;
+  maxOutboundStreams;
+  dhtContentRouting;
+  dhtPeerRouting;
+  peerInfoMapper;
+  reprovider;
+  /**
+   * Create a new KadDHT
+   */
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super();
+    const logPrefix = init.logPrefix ?? 'libp2p:kad-dht';
+    const datastorePrefix = init.datastorePrefix ?? '/dht';
+    const metricsPrefix = init.metricsPrefix ?? 'libp2p_kad_dht';
+    const operationMetrics = {
+      queries: components.metrics?.registerMetricGroup(`${metricsPrefix}_operations_total`, {
+        label: 'operation'
+      }),
+      errors: components.metrics?.registerCounterGroup(`${metricsPrefix}_operation_errors_total`, {
+        label: 'operation'
+      }),
+      queryTime: components.metrics?.registerMetricGroup(`${metricsPrefix}_operation_time_seconds`, {
+        label: 'operation'
+      }),
+      errorTime: components.metrics?.registerMetricGroup(`${metricsPrefix}_operation_error_time_seconds`, {
+        label: 'operation'
+      })
+    };
+    this.running = false;
+    this.components = components;
+    this.log = components.logger.forComponent(logPrefix);
+    this.protocol = init.protocol ?? constants.PROTOCOL;
+    this.kBucketSize = init.kBucketSize ?? 20;
+    this.clientMode = init.clientMode ?? true;
+    this.maxInboundStreams = init.maxInboundStreams ?? DEFAULT_MAX_INBOUND_STREAMS;
+    this.maxOutboundStreams = init.maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS;
+    this.peerInfoMapper = init.peerInfoMapper ?? utils.removePrivateAddressesMapper;
+    const providerLock = index.default();
+    this.providers = new providers.Providers(components, {
+      ...init.providers,
+      logPrefix,
+      datastorePrefix,
+      lock: providerLock
+    });
+    this.validators = {
+      ...validators.validators,
+      ...init.validators
+    };
+    this.selectors = {
+      ...selectors.selectors,
+      ...init.selectors
+    };
+    this.network = new network.Network(components, {
+      protocol: this.protocol,
+      logPrefix,
+      metricsPrefix
+    });
+    this.routingTable = new index$1.RoutingTable(components, {
+      kBucketSize: init.kBucketSize,
+      pingOldContactTimeout: init.pingOldContactTimeout,
+      pingOldContactConcurrency: init.pingOldContactConcurrency,
+      pingOldContactMaxQueueSize: init.pingOldContactMaxQueueSize,
+      pingNewContactTimeout: init.pingNewContactTimeout,
+      pingNewContactConcurrency: init.pingNewContactConcurrency,
+      pingNewContactMaxQueueSize: init.pingNewContactMaxQueueSize,
+      protocol: this.protocol,
+      logPrefix,
+      metricsPrefix,
+      prefixLength: init.prefixLength,
+      splitThreshold: init.kBucketSplitThreshold,
+      network: this.network
+    });
+    // all queries should wait for the initial query-self query to run so we have
+    // some peers and don't force consumers to use arbitrary timeouts
+    const initialQuerySelfHasRun = index$2.default();
+    // if the user doesn't want to wait for query peers, resolve the initial
+    // self-query promise immediately
+    if (init.allowQueryWithZeroPeers === true) {
+      initialQuerySelfHasRun.resolve();
+    }
+    this.queryManager = new manager.QueryManager(components, {
+      // Number of disjoint query paths to use - This is set to `kBucketSize/2` per the S/Kademlia paper
+      disjointPaths: Math.ceil(this.kBucketSize / 2),
+      logPrefix,
+      metricsPrefix,
+      initialQuerySelfHasRun,
+      routingTable: this.routingTable
+    });
+    // DHT components
+    this.peerRouting = new index$3.PeerRouting(components, {
+      routingTable: this.routingTable,
+      network: this.network,
+      validators: this.validators,
+      queryManager: this.queryManager,
+      logPrefix
+    });
+    this.contentFetching = new index$4.ContentFetching(components, {
+      validators: this.validators,
+      selectors: this.selectors,
+      peerRouting: this.peerRouting,
+      queryManager: this.queryManager,
+      network: this.network,
+      logPrefix,
+      datastorePrefix
+    });
+    this.contentRouting = new index$5.ContentRouting(components, {
+      network: this.network,
+      peerRouting: this.peerRouting,
+      queryManager: this.queryManager,
+      routingTable: this.routingTable,
+      providers: this.providers,
+      logPrefix
+    });
+    this.routingTableRefresh = new refresh.RoutingTableRefresh(components, {
+      peerRouting: this.peerRouting,
+      routingTable: this.routingTable,
+      logPrefix
+    });
+    this.rpc = new index$6.RPC(components, {
+      routingTable: this.routingTable,
+      providers: this.providers,
+      peerRouting: this.peerRouting,
+      validators: this.validators,
+      logPrefix,
+      metricsPrefix,
+      datastorePrefix,
+      peerInfoMapper: this.peerInfoMapper
+    });
+    this.topologyListener = new topologyListener.TopologyListener(components, {
+      protocol: this.protocol,
+      logPrefix
+    });
+    this.querySelf = new querySelf.QuerySelf(components, {
+      peerRouting: this.peerRouting,
+      interval: init.querySelfInterval,
+      initialInterval: init.initialQuerySelfInterval,
+      logPrefix,
+      initialQuerySelfHasRun,
+      routingTable: this.routingTable,
+      operationMetrics
+    });
+    this.reprovider = new reprovider.Reprovider(components, {
+      ...init.reprovide,
+      logPrefix,
+      metricsPrefix,
+      datastorePrefix,
+      contentRouting: this.contentRouting,
+      lock: providerLock,
+      operationMetrics
+    });
+    // handle peers being discovered during processing of DHT messages
+    this.network.addEventListener('peer', evt => {
+      const peerData = evt.detail;
+      this.onPeerConnect(peerData).catch(err => {
+        this.log.error('could not add %p to routing table', peerData.id, err);
+      });
+      this.dispatchEvent(new CustomEvent('peer', {
+        detail: peerData
+      }));
+    });
+    // handle peers being discovered via other peer discovery mechanisms
+    this.topologyListener.addEventListener('peer', evt => {
+      const peerId = evt.detail;
+      Promise.resolve().then(async () => {
+        const peer = await this.components.peerStore.get(peerId);
+        const peerData = {
+          id: peerId,
+          multiaddrs: peer.addresses.map(_ref => {
+            let {
+              multiaddr
+            } = _ref;
+            return multiaddr;
+          }),
+          protocols: peer.protocols
+        };
+        await this.onPeerConnect(peerData);
+      }).catch(err => {
+        this.log.error('could not add %p to routing table - %e', peerId, err);
+      });
+    });
+    this.dhtPeerRouting = new DHTPeerRouting(this);
+    this.dhtContentRouting = new DHTContentRouting(this);
+    // if client mode has not been explicitly specified, auto-switch to server
+    // mode when the node's peer data is updated with publicly dialable
+    // addresses
+    if (init.clientMode == null) {
+      components.events.addEventListener('self:peer:update', evt => {
+        this.log('received update of self-peer info');
+        void Promise.resolve().then(async () => {
+          const hasPublicAddress = evt.detail.peer.addresses.some(_ref2 => {
+            let {
+              multiaddr
+            } = _ref2;
+            return utils.multiaddrIsPublic(multiaddr);
+          });
+          const mode = this.getMode();
+          if (hasPublicAddress && mode === 'client') {
+            await this.setMode('server');
+          } else if (mode === 'server' && !hasPublicAddress) {
+            await this.setMode('client');
+          }
+        }).catch(err => {
+          this.log.error('error setting dht server mode', err);
+        });
+      });
+    }
+    this.get = utils.timeOperationGenerator(this.get.bind(this), operationMetrics, 'GET_VALUE');
+    this.findProviders = utils.timeOperationGenerator(this.findProviders.bind(this), operationMetrics, 'FIND_PROVIDERS');
+    this.findPeer = utils.timeOperationGenerator(this.findPeer.bind(this), operationMetrics, 'FIND_PEER');
+    this.getClosestPeers = utils.timeOperationGenerator(this.getClosestPeers.bind(this), operationMetrics, 'GET_CLOSEST_PEERS');
+    this.provide = utils.timeOperationGenerator(this.provide.bind(this), operationMetrics, 'PROVIDE');
+    this.put = utils.timeOperationGenerator(this.put.bind(this), operationMetrics, 'PUT_VALUE');
+  }
+  [Symbol.toStringTag] = '@libp2p/kad-dht';
+  [index$7.serviceCapabilities] = ['@libp2p/content-routing', '@libp2p/peer-routing', '@libp2p/peer-discovery'];
+  [index$7.serviceDependencies] = ['@libp2p/identify'];
+  get [contentRouting.contentRoutingSymbol]() {
+    return this.dhtContentRouting;
+  }
+  get [peerRouting.peerRoutingSymbol]() {
+    return this.dhtPeerRouting;
+  }
+  get [peerDiscovery.peerDiscoverySymbol]() {
+    return this;
+  }
+  async onPeerConnect(peerData) {
+    this.log.trace('peer %p connected', peerData.id);
+    peerData = this.peerInfoMapper(peerData);
+    if (peerData.multiaddrs.length === 0) {
+      this.log.trace('ignoring %p as there were no valid addresses in %s after filtering', peerData.id, peerData.multiaddrs.map(addr => addr.toString()));
+      return;
+    }
+    try {
+      await this.routingTable.add(peerData.id);
+    } catch (err) {
+      this.log.error('could not add %p to routing table', peerData.id, err);
+    }
+  }
+  /**
+   * Is this DHT running.
+   */
+  isStarted() {
+    return this.running;
+  }
+  /**
+   * If 'server' this node will respond to DHT queries, if 'client' this node will not
+   */
+  getMode() {
+    return this.clientMode ? 'client' : 'server';
+  }
+  /**
+   * If 'server' this node will respond to DHT queries, if 'client' this node will not
+   */
+  async setMode(mode) {
+    let force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (mode === this.getMode() && !force) {
+      this.log('already in %s mode', mode);
+      return;
+    }
+    await this.components.registrar.unhandle(this.protocol);
+    // check again after async work
+    if (mode === this.getMode() && !force) {
+      this.log('already in %s mode', mode);
+      return;
+    }
+    if (mode === 'client') {
+      this.log('enabling client mode while in %s mode', this.getMode());
+      this.clientMode = true;
+    } else {
+      this.log('enabling server mode while in %s mode', this.getMode());
+      this.clientMode = false;
+      await this.components.registrar.handle(this.protocol, this.rpc.onIncomingStream.bind(this.rpc), {
+        maxInboundStreams: this.maxInboundStreams,
+        maxOutboundStreams: this.maxOutboundStreams
+      });
+    }
+  }
+  /**
+   * Start listening to incoming connections.
+   */
+  async start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    // Only respond to queries when not in client mode
+    await this.setMode(this.clientMode ? 'client' : 'server', true);
+    await startable.start(this.routingTable, this.queryManager, this.network, this.topologyListener, this.routingTableRefresh, this.reprovider);
+    // Query self after other components are configured
+    await startable.start(this.querySelf);
+  }
+  /**
+   * Stop accepting incoming connections and sending outgoing
+   * messages.
+   */
+  async stop() {
+    this.running = false;
+    await startable.stop(this.querySelf, this.queryManager, this.network, this.routingTable, this.routingTableRefresh, this.topologyListener, this.reprovider);
+  }
+  /**
+   * Store the given key/value pair in the DHT
+   */
+  put(key, value) {
+    try {
+      var _this3 = this;
+      let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return async function* () {
+        yield* _this3.contentFetching.put(key, value, options);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Get the value that corresponds to the passed key
+   */
+  get(key) {
+    try {
+      var _this4 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        yield* _this4.contentFetching.get(key, options);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  // ----------- Content Routing
+  /**
+   * Announce to the network that we can provide given key's value
+   */
+  provide(key) {
+    try {
+      var _this5 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        yield* _this5.contentRouting.provide(key, _this5.components.addressManager.getAddresses(), options);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Provider records must be re-published every 24 hours - pass a previously
+   * provided CID here to not re-publish a record for it any more
+   */
+  async cancelReprovide(key) {
+    await this.providers.removeProvider(key, this.components.peerId);
+  }
+  /**
+   * Search the dht for providers of the given CID
+   */
+  findProviders(key) {
+    try {
+      var _this6 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        yield* _this6.contentRouting.findProviders(key, options);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  // ----------- Peer Routing -----------
+  /**
+   * Search for a peer with the given ID
+   */
+  findPeer(id) {
+    try {
+      var _this7 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        yield* _this7.peerRouting.findPeer(id, options);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Kademlia 'node lookup' operation
+   */
+  getClosestPeers(key) {
+    try {
+      var _this8 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        yield* _this8.peerRouting.getClosestPeers(key, options);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  async refreshRoutingTable() {
+    this.routingTableRefresh.refreshTable(true);
+  }
+}
+
+exports.DEFAULT_MAX_INBOUND_STREAMS = DEFAULT_MAX_INBOUND_STREAMS;
+exports.DEFAULT_MAX_OUTBOUND_STREAMS = DEFAULT_MAX_OUTBOUND_STREAMS;
+exports.KadDHT = KadDHT;