web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/node_modules/@chainsafe/libp2p-yamux/dist/src/frame.js

@@ -0,0 +1,36 @@
+'use strict';
+
+exports.FrameType = void 0;
+(function (FrameType) {
+  /** Used to transmit data. May transmit zero length payloads depending on the flags. */
+  FrameType[FrameType["Data"] = 0] = "Data";
+  /** Used to updated the senders receive window size. This is used to implement per-session flow control. */
+  FrameType[FrameType["WindowUpdate"] = 1] = "WindowUpdate";
+  /** Used to measure RTT. It can also be used to heart-beat and do keep-alives over TCP. */
+  FrameType[FrameType["Ping"] = 2] = "Ping";
+  /** Used to close a session. */
+  FrameType[FrameType["GoAway"] = 3] = "GoAway";
+})(exports.FrameType || (exports.FrameType = {}));
+exports.Flag = void 0;
+(function (Flag) {
+  /** Signals the start of a new stream. May be sent with a data or window update message. Also sent with a ping to indicate outbound. */
+  Flag[Flag["SYN"] = 1] = "SYN";
+  /** Acknowledges the start of a new stream. May be sent with a data or window update message. Also sent with a ping to indicate response. */
+  Flag[Flag["ACK"] = 2] = "ACK";
+  /** Performs a half-close of a stream. May be sent with a data message or window update. */
+  Flag[Flag["FIN"] = 4] = "FIN";
+  /** Reset a stream immediately. May be sent with a data or window update message. */
+  Flag[Flag["RST"] = 8] = "RST";
+})(exports.Flag || (exports.Flag = {}));
+Object.values(exports.Flag).filter(x => typeof x !== 'string');
+const YAMUX_VERSION = 0;
+exports.GoAwayCode = void 0;
+(function (GoAwayCode) {
+  GoAwayCode[GoAwayCode["NormalTermination"] = 0] = "NormalTermination";
+  GoAwayCode[GoAwayCode["ProtocolError"] = 1] = "ProtocolError";
+  GoAwayCode[GoAwayCode["InternalError"] = 2] = "InternalError";
+})(exports.GoAwayCode || (exports.GoAwayCode = {}));
+const HEADER_LENGTH = 12;
+
+exports.HEADER_LENGTH = HEADER_LENGTH;
+exports.YAMUX_VERSION = YAMUX_VERSION;

package/dist/cjs/node_modules/@chainsafe/libp2p-yamux/dist/src/index.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var muxer = require('./muxer.js');
+var frame = require('./frame.js');
+
+/**
+ * @packageDocumentation
+ *
+ * This module is a JavaScript implementation of [Yamux from Hashicorp](https://github.com/hashicorp/yamux/blob/master/spec.md) designed to be used with [js-libp2p](https://github.com/libp2p/js-libp2p).
+ *
+ * @example Configure libp2p with Yamux
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
+ *
+ * const node = await createLibp2p({
+ *   // ... other options
+ *   streamMuxers: [
+ *     yamux()
+ *   ]
+ * })
+ * ```
+ *
+ * @example Using the low-level API
+ *
+ * ```js
+ * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { pipe } from 'it-pipe'
+ * import { duplexPair } from 'it-pair/duplex'
+ * import all from 'it-all'
+ *
+ * // Connect two yamux muxers to demo basic stream multiplexing functionality
+ *
+ * const clientMuxer = yamux({
+ *   client: true,
+ *   onIncomingStream: stream => {
+ *     // echo data on incoming streams
+ *     pipe(stream, stream)
+ *   },
+ *   onStreamEnd: stream => {
+ *     // do nothing
+ *   }
+ * })()
+ *
+ * const serverMuxer = yamux({
+ *   client: false,
+ *   onIncomingStream: stream => {
+ *     // echo data on incoming streams
+ *     pipe(stream, stream)
+ *   },
+ *   onStreamEnd: stream => {
+ *     // do nothing
+ *   }
+ * })()
+ *
+ * // `p` is our "connections", what we use to connect the two sides
+ * // In a real application, a connection is usually to a remote computer
+ * const p = duplexPair()
+ *
+ * // connect the muxers together
+ * pipe(p[0], clientMuxer, p[0])
+ * pipe(p[1], serverMuxer, p[1])
+ *
+ * // now either side can open streams
+ * const stream0 = clientMuxer.newStream()
+ * const stream1 = serverMuxer.newStream()
+ *
+ * // Send some data to the other side
+ * const encoder = new TextEncoder()
+ * const data = [encoder.encode('hello'), encoder.encode('world')]
+ * pipe(data, stream0)
+ *
+ * // Receive data back
+ * const result = await pipe(stream0, all)
+ *
+ * // close a stream
+ * stream1.close()
+ *
+ * // close the muxer
+ * clientMuxer.close()
+ * ```
+ */
+function yamux() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new muxer.Yamux(components, init);
+}
+
+Object.defineProperty(exports, "GoAwayCode", {
+    enumerable: true,
+    get: function () { return frame.GoAwayCode; }
+});
+exports.yamux = yamux;

package/dist/cjs/node_modules/@chainsafe/libp2p-yamux/dist/src/muxer.js

@@ -0,0 +1,532 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var index$2 = require('../../../../get-iterator/dist/src/index.js');
+var index = require('../../../../it-pushable/dist/src/index.js');
+var index$1 = require('../../../../uint8arraylist/dist/src/index.js');
+var config = require('./config.js');
+var constants = require('./constants.js');
+var decode = require('./decode.js');
+var encode = require('./encode.js');
+var errors = require('./errors.js');
+var frame = require('./frame.js');
+var stream = require('./stream.js');
+
+const YAMUX_PROTOCOL_ID = '/yamux/1.0.0';
+const CLOSE_TIMEOUT = 500;
+class Yamux {
+  protocol = (() => YAMUX_PROTOCOL_ID)();
+  _components;
+  _init;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this._components = components;
+    this._init = init;
+  }
+  [Symbol.toStringTag] = '@chainsafe/libp2p-yamux';
+  [_interface.serviceCapabilities] = ['@libp2p/stream-multiplexing'];
+  createStreamMuxer(init) {
+    return new YamuxMuxer(this._components, {
+      ...this._init,
+      ...init
+    });
+  }
+}
+class YamuxMuxer {
+  protocol = (() => YAMUX_PROTOCOL_ID)();
+  source;
+  sink;
+  config;
+  log;
+  logger;
+  /** Used to close the muxer from either the sink or source */
+  closeController;
+  /** The next stream id to be used when initiating a new stream */
+  nextStreamID;
+  /** Primary stream mapping, streamID => stream */
+  _streams;
+  /** The next ping id to be used when pinging */
+  nextPingID;
+  /** Tracking info for the currently active ping */
+  activePing;
+  /** Round trip time */
+  rtt;
+  /** True if client, false if server */
+  client;
+  localGoAway;
+  remoteGoAway;
+  /** Number of tracked inbound streams */
+  numInboundStreams;
+  /** Number of tracked outbound streams */
+  numOutboundStreams;
+  onIncomingStream;
+  onStreamEnd;
+  constructor(components, init) {
+    this.client = init.direction === 'outbound';
+    this.config = {
+      ...config.defaultConfig,
+      ...init
+    };
+    this.logger = components.logger;
+    this.log = this.logger.forComponent('libp2p:yamux');
+    config.verifyConfig(this.config);
+    this.closeController = new AbortController();
+    _interface.setMaxListeners(Infinity, this.closeController.signal);
+    this.onIncomingStream = init.onIncomingStream;
+    this.onStreamEnd = init.onStreamEnd;
+    this._streams = new Map();
+    this.source = index.pushable({
+      onEnd: () => {
+        this.log?.trace('muxer source ended');
+        this._streams.forEach(stream => {
+          stream.destroy();
+        });
+      }
+    });
+    this.sink = async source => {
+      const shutDownListener = () => {
+        const iterator = index$2.getIterator(source);
+        if (iterator.return != null) {
+          const res = iterator.return();
+          if (isPromise(res)) {
+            res.catch(err => {
+              this.log?.('could not cause sink source to return', err);
+            });
+          }
+        }
+      };
+      let reason, error;
+      try {
+        const decoder = new decode.Decoder(source);
+        try {
+          this.closeController.signal.addEventListener('abort', shutDownListener);
+          for await (const frame of decoder.emitFrames()) {
+            await this.handleFrame(frame.header, frame.readData);
+          }
+        } finally {
+          this.closeController.signal.removeEventListener('abort', shutDownListener);
+        }
+        reason = frame.GoAwayCode.NormalTermination;
+      } catch (err) {
+        // either a protocol or internal error
+        if (constants.PROTOCOL_ERRORS.has(err.name)) {
+          this.log?.error('protocol error in sink', err);
+          reason = frame.GoAwayCode.ProtocolError;
+        } else {
+          this.log?.error('internal error in sink', err);
+          reason = frame.GoAwayCode.InternalError;
+        }
+        error = err;
+      }
+      this.log?.trace('muxer sink ended');
+      if (error != null) {
+        this.abort(error, reason);
+      } else {
+        await this.close({
+          reason
+        });
+      }
+    };
+    this.numInboundStreams = 0;
+    this.numOutboundStreams = 0;
+    // client uses odd streamIDs, server uses even streamIDs
+    this.nextStreamID = this.client ? 1 : 2;
+    this.nextPingID = 0;
+    this.rtt = -1;
+    this.log?.trace('muxer created');
+    if (this.config.enableKeepAlive) {
+      this.keepAliveLoop().catch(e => this.log?.error('keepalive error: %s', e));
+    }
+    // send an initial ping to establish RTT
+    this.ping().catch(e => this.log?.error('ping error: %s', e));
+  }
+  get streams() {
+    return Array.from(this._streams.values());
+  }
+  newStream(name) {
+    if (this.remoteGoAway !== undefined) {
+      throw new _interface.MuxerClosedError('Muxer closed remotely');
+    }
+    if (this.localGoAway !== undefined) {
+      throw new _interface.MuxerClosedError('Muxer closed locally');
+    }
+    const id = this.nextStreamID;
+    this.nextStreamID += 2;
+    // check against our configured maximum number of outbound streams
+    if (this.numOutboundStreams >= this.config.maxOutboundStreams) {
+      throw new _interface.TooManyOutboundProtocolStreamsError('max outbound streams exceeded');
+    }
+    this.log?.trace('new outgoing stream id=%s', id);
+    const stream$1 = this._newStream(id, name, stream.StreamState.Init, 'outbound');
+    this._streams.set(id, stream$1);
+    this.numOutboundStreams++;
+    // send a window update to open the stream on the receiver end
+    stream$1.sendWindowUpdate();
+    return stream$1;
+  }
+  /**
+   * Initiate a ping and wait for a response
+   *
+   * Note: only a single ping will be initiated at a time.
+   * If a ping is already in progress, a new ping will not be initiated.
+   *
+   * @returns the round-trip-time in milliseconds
+   */
+  async ping() {
+    if (this.remoteGoAway !== undefined) {
+      throw new _interface.MuxerClosedError('Muxer closed remotely');
+    }
+    if (this.localGoAway !== undefined) {
+      throw new _interface.MuxerClosedError('Muxer closed locally');
+    }
+    // An active ping does not yet exist, handle the process here
+    if (this.activePing === undefined) {
+      // create active ping
+      let _resolve = () => {};
+      this.activePing = {
+        id: this.nextPingID++,
+        // this promise awaits resolution or the close controller aborting
+        promise: new Promise((resolve, reject) => {
+          const closed = () => {
+            reject(new _interface.MuxerClosedError('Muxer closed locally'));
+          };
+          this.closeController.signal.addEventListener('abort', closed, {
+            once: true
+          });
+          _resolve = () => {
+            this.closeController.signal.removeEventListener('abort', closed);
+            resolve();
+          };
+        }),
+        resolve: _resolve
+      };
+      // send ping
+      const start = Date.now();
+      this.sendPing(this.activePing.id);
+      // await pong
+      try {
+        await this.activePing.promise;
+      } finally {
+        // clean-up active ping
+        delete this.activePing;
+      }
+      // update rtt
+      const end = Date.now();
+      this.rtt = end - start;
+    } else {
+      // an active ping is already in progress, piggyback off that
+      await this.activePing.promise;
+    }
+    return this.rtt;
+  }
+  /**
+   * Get the ping round trip time
+   *
+   * Note: Will return 0 if no successful ping has yet been completed
+   *
+   * @returns the round-trip-time in milliseconds
+   */
+  getRTT() {
+    return this.rtt;
+  }
+  /**
+   * Close the muxer
+   */
+  async close() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (this.closeController.signal.aborted) {
+      // already closed
+      return;
+    }
+    const reason = options?.reason ?? frame.GoAwayCode.NormalTermination;
+    this.log?.trace('muxer close reason=%s', reason);
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(CLOSE_TIMEOUT);
+      _interface.setMaxListeners(Infinity, signal);
+      options = {
+        ...options,
+        signal
+      };
+    }
+    try {
+      await Promise.all([...this._streams.values()].map(async s => s.close(options)));
+      // send reason to the other side, allow the other side to close gracefully
+      this.sendGoAway(reason);
+      this._closeMuxer();
+    } catch (err) {
+      this.abort(err);
+    }
+  }
+  abort(err, reason) {
+    if (this.closeController.signal.aborted) {
+      // already closed
+      return;
+    }
+    reason = reason ?? frame.GoAwayCode.InternalError;
+    // If reason was provided, use that, otherwise use the presence of `err` to determine the reason
+    this.log?.error('muxer abort reason=%s error=%s', reason, err);
+    // Abort all underlying streams
+    for (const stream of this._streams.values()) {
+      stream.abort(err);
+    }
+    // send reason to the other side, allow the other side to close gracefully
+    this.sendGoAway(reason);
+    this._closeMuxer();
+  }
+  isClosed() {
+    return this.closeController.signal.aborted;
+  }
+  /**
+   * Called when either the local or remote shuts down the muxer
+   */
+  _closeMuxer() {
+    // stop the sink and any other processes
+    this.closeController.abort();
+    // stop the source
+    this.source.end();
+  }
+  /** Create a new stream */
+  _newStream(id, name, state, direction) {
+    if (this._streams.get(id) != null) {
+      throw new _interface.InvalidParametersError('Stream already exists with that id');
+    }
+    const stream$1 = new stream.YamuxStream({
+      id: id.toString(),
+      name,
+      state,
+      direction,
+      sendFrame: this.sendFrame.bind(this),
+      onEnd: () => {
+        this.closeStream(id);
+        this.onStreamEnd?.(stream$1);
+      },
+      log: this.logger.forComponent(`libp2p:yamux:${direction}:${id}`),
+      config: this.config,
+      getRTT: this.getRTT.bind(this)
+    });
+    return stream$1;
+  }
+  /**
+   * closeStream is used to close a stream once both sides have
+   * issued a close.
+   */
+  closeStream(id) {
+    if (this.client === (id % 2 === 0)) {
+      this.numInboundStreams--;
+    } else {
+      this.numOutboundStreams--;
+    }
+    this._streams.delete(id);
+  }
+  async keepAliveLoop() {
+    const abortPromise = new Promise((_resolve, reject) => {
+      this.closeController.signal.addEventListener('abort', reject, {
+        once: true
+      });
+    });
+    this.log?.trace('muxer keepalive enabled interval=%s', this.config.keepAliveInterval);
+    while (true) {
+      let timeoutId;
+      try {
+        await Promise.race([abortPromise, new Promise(resolve => {
+          timeoutId = setTimeout(resolve, this.config.keepAliveInterval);
+        })]);
+        this.ping().catch(e => this.log?.error('ping error: %s', e));
+      } catch (e) {
+        // closed
+        clearInterval(timeoutId);
+        return;
+      }
+    }
+  }
+  async handleFrame(header, readData) {
+    const {
+      streamID,
+      type,
+      length
+    } = header;
+    this.log?.trace('received frame %o', header);
+    if (streamID === 0) {
+      switch (type) {
+        case frame.FrameType.Ping:
+          {
+            this.handlePing(header);
+            return;
+          }
+        case frame.FrameType.GoAway:
+          {
+            this.handleGoAway(length);
+            return;
+          }
+        default:
+          // Invalid state
+          throw new errors.InvalidFrameError('Invalid frame type');
+      }
+    } else {
+      switch (header.type) {
+        case frame.FrameType.Data:
+        case frame.FrameType.WindowUpdate:
+          {
+            await this.handleStreamMessage(header, readData);
+            return;
+          }
+        default:
+          // Invalid state
+          throw new errors.InvalidFrameError('Invalid frame type');
+      }
+    }
+  }
+  handlePing(header) {
+    // If the ping  is initiated by the sender, send a response
+    if (header.flag === frame.Flag.SYN) {
+      this.log?.trace('received ping request pingId=%s', header.length);
+      this.sendPing(header.length, frame.Flag.ACK);
+    } else if (header.flag === frame.Flag.ACK) {
+      this.log?.trace('received ping response pingId=%s', header.length);
+      this.handlePingResponse(header.length);
+    } else {
+      // Invalid state
+      throw new errors.InvalidFrameError('Invalid frame flag');
+    }
+  }
+  handlePingResponse(pingId) {
+    if (this.activePing === undefined) {
+      // this ping was not requested
+      throw new errors.UnrequestedPingError('ping not requested');
+    }
+    if (this.activePing.id !== pingId) {
+      // this ping doesn't match our active ping request
+      throw new errors.NotMatchingPingError('ping doesn\'t match our id');
+    }
+    // valid ping response
+    this.activePing.resolve();
+  }
+  handleGoAway(reason) {
+    this.log?.trace('received GoAway reason=%s', frame.GoAwayCode[reason] ?? 'unknown');
+    this.remoteGoAway = reason;
+    // If the other side is friendly, they would have already closed all streams before sending a GoAway
+    // In case they weren't, reset all streams
+    for (const stream of this._streams.values()) {
+      stream.reset();
+    }
+    this._closeMuxer();
+  }
+  async handleStreamMessage(header, readData) {
+    const {
+      streamID,
+      flag,
+      type
+    } = header;
+    if ((flag & frame.Flag.SYN) === frame.Flag.SYN) {
+      this.incomingStream(streamID);
+    }
+    const stream = this._streams.get(streamID);
+    if (stream === undefined) {
+      if (type === frame.FrameType.Data) {
+        this.log?.('discarding data for stream id=%s', streamID);
+        if (readData === undefined) {
+          throw new Error('unreachable');
+        }
+        await readData();
+      } else {
+        this.log?.trace('frame for missing stream id=%s', streamID);
+      }
+      return;
+    }
+    switch (type) {
+      case frame.FrameType.WindowUpdate:
+        {
+          stream.handleWindowUpdate(header);
+          return;
+        }
+      case frame.FrameType.Data:
+        {
+          if (readData === undefined) {
+            throw new Error('unreachable');
+          }
+          await stream.handleData(header, readData);
+          return;
+        }
+      default:
+        throw new Error('unreachable');
+    }
+  }
+  incomingStream(id) {
+    if (this.client !== (id % 2 === 0)) {
+      throw new _interface.InvalidParametersError('Both endpoints are clients');
+    }
+    if (this._streams.has(id)) {
+      return;
+    }
+    this.log?.trace('new incoming stream id=%s', id);
+    if (this.localGoAway !== undefined) {
+      // reject (reset) immediately if we are doing a go away
+      this.sendFrame({
+        type: frame.FrameType.WindowUpdate,
+        flag: frame.Flag.RST,
+        streamID: id,
+        length: 0
+      });
+      return;
+    }
+    // check against our configured maximum number of inbound streams
+    if (this.numInboundStreams >= this.config.maxInboundStreams) {
+      this.log?.('maxIncomingStreams exceeded, forcing stream reset');
+      this.sendFrame({
+        type: frame.FrameType.WindowUpdate,
+        flag: frame.Flag.RST,
+        streamID: id,
+        length: 0
+      });
+      return;
+    }
+    // allocate a new stream
+    const stream$1 = this._newStream(id, undefined, stream.StreamState.SYNReceived, 'inbound');
+    this.numInboundStreams++;
+    // the stream should now be tracked
+    this._streams.set(id, stream$1);
+    this.onIncomingStream?.(stream$1);
+  }
+  sendFrame(header, data) {
+    this.log?.trace('sending frame %o', header);
+    if (header.type === frame.FrameType.Data) {
+      if (data === undefined) {
+        throw new errors.InvalidFrameError('Invalid frame');
+      }
+      this.source.push(new index$1.Uint8ArrayList(encode.encodeHeader(header), data));
+    } else {
+      this.source.push(encode.encodeHeader(header));
+    }
+  }
+  sendPing(pingId) {
+    let flag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : frame.Flag.SYN;
+    if (flag === frame.Flag.SYN) {
+      this.log?.trace('sending ping request pingId=%s', pingId);
+    } else {
+      this.log?.trace('sending ping response pingId=%s', pingId);
+    }
+    this.sendFrame({
+      type: frame.FrameType.Ping,
+      flag,
+      streamID: 0,
+      length: pingId
+    });
+  }
+  sendGoAway() {
+    let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : frame.GoAwayCode.NormalTermination;
+    this.log?.('sending GoAway reason=%s', frame.GoAwayCode[reason]);
+    this.localGoAway = reason;
+    this.sendFrame({
+      type: frame.FrameType.GoAway,
+      flag: 0,
+      streamID: 0,
+      length: reason
+    });
+  }
+}
+function isPromise(thing) {
+  return thing != null && typeof thing.then === 'function';
+}
+
+exports.Yamux = Yamux;
+exports.YamuxMuxer = YamuxMuxer;