web-dc-api 0.0.61 → 0.0.62

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

@@ -0,0 +1,59 @@
+'use strict';
+
+var peerStore = require('../../../interface/dist/src/peer-store.js');
+
+const second = 1000;
+const minute = 60 * second;
+const hour = 60 * minute;
+const MAX_RECORD_AGE = 36 * hour;
+const PROTOCOL = '/ipfs/kad/1.0.0';
+/**
+ * @see https://github.com/libp2p/specs/blob/master/kad-dht/README.md#content-provider-advertisement-and-discovery
+ */
+const PROVIDERS_VALIDITY = 48 * hour;
+// Re-run the provide operation when the expiry of our provider records is within this amount
+const REPROVIDE_THRESHOLD = 24 * hour;
+// How many reprovide operations to run at once
+const REPROVIDE_CONCURRENCY = 10;
+// How long to let the reprovide queue grow before we wait for capacity
+const REPROVIDE_MAX_QUEUE_SIZE = 16_384;
+// How often to check if records need re-providing
+const REPROVIDE_INTERVAL = hour;
+// K is the maximum number of requests to perform before returning failure
+const K = 20;
+// Alpha is the concurrency for asynchronous requests
+const ALPHA = 3;
+// How often we look for our closest DHT neighbors
+const QUERY_SELF_INTERVAL = 5 * minute;
+// How often we look for the first set of our closest DHT neighbors
+const QUERY_SELF_INITIAL_INTERVAL = second;
+// How long to look for our closest DHT neighbors for
+const QUERY_SELF_TIMEOUT = 5 * second;
+// How often we try to find new peers
+const TABLE_REFRESH_INTERVAL = 5 * minute;
+// How how long to look for new peers for
+const TABLE_REFRESH_QUERY_TIMEOUT = 30 * second;
+// When a timeout is not specified, run a query for this long
+const DEFAULT_QUERY_TIMEOUT = 180 * second;
+// used to ensure connections to our closest peers remain open
+const KEEP_ALIVE_TAG = `${peerStore.KEEP_ALIVE}-kad-dht`;
+
+exports.ALPHA = ALPHA;
+exports.DEFAULT_QUERY_TIMEOUT = DEFAULT_QUERY_TIMEOUT;
+exports.K = K;
+exports.KEEP_ALIVE_TAG = KEEP_ALIVE_TAG;
+exports.MAX_RECORD_AGE = MAX_RECORD_AGE;
+exports.PROTOCOL = PROTOCOL;
+exports.PROVIDERS_VALIDITY = PROVIDERS_VALIDITY;
+exports.QUERY_SELF_INITIAL_INTERVAL = QUERY_SELF_INITIAL_INTERVAL;
+exports.QUERY_SELF_INTERVAL = QUERY_SELF_INTERVAL;
+exports.QUERY_SELF_TIMEOUT = QUERY_SELF_TIMEOUT;
+exports.REPROVIDE_CONCURRENCY = REPROVIDE_CONCURRENCY;
+exports.REPROVIDE_INTERVAL = REPROVIDE_INTERVAL;
+exports.REPROVIDE_MAX_QUEUE_SIZE = REPROVIDE_MAX_QUEUE_SIZE;
+exports.REPROVIDE_THRESHOLD = REPROVIDE_THRESHOLD;
+exports.TABLE_REFRESH_INTERVAL = TABLE_REFRESH_INTERVAL;
+exports.TABLE_REFRESH_QUERY_TIMEOUT = TABLE_REFRESH_QUERY_TIMEOUT;
+exports.hour = hour;
+exports.minute = minute;
+exports.second = second;

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

@@ -0,0 +1,271 @@
+'use strict';
+
+var index = require('../../../../record/dist/src/index.js');
+var index$2 = require('../../../../../it-map/dist/src/index.js');
+var index$3 = require('../../../../../it-parallel/dist/src/index.js');
+var index$1 = require('../../../../../it-pipe/dist/src/index.js');
+var equals = require('../../../../../uint8arrays/dist/src/equals.js');
+var constants = require('../constants.js');
+var errors = require('../errors.js');
+var dht = require('../message/dht.js');
+var events = require('../query/events.js');
+var selectors = require('../record/selectors.js');
+var validators = require('../record/validators.js');
+var utils = require('../utils.js');
+var errors$1 = require('../../../../interface/dist/src/errors.js');
+
+class ContentFetching {
+  log;
+  components;
+  validators;
+  selectors;
+  peerRouting;
+  queryManager;
+  network;
+  datastorePrefix;
+  constructor(components, init) {
+    const {
+      validators,
+      selectors,
+      peerRouting,
+      queryManager,
+      network,
+      logPrefix
+    } = init;
+    this.components = components;
+    this.log = components.logger.forComponent(`${logPrefix}:content-fetching`);
+    this.datastorePrefix = `${init.datastorePrefix}/record`;
+    this.validators = validators;
+    this.selectors = selectors;
+    this.peerRouting = peerRouting;
+    this.queryManager = queryManager;
+    this.network = network;
+    this.get = components.metrics?.traceFunction('libp2p.kadDHT.get', this.get.bind(this), {
+      optionsIndex: 1
+    }) ?? this.get;
+    this.put = components.metrics?.traceFunction('libp2p.kadDHT.put', this.put.bind(this), {
+      optionsIndex: 2
+    }) ?? this.put;
+  }
+  /**
+   * Attempt to retrieve the value for the given key from
+   * the local datastore
+   */
+  async getLocal(key) {
+    this.log('getLocal %b', key);
+    const dsKey = utils.bufferToRecordKey(this.datastorePrefix, key);
+    this.log('fetching record for key %k', dsKey);
+    const raw = await this.components.datastore.get(dsKey);
+    this.log('found %k in local datastore', dsKey);
+    const rec = index.Libp2pRecord.deserialize(raw);
+    await validators.verifyRecord(this.validators, rec);
+    return rec;
+  }
+  /**
+   * Send the best record found to any peers that have an out of date record
+   */
+  sendCorrectionRecord(key, vals, best) {
+    try {
+      var _this = this;
+      let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+      return async function* () {
+        _this.log('sendCorrection for %b', key);
+        const fixupRec = utils.createPutRecord(key, best);
+        for (const {
+          value,
+          from
+        } of vals) {
+          // no need to do anything
+          if (equals.equals(value, best)) {
+            _this.log('record was ok');
+            continue;
+          }
+          // correct ourself
+          if (_this.components.peerId.equals(from)) {
+            try {
+              const dsKey = utils.bufferToRecordKey(_this.datastorePrefix, key);
+              _this.log(`Storing corrected record for key ${dsKey.toString()}`);
+              await _this.components.datastore.put(dsKey, fixupRec.subarray());
+            } catch (err) {
+              _this.log.error('Failed error correcting self', err);
+            }
+            continue;
+          }
+          // send correction
+          let sentCorrection = false;
+          const request = {
+            type: dht.MessageType.PUT_VALUE,
+            key,
+            record: fixupRec
+          };
+          for await (const event of _this.network.sendRequest(from, request, options)) {
+            if (event.name === 'PEER_RESPONSE' && event.record != null && equals.equals(event.record.value, index.Libp2pRecord.deserialize(fixupRec).value)) {
+              sentCorrection = true;
+            }
+            yield event;
+          }
+          if (!sentCorrection) {
+            yield events.queryErrorEvent({
+              from,
+              error: new errors.QueryError('Value not put correctly')
+            }, options);
+          }
+          _this.log.error('Failed error correcting entry');
+        }
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Store the given key/value pair in the DHT
+   */
+  put(key, value) {
+    try {
+      var _this2 = this;
+      let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return async function* () {
+        _this2.log('put key %b value %b', key, value);
+        // create record in the dht format
+        const record = utils.createPutRecord(key, value);
+        // store the record locally
+        const dsKey = utils.bufferToRecordKey(_this2.datastorePrefix, key);
+        _this2.log(`storing record for key ${dsKey.toString()}`);
+        await _this2.components.datastore.put(dsKey, record.subarray());
+        // put record to the closest peers
+        yield* index$1.pipe(_this2.peerRouting.getClosestPeers(key, {
+          ...options,
+          signal: options.signal
+        }), source => index$2.default(source, event => {
+          return async () => {
+            if (event.name !== 'FINAL_PEER') {
+              return [event];
+            }
+            const events$1 = [];
+            const msg = {
+              type: dht.MessageType.PUT_VALUE,
+              key,
+              record
+            };
+            _this2.log('send put to %p', event.peer.id);
+            for await (const putEvent of _this2.network.sendRequest(event.peer.id, msg, options)) {
+              events$1.push(putEvent);
+              if (putEvent.name !== 'PEER_RESPONSE') {
+                continue;
+              }
+              if (!(putEvent.record != null && equals.equals(putEvent.record.value, index.Libp2pRecord.deserialize(record).value))) {
+                events$1.push(events.queryErrorEvent({
+                  from: event.peer.id,
+                  error: new errors.QueryError('Value not put correctly')
+                }, options));
+              }
+            }
+            return events$1;
+          };
+        }), source => index$3.default(source, {
+          ordered: false,
+          concurrency: constants.ALPHA
+        }), async function* (source) {
+          for await (const events of source) {
+            yield* events;
+          }
+        });
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Get the value to the given key
+   */
+  get(key) {
+    try {
+      var _this3 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        _this3.log('get %b', key);
+        const vals = [];
+        for await (const event of _this3.getMany(key, options)) {
+          if (event.name === 'VALUE') {
+            vals.push(event);
+          }
+          yield event;
+        }
+        if (vals.length === 0) {
+          return;
+        }
+        const records = vals.map(v => v.value);
+        let i = 0;
+        try {
+          i = selectors.bestRecord(_this3.selectors, key, records);
+        } catch (err) {
+          // Assume the first record if no selector available
+          if (err.name !== 'InvalidParametersError') {
+            throw err;
+          }
+        }
+        const best = records[i];
+        _this3.log('GetValue %b %b', key, best);
+        if (best == null) {
+          throw new errors$1.NotFoundError('Best value was not found');
+        }
+        yield* _this3.sendCorrectionRecord(key, vals, best, options);
+        yield vals[i];
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Get the `n` values to the given key without sorting
+   */
+  getMany(key) {
+    try {
+      var _this4 = this;
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return async function* () {
+        _this4.log('getMany values for %b', key);
+        try {
+          const localRec = await _this4.getLocal(key);
+          yield events.valueEvent({
+            value: localRec.value,
+            from: _this4.components.peerId
+          }, options);
+        } catch (err) {
+          _this4.log('error getting local value for %b', key, err);
+        }
+        const self = _this4; // eslint-disable-line @typescript-eslint/no-this-alias
+        const getValueQuery = function (_ref) {
+          try {
+            let {
+              peer,
+              signal
+            } = _ref;
+            return async function* () {
+              for await (const event of self.peerRouting.getValueOrPeers(peer, key, {
+                ...options,
+                signal
+              })) {
+                yield event;
+                if (event.name === 'PEER_RESPONSE' && event.record != null) {
+                  yield events.valueEvent({
+                    from: peer,
+                    value: event.record.value
+                  }, options);
+                }
+              }
+            }();
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+        // we have peers, lets send the actual query to them
+        yield* _this4.queryManager.run(key, getValueQuery, options);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+}
+
+exports.ContentFetching = ContentFetching;

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

@@ -0,0 +1,217 @@
+'use strict';
+
+var index$1 = require('../../../../../it-map/dist/src/index.js');
+var index$2 = require('../../../../../it-parallel/dist/src/index.js');
+var index = require('../../../../../it-pipe/dist/src/index.js');
+var constants = require('../constants.js');
+var dht = require('../message/dht.js');
+var utils = require('../message/utils.js');
+var events = require('../query/events.js');
+var set = require('../../../../peer-collections/dist/src/set.js');
+
+class ContentRouting {
+  log;
+  components;
+  network;
+  peerRouting;
+  queryManager;
+  routingTable;
+  providers;
+  constructor(components, init) {
+    const {
+      network,
+      peerRouting,
+      queryManager,
+      routingTable,
+      providers,
+      logPrefix
+    } = init;
+    this.components = components;
+    this.log = components.logger.forComponent(`${logPrefix}:content-routing`);
+    this.network = network;
+    this.peerRouting = peerRouting;
+    this.queryManager = queryManager;
+    this.routingTable = routingTable;
+    this.providers = providers;
+    this.findProviders = components.metrics?.traceFunction('libp2p.kadDHT.findProviders', this.findProviders.bind(this), {
+      optionsIndex: 1,
+      getAttributesFromYieldedValue: (event, attrs) => {
+        if (event.name === 'PROVIDER') {
+          attrs.providers ??= [];
+          attrs.providers.push(...event.providers.map(info => info.id.toString()));
+        }
+        return attrs;
+      }
+    }) ?? this.findProviders;
+    this.provide = components.metrics?.traceFunction('libp2p.kadDHT.provide', this.provide.bind(this), {
+      optionsIndex: 1,
+      getAttributesFromYieldedValue: (event, attrs) => {
+        if (event.name === 'PEER_RESPONSE' && event.messageName === 'ADD_PROVIDER') {
+          attrs.providers ??= [];
+          attrs.providers.push(event.from.toString());
+        }
+        return attrs;
+      }
+    }) ?? this.provide;
+  }
+  /**
+   * Announce to the network that we can provide the value for a given key and
+   * are contactable on the given multiaddrs
+   */
+  provide(key, multiaddrs) {
+    try {
+      var _this = this;
+      let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return async function* () {
+        _this.log('provide %s', key);
+        const target = key.multihash.bytes;
+        // Add peer as provider
+        await _this.providers.addProvider(key, _this.components.peerId);
+        const msg = {
+          type: dht.MessageType.ADD_PROVIDER,
+          key: target,
+          providers: [utils.toPbPeerInfo({
+            id: _this.components.peerId,
+            multiaddrs
+          })]
+        };
+        let sent = 0;
+        const maybeNotifyPeer = event => {
+          return async () => {
+            if (event.name !== 'FINAL_PEER') {
+              return [event];
+            }
+            const events$1 = [];
+            _this.log('putProvider %s to %p', key, event.peer.id);
+            try {
+              _this.log('sending provider record for %s to %p', key, event.peer.id);
+              for await (const sendEvent of _this.network.sendMessage(event.peer.id, msg, options)) {
+                if (sendEvent.name === 'PEER_RESPONSE') {
+                  _this.log('sent provider record for %s to %p', key, event.peer.id);
+                  sent++;
+                }
+                events$1.push(sendEvent);
+              }
+            } catch (err) {
+              _this.log.error('error sending provide record to peer %p', event.peer.id, err);
+              events$1.push(events.queryErrorEvent({
+                from: event.peer.id,
+                error: err
+              }, options));
+            }
+            return events$1;
+          };
+        };
+        // Notify closest peers
+        yield* index.pipe(_this.peerRouting.getClosestPeers(target, options), source => index$1.default(source, event => maybeNotifyPeer(event)), source => index$2.default(source, {
+          ordered: false,
+          concurrency: constants.ALPHA
+        }), async function* (source) {
+          for await (const events of source) {
+            yield* events;
+          }
+        });
+        _this.log('sent provider records to %d peers', sent);
+      }();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Search the dht for up to `K` providers of the given CID.
+   */
+  async *findProviders(key, options) {
+    const toFind = this.routingTable.kBucketSize;
+    let found = 0;
+    const target = key.multihash.bytes;
+    const self = this; // eslint-disable-line @typescript-eslint/no-this-alias
+    this.log('findProviders %c', key);
+    const provs = await this.providers.getProviders(key);
+    // yield values if we have some, also slice because maybe we got lucky and already have too many?
+    if (provs.length > 0) {
+      const providers = [];
+      for (const peerId of provs.slice(0, toFind)) {
+        try {
+          const peer = await this.components.peerStore.get(peerId);
+          providers.push({
+            id: peerId,
+            multiaddrs: peer.addresses.map(_ref => {
+              let {
+                multiaddr
+              } = _ref;
+              return multiaddr;
+            })
+          });
+        } catch (err) {
+          if (err.name !== 'NotFoundError') {
+            throw err;
+          }
+          this.log('no peer store entry for %p', peerId);
+        }
+      }
+      yield events.peerResponseEvent({
+        from: this.components.peerId,
+        messageType: dht.MessageType.GET_PROVIDERS,
+        providers
+      }, options);
+      yield events.providerEvent({
+        from: this.components.peerId,
+        providers
+      }, options);
+      found += providers.length;
+      if (found >= toFind) {
+        return;
+      }
+    }
+    /**
+     * The query function to use on this particular disjoint path
+     */
+    const findProvidersQuery = function (_ref2) {
+      try {
+        let {
+          peer,
+          signal
+        } = _ref2;
+        return async function* () {
+          const request = {
+            type: dht.MessageType.GET_PROVIDERS,
+            key: target
+          };
+          yield* self.network.sendRequest(peer, request, {
+            ...options,
+            signal
+          });
+        }();
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    const providers = new set.PeerSet(provs);
+    for await (const event of this.queryManager.run(target, findProvidersQuery, options)) {
+      yield event;
+      if (event.name === 'PEER_RESPONSE') {
+        this.log('Found %d provider entries for %c and %d closer peers', event.providers.length, key, event.closer.length);
+        const newProviders = [];
+        for (const peer of event.providers) {
+          if (providers.has(peer.id)) {
+            continue;
+          }
+          providers.add(peer.id);
+          newProviders.push(peer);
+        }
+        if (newProviders.length > 0) {
+          yield events.providerEvent({
+            from: event.from,
+            providers: newProviders
+          }, options);
+          found += newProviders.length;
+          if (found >= toFind) {
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+exports.ContentRouting = ContentRouting;

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

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * An error occurred during a query
+ */
+class QueryError extends Error {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Query error';
+    super(message);
+    this.name = 'QueryError';
+  }
+}
+/**
+ * A query was aborted
+ */
+class QueryAbortedError extends Error {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Query aborted';
+    super(message);
+    this.name = 'QueryAbortedError';
+  }
+}
+/**
+ * An invalid record was received
+ */
+class InvalidRecordError extends Error {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Invalid record';
+    super(message);
+    this.name = 'InvalidRecordError';
+  }
+}
+/**
+ * A selector function was missing
+ */
+class MissingSelectorError extends Error {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'No selector function configured for prefix';
+    super(message);
+    this.name = 'MissingSelectorError';
+  }
+}
+
+exports.InvalidRecordError = InvalidRecordError;
+exports.MissingSelectorError = MissingSelectorError;
+exports.QueryAbortedError = QueryAbortedError;
+exports.QueryError = QueryError;