web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/@libp2p/peer-record/dist/src/peer-record/peer-record.js

@@ -0,0 +1,133 @@
+'use strict';
+
+var index = require('../../../../../protons-runtime/dist/src/index.js');
+var alloc = require('../../../../../uint8arrays/dist/src/alloc.js');
+var message = require('../../../../../protons-runtime/dist/src/codecs/message.js');
+var encode = require('../../../../../protons-runtime/dist/src/encode.js');
+var decode = require('../../../../../protons-runtime/dist/src/decode.js');
+
+exports.PeerRecord = void 0;
+(function (PeerRecord) {
+  (function (AddressInfo) {
+    let _codec;
+    AddressInfo.codec = () => {
+      if (_codec == null) {
+        _codec = message.message(function (obj, w) {
+          let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          if (opts.lengthDelimited !== false) {
+            w.fork();
+          }
+          if (obj.multiaddr != null && obj.multiaddr.byteLength > 0) {
+            w.uint32(10);
+            w.bytes(obj.multiaddr);
+          }
+          if (opts.lengthDelimited !== false) {
+            w.ldelim();
+          }
+        }, function (reader, length) {
+          const obj = {
+            multiaddr: alloc.alloc(0)
+          };
+          const end = length == null ? reader.len : reader.pos + length;
+          while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1:
+                {
+                  obj.multiaddr = reader.bytes();
+                  break;
+                }
+              default:
+                {
+                  reader.skipType(tag & 7);
+                  break;
+                }
+            }
+          }
+          return obj;
+        });
+      }
+      return _codec;
+    };
+    AddressInfo.encode = obj => {
+      return encode.encodeMessage(obj, AddressInfo.codec());
+    };
+    AddressInfo.decode = (buf, opts) => {
+      return decode.decodeMessage(buf, AddressInfo.codec(), opts);
+    };
+  })(PeerRecord.AddressInfo || (PeerRecord.AddressInfo = {}));
+  let _codec;
+  PeerRecord.codec = () => {
+    if (_codec == null) {
+      _codec = message.message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.peerId != null && obj.peerId.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.peerId);
+        }
+        if (obj.seq != null && obj.seq !== 0n) {
+          w.uint32(16);
+          w.uint64(obj.seq);
+        }
+        if (obj.addresses != null) {
+          for (const value of obj.addresses) {
+            w.uint32(26);
+            PeerRecord.AddressInfo.codec().encode(value, w);
+          }
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          peerId: alloc.alloc(0),
+          seq: 0n,
+          addresses: []
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.peerId = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                obj.seq = reader.uint64();
+                break;
+              }
+            case 3:
+              {
+                if (opts.limits?.addresses != null && obj.addresses.length === opts.limits.addresses) {
+                  throw new index.MaxLengthError('Decode error - map field "addresses" had too many elements');
+                }
+                obj.addresses.push(PeerRecord.AddressInfo.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.addresses$
+                }));
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  PeerRecord.encode = obj => {
+    return encode.encodeMessage(obj, PeerRecord.codec());
+  };
+  PeerRecord.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, PeerRecord.codec(), opts);
+  };
+})(exports.PeerRecord || (exports.PeerRecord = {}));

package/dist/cjs/node_modules/@libp2p/ping/dist/src/constants.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const PING_LENGTH = 32;
+const PROTOCOL_VERSION = '1.0.0';
+const PROTOCOL_NAME = 'ping';
+const PROTOCOL_PREFIX = 'ipfs';
+const TIMEOUT = 10000;
+// See https://github.com/libp2p/specs/blob/d4b5fb0152a6bb86cfd9ea/ping/ping.md?plain=1#L38-L43
+// The dialing peer MUST NOT keep more than one outbound stream for the ping protocol per peer.
+// The listening peer SHOULD accept at most two streams per peer since cross-stream behavior is
+// non-linear and stream writes occur asynchronously. The listening peer may perceive the
+// dialing peer closing and opening the wrong streams (for instance, closing stream B and
+// opening stream A even though the dialing peer is opening stream B and closing stream A).
+const MAX_INBOUND_STREAMS = 2;
+const MAX_OUTBOUND_STREAMS = 1;
+
+exports.MAX_INBOUND_STREAMS = MAX_INBOUND_STREAMS;
+exports.MAX_OUTBOUND_STREAMS = MAX_OUTBOUND_STREAMS;
+exports.PING_LENGTH = PING_LENGTH;
+exports.PROTOCOL_NAME = PROTOCOL_NAME;
+exports.PROTOCOL_PREFIX = PROTOCOL_PREFIX;
+exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+exports.TIMEOUT = TIMEOUT;

package/dist/cjs/node_modules/@libp2p/ping/dist/src/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var ping$1 = require('./ping.js');
+
+/**
+ * @packageDocumentation
+ *
+ * The ping service implements the [libp2p ping spec](https://github.com/libp2p/specs/blob/master/ping/ping.md) allowing you to make a latency measurement to a remote peer.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { ping } from '@libp2p/ping'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const node = await createLibp2p({
+ *   services: {
+ *     ping: ping()
+ *   }
+ * })
+ *
+ * const rtt = await node.services.ping.ping(multiaddr('/ip4/...'))
+ *
+ * console.info(rtt)
+ * ```
+ */
+function ping() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new ping$1.Ping(components, init);
+}
+
+exports.ping = ping;

package/dist/cjs/node_modules/@libp2p/ping/dist/src/ping.js

@@ -0,0 +1,140 @@
+'use strict';
+
+var crypto = require('@libp2p/crypto');
+var _interface = require('@libp2p/interface');
+var index = require('../../../../it-byte-stream/dist/src/index.js');
+var equals = require('../../../../uint8arrays/dist/src/equals.js');
+var constants = require('./constants.js');
+
+class Ping {
+  protocol;
+  components;
+  started;
+  timeout;
+  maxInboundStreams;
+  maxOutboundStreams;
+  runOnLimitedConnection;
+  log;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.components = components;
+    this.log = components.logger.forComponent('libp2p:ping');
+    this.started = false;
+    this.protocol = `/${init.protocolPrefix ?? constants.PROTOCOL_PREFIX}/${constants.PROTOCOL_NAME}/${constants.PROTOCOL_VERSION}`;
+    this.timeout = init.timeout ?? constants.TIMEOUT;
+    this.maxInboundStreams = init.maxInboundStreams ?? constants.MAX_INBOUND_STREAMS;
+    this.maxOutboundStreams = init.maxOutboundStreams ?? constants.MAX_OUTBOUND_STREAMS;
+    this.runOnLimitedConnection = init.runOnLimitedConnection ?? true;
+    this.handleMessage = this.handleMessage.bind(this);
+  }
+  [Symbol.toStringTag] = '@libp2p/ping';
+  [_interface.serviceCapabilities] = ['@libp2p/ping'];
+  async start() {
+    await this.components.registrar.handle(this.protocol, this.handleMessage, {
+      maxInboundStreams: this.maxInboundStreams,
+      maxOutboundStreams: this.maxOutboundStreams,
+      runOnLimitedConnection: this.runOnLimitedConnection
+    });
+    this.started = true;
+  }
+  async stop() {
+    await this.components.registrar.unhandle(this.protocol);
+    this.started = false;
+  }
+  isStarted() {
+    return this.started;
+  }
+  /**
+   * A handler to register with Libp2p to process ping messages
+   */
+  handleMessage(data) {
+    this.log('incoming ping from %p', data.connection.remotePeer);
+    const {
+      stream
+    } = data;
+    const start = Date.now();
+    const bytes = index.byteStream(stream);
+    let pinged = false;
+    Promise.resolve().then(async () => {
+      while (true) {
+        const signal = AbortSignal.timeout(this.timeout);
+        _interface.setMaxListeners(Infinity, signal);
+        signal.addEventListener('abort', () => {
+          stream?.abort(new _interface.TimeoutError('ping timeout'));
+        });
+        const buf = await bytes.read({
+          bytes: constants.PING_LENGTH,
+          signal
+        });
+        await bytes.write(buf, {
+          signal
+        });
+        pinged = true;
+      }
+    }).catch(err => {
+      // ignore the error if we've processed at least one ping, the remote
+      // closed the stream and we handled or are handling the close cleanly
+      if (pinged && err.name === 'UnexpectedEOFError' && stream.readStatus !== 'ready') {
+        return;
+      }
+      this.log.error('incoming ping from %p failed with error - %e', data.connection.remotePeer, err);
+      stream?.abort(err);
+    }).finally(() => {
+      const ms = Date.now() - start;
+      this.log('incoming ping from %p complete in %dms', data.connection.remotePeer, ms);
+      const signal = AbortSignal.timeout(this.timeout);
+      _interface.setMaxListeners(Infinity, signal);
+      stream.close({
+        signal
+      }).catch(err => {
+        this.log.error('error closing ping stream from %p - %e', data.connection.remotePeer, err);
+        stream?.abort(err);
+      });
+    });
+  }
+  /**
+   * Ping a given peer and wait for its response, getting the operation latency.
+   */
+  async ping(peer) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.log('pinging %p', peer);
+    const start = Date.now();
+    const data = crypto.randomBytes(constants.PING_LENGTH);
+    const connection = await this.components.connectionManager.openConnection(peer, options);
+    let stream;
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(this.timeout);
+      options = {
+        ...options,
+        signal
+      };
+    }
+    try {
+      stream = await connection.newStream(this.protocol, {
+        ...options,
+        runOnLimitedConnection: this.runOnLimitedConnection
+      });
+      const bytes = index.byteStream(stream);
+      const [, result] = await Promise.all([bytes.write(data, options), bytes.read({
+        ...options,
+        bytes: constants.PING_LENGTH
+      })]);
+      const ms = Date.now() - start;
+      if (!equals.equals(data, result.subarray())) {
+        throw new _interface.ProtocolError(`Received wrong ping ack after ${ms}ms`);
+      }
+      this.log('ping %p complete in %dms', connection.remotePeer, ms);
+      return ms;
+    } catch (err) {
+      this.log.error('error while pinging %p', connection.remotePeer, err);
+      stream?.abort(err);
+      throw err;
+    } finally {
+      if (stream != null) {
+        await stream.close(options);
+      }
+    }
+  }
+}
+
+exports.Ping = Ping;

package/dist/cjs/node_modules/@libp2p/utils/dist/src/abstract-stream.js

@@ -0,0 +1,337 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index$1 = require('../../../../it-pushable/dist/src/index.js');
+var index = require('../../../../p-defer/index.js');
+var index$3 = require('../../../../race-signal/dist/src/index.js');
+var index$2 = require('../../../../uint8arraylist/dist/src/index.js');
+var closeSource = require('./close-source.js');
+
+const DEFAULT_SEND_CLOSE_WRITE_TIMEOUT = 5000;
+function isPromise(thing) {
+  if (thing == null) {
+    return false;
+  }
+  return typeof thing.then === 'function' && typeof thing.catch === 'function' && typeof thing.finally === 'function';
+}
+class AbstractStream {
+  id;
+  direction;
+  timeline;
+  protocol;
+  metadata;
+  source;
+  status;
+  readStatus;
+  writeStatus;
+  log;
+  sinkController;
+  sinkEnd;
+  closed;
+  endErr;
+  streamSource;
+  onEnd;
+  onCloseRead;
+  onCloseWrite;
+  onReset;
+  onAbort;
+  sendCloseWriteTimeout;
+  sendingData;
+  constructor(init) {
+    this.sinkController = new AbortController();
+    this.sinkEnd = index.default();
+    this.closed = index.default();
+    this.log = init.log;
+    // stream status
+    this.status = 'open';
+    this.readStatus = 'ready';
+    this.writeStatus = 'ready';
+    this.id = init.id;
+    this.metadata = init.metadata ?? {};
+    this.direction = init.direction;
+    this.timeline = {
+      open: Date.now()
+    };
+    this.sendCloseWriteTimeout = init.sendCloseWriteTimeout ?? DEFAULT_SEND_CLOSE_WRITE_TIMEOUT;
+    this.onEnd = init.onEnd;
+    this.onCloseRead = init.onCloseRead;
+    this.onCloseWrite = init.onCloseWrite;
+    this.onReset = init.onReset;
+    this.onAbort = init.onAbort;
+    this.source = this.streamSource = index$1.pushable({
+      onEnd: err => {
+        if (err != null) {
+          this.log.trace('source ended with error', err);
+        } else {
+          this.log.trace('source ended');
+        }
+        this.onSourceEnd(err);
+      }
+    });
+    // necessary because the libp2p upgrader wraps the sink function
+    this.sink = this.sink.bind(this);
+  }
+  async sink(source) {
+    if (this.writeStatus !== 'ready') {
+      throw new _interface.StreamStateError(`writable end state is "${this.writeStatus}" not "ready"`);
+    }
+    try {
+      this.writeStatus = 'writing';
+      const options = {
+        signal: this.sinkController.signal
+      };
+      if (this.direction === 'outbound') {
+        // If initiator, open a new stream
+        const res = this.sendNewStream(options);
+        if (isPromise(res)) {
+          await res;
+        }
+      }
+      const abortListener = () => {
+        closeSource.closeSource(source, this.log);
+      };
+      try {
+        this.sinkController.signal.addEventListener('abort', abortListener);
+        this.log.trace('sink reading from source');
+        for await (let data of source) {
+          data = data instanceof Uint8Array ? new index$2.Uint8ArrayList(data) : data;
+          const res = this.sendData(data, options);
+          if (isPromise(res)) {
+            this.sendingData = index.default();
+            await res;
+            this.sendingData.resolve();
+            this.sendingData = undefined;
+          }
+        }
+      } finally {
+        this.sinkController.signal.removeEventListener('abort', abortListener);
+      }
+      this.log.trace('sink finished reading from source, write status is "%s"', this.writeStatus);
+      if (this.writeStatus === 'writing') {
+        this.writeStatus = 'closing';
+        this.log.trace('send close write to remote');
+        await this.sendCloseWrite({
+          signal: AbortSignal.timeout(this.sendCloseWriteTimeout)
+        });
+        this.writeStatus = 'closed';
+      }
+      this.onSinkEnd();
+    } catch (err) {
+      this.log.trace('sink ended with error, calling abort with error', err);
+      this.abort(err);
+      throw err;
+    } finally {
+      this.log.trace('resolve sink end');
+      this.sinkEnd.resolve();
+    }
+  }
+  onSourceEnd(err) {
+    if (this.timeline.closeRead != null) {
+      return;
+    }
+    this.timeline.closeRead = Date.now();
+    this.readStatus = 'closed';
+    if (err != null && this.endErr == null) {
+      this.endErr = err;
+    }
+    this.onCloseRead?.();
+    if (this.timeline.closeWrite != null) {
+      this.log.trace('source and sink ended');
+      this.timeline.close = Date.now();
+      if (this.status !== 'aborted' && this.status !== 'reset') {
+        this.status = 'closed';
+      }
+      if (this.onEnd != null) {
+        this.onEnd(this.endErr);
+      }
+      this.closed.resolve();
+    } else {
+      this.log.trace('source ended, waiting for sink to end');
+    }
+  }
+  onSinkEnd(err) {
+    if (this.timeline.closeWrite != null) {
+      return;
+    }
+    this.timeline.closeWrite = Date.now();
+    this.writeStatus = 'closed';
+    if (err != null && this.endErr == null) {
+      this.endErr = err;
+    }
+    this.onCloseWrite?.();
+    if (this.timeline.closeRead != null) {
+      this.log.trace('sink and source ended');
+      this.timeline.close = Date.now();
+      if (this.status !== 'aborted' && this.status !== 'reset') {
+        this.status = 'closed';
+      }
+      if (this.onEnd != null) {
+        this.onEnd(this.endErr);
+      }
+      this.closed.resolve();
+    } else {
+      this.log.trace('sink ended, waiting for source to end');
+    }
+  }
+  // Close for both Reading and Writing
+  async close(options) {
+    if (this.status !== 'open') {
+      return;
+    }
+    this.log.trace('closing gracefully');
+    this.status = 'closing';
+    // wait for read and write ends to close
+    await index$3.raceSignal(Promise.all([this.closeWrite(options), this.closeRead(options), this.closed.promise]), options?.signal);
+    this.status = 'closed';
+    this.log.trace('closed gracefully');
+  }
+  async closeRead() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (this.readStatus === 'closing' || this.readStatus === 'closed') {
+      return;
+    }
+    this.log.trace('closing readable end of stream with starting read status "%s"', this.readStatus);
+    const readStatus = this.readStatus;
+    this.readStatus = 'closing';
+    if (this.status !== 'reset' && this.status !== 'aborted' && this.timeline.closeRead == null) {
+      this.log.trace('send close read to remote');
+      await this.sendCloseRead(options);
+    }
+    if (readStatus === 'ready') {
+      this.log.trace('ending internal source queue with %d queued bytes', this.streamSource.readableLength);
+      this.streamSource.end();
+    }
+    this.log.trace('closed readable end of stream');
+  }
+  async closeWrite() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (this.writeStatus === 'closing' || this.writeStatus === 'closed') {
+      return;
+    }
+    this.log.trace('closing writable end of stream with starting write status "%s"', this.writeStatus);
+    if (this.writeStatus === 'ready') {
+      this.log.trace('sink was never sunk, sink an empty array');
+      await index$3.raceSignal(this.sink([]), options.signal);
+    }
+    if (this.writeStatus === 'writing') {
+      // try to let sending outgoing data succeed
+      if (this.sendingData != null) {
+        await index$3.raceSignal(this.sendingData.promise, options.signal);
+      }
+      // stop reading from the source passed to `.sink`
+      this.log.trace('aborting source passed to .sink');
+      this.sinkController.abort();
+      await index$3.raceSignal(this.sinkEnd.promise, options.signal);
+    }
+    this.writeStatus = 'closed';
+    this.log.trace('closed writable end of stream');
+  }
+  /**
+   * Close immediately for reading and writing and send a reset message (local
+   * error)
+   */
+  abort(err) {
+    if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+      return;
+    }
+    this.log('abort with error', err);
+    // try to send a reset message
+    this.log('try to send reset to remote');
+    const res = this.sendReset();
+    if (isPromise(res)) {
+      res.catch(err => {
+        this.log.error('error sending reset message', err);
+      });
+    }
+    this.status = 'aborted';
+    this.timeline.abort = Date.now();
+    this._closeSinkAndSource(err);
+    this.onAbort?.(err);
+  }
+  /**
+   * Receive a reset message - close immediately for reading and writing (remote
+   * error)
+   */
+  reset() {
+    if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+      return;
+    }
+    const err = new _interface.StreamResetError('stream reset');
+    this.status = 'reset';
+    this.timeline.reset = Date.now();
+    this._closeSinkAndSource(err);
+    this.onReset?.();
+  }
+  _closeSinkAndSource(err) {
+    this._closeSink(err);
+    this._closeSource(err);
+  }
+  _closeSink(err) {
+    // if the sink function is running, cause it to end
+    if (this.writeStatus === 'writing') {
+      this.log.trace('end sink source');
+      this.sinkController.abort();
+    }
+    this.onSinkEnd(err);
+  }
+  _closeSource(err) {
+    // if the source is not ending, end it
+    if (this.readStatus !== 'closing' && this.readStatus !== 'closed') {
+      this.log.trace('ending source with %d bytes to be read by consumer', this.streamSource.readableLength);
+      this.readStatus = 'closing';
+      this.streamSource.end(err);
+    }
+  }
+  /**
+   * The remote closed for writing so we should expect to receive no more
+   * messages
+   */
+  remoteCloseWrite() {
+    if (this.readStatus === 'closing' || this.readStatus === 'closed') {
+      this.log('received remote close write but local source is already closed');
+      return;
+    }
+    this.log.trace('remote close write');
+    this._closeSource();
+  }
+  /**
+   * The remote closed for reading so we should not send any more
+   * messages
+   */
+  remoteCloseRead() {
+    if (this.writeStatus === 'closing' || this.writeStatus === 'closed') {
+      this.log('received remote close read but local sink is already closed');
+      return;
+    }
+    this.log.trace('remote close read');
+    this._closeSink();
+  }
+  /**
+   * The underlying muxer has closed, no more messages can be sent or will
+   * be received, close immediately to free up resources
+   */
+  destroy() {
+    if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+      this.log('received destroy but we are already closed');
+      return;
+    }
+    this.log.trace('stream destroyed');
+    this._closeSinkAndSource();
+  }
+  /**
+   * When an extending class reads data from it's implementation-specific source,
+   * call this method to allow the stream consumer to read the data.
+   */
+  sourcePush(data) {
+    this.streamSource.push(data);
+  }
+  /**
+   * Returns the amount of unread data - can be used to prevent large amounts of
+   * data building up when the stream consumer is too slow.
+   */
+  sourceReadableLength() {
+    return this.streamSource.readableLength;
+  }
+}
+
+exports.AbstractStream = AbstractStream;

package/dist/cjs/node_modules/@libp2p/utils/dist/src/array-equals.js

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * @packageDocumentation
+ *
+ * Provides strategies ensure arrays are equivalent.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { arrayEquals } from '@libp2p/utils/array-equals'
+ * import { multiaddr } from '@multformats/multiaddr'
+ *
+ * const ma1 = multiaddr('/ip4/127.0.0.1/tcp/9000'),
+ * const ma2 = multiaddr('/ip4/82.41.53.1/tcp/9000')
+ *
+ * console.info(arrayEquals([ma1], [ma1])) // true
+ * console.info(arrayEquals([ma1], [ma2])) // false
+ * ```
+ */
+/**
+ * Verify if two arrays of non primitive types with the "equals" function are equal.
+ * Compatible with multiaddr, peer-id and others.
+ */
+function arrayEquals(a, b) {
+  const sort = (a, b) => a.toString().localeCompare(b.toString());
+  if (a.length !== b.length) {
+    return false;
+  }
+  b.sort(sort);
+  return a.sort(sort).every((item, index) => b[index].equals(item));
+}
+
+exports.arrayEquals = arrayEquals;