web-dc-api 0.0.58 → 0.0.59

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

@@ -0,0 +1,259 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var abstractStream = require('../../../../@libp2p/utils/dist/src/abstract-stream.js');
+var index = require('../../../../it-foreach/dist/src/index.js');
+var constants = require('./constants.js');
+var errors = require('./errors.js');
+var frame = require('./frame.js');
+
+exports.StreamState = void 0;
+(function (StreamState) {
+  StreamState[StreamState["Init"] = 0] = "Init";
+  StreamState[StreamState["SYNSent"] = 1] = "SYNSent";
+  StreamState[StreamState["SYNReceived"] = 2] = "SYNReceived";
+  StreamState[StreamState["Established"] = 3] = "Established";
+  StreamState[StreamState["Finished"] = 4] = "Finished";
+})(exports.StreamState || (exports.StreamState = {}));
+/** YamuxStream is used to represent a logical stream within a session */
+class YamuxStream extends abstractStream.AbstractStream {
+  name;
+  state;
+  config;
+  _id;
+  /** The number of available bytes to send */
+  sendWindowCapacity;
+  /** Callback to notify that the sendWindowCapacity has been updated */
+  sendWindowCapacityUpdate;
+  /** The number of bytes available to receive in a full window */
+  recvWindow;
+  /** The number of available bytes to receive */
+  recvWindowCapacity;
+  /**
+   * An 'epoch' is the time it takes to process and read data
+   *
+   * Used in conjunction with RTT to determine whether to increase the recvWindow
+   */
+  epochStart;
+  getRTT;
+  sendFrame;
+  constructor(init) {
+    super({
+      ...init,
+      onEnd: err => {
+        this.state = exports.StreamState.Finished;
+        init.onEnd?.(err);
+      }
+    });
+    this.config = init.config;
+    this._id = parseInt(init.id, 10);
+    this.name = init.name;
+    this.state = init.state;
+    this.sendWindowCapacity = constants.INITIAL_STREAM_WINDOW;
+    this.recvWindow = this.config.initialStreamWindowSize;
+    this.recvWindowCapacity = this.recvWindow;
+    this.epochStart = Date.now();
+    this.getRTT = init.getRTT;
+    this.sendFrame = init.sendFrame;
+    this.source = index.default(this.source, () => {
+      this.sendWindowUpdate();
+    });
+  }
+  /**
+   * Send a message to the remote muxer informing them a new stream is being
+   * opened.
+   *
+   * This is a noop for Yamux because the first window update is sent when
+   * .newStream is called on the muxer which opens the stream on the remote.
+   */
+  async sendNewStream() {}
+  /**
+   * Send a data message to the remote muxer
+   */
+  async sendData(buf) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    buf = buf.sublist();
+    // send in chunks, waiting for window updates
+    while (buf.byteLength !== 0) {
+      // wait for the send window to refill
+      if (this.sendWindowCapacity === 0) {
+        this.log?.trace('wait for send window capacity, status %s', this.status);
+        await this.waitForSendWindowCapacity(options);
+        // check we didn't close while waiting for send window capacity
+        if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+          this.log?.trace('%s while waiting for send window capacity', this.status);
+          return;
+        }
+      }
+      // send as much as we can
+      const toSend = Math.min(this.sendWindowCapacity, this.config.maxMessageSize - frame.HEADER_LENGTH, buf.length);
+      const flags = this.getSendFlags();
+      this.sendFrame({
+        type: frame.FrameType.Data,
+        flag: flags,
+        streamID: this._id,
+        length: toSend
+      }, buf.sublist(0, toSend));
+      this.sendWindowCapacity -= toSend;
+      buf.consume(toSend);
+    }
+  }
+  /**
+   * Send a reset message to the remote muxer
+   */
+  async sendReset() {
+    this.sendFrame({
+      type: frame.FrameType.WindowUpdate,
+      flag: frame.Flag.RST,
+      streamID: this._id,
+      length: 0
+    });
+  }
+  /**
+   * Send a message to the remote muxer, informing them no more data messages
+   * will be sent by this end of the stream
+   */
+  async sendCloseWrite() {
+    const flags = this.getSendFlags() | frame.Flag.FIN;
+    this.sendFrame({
+      type: frame.FrameType.WindowUpdate,
+      flag: flags,
+      streamID: this._id,
+      length: 0
+    });
+  }
+  /**
+   * Send a message to the remote muxer, informing them no more data messages
+   * will be read by this end of the stream
+   */
+  async sendCloseRead() {}
+  /**
+   * Wait for the send window to be non-zero
+   *
+   * Will throw with ERR_STREAM_ABORT if the stream gets aborted
+   */
+  async waitForSendWindowCapacity() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (this.sendWindowCapacity > 0) {
+      return;
+    }
+    let resolve;
+    let reject;
+    const abort = () => {
+      if (this.status === 'open' || this.status === 'closing') {
+        reject(new _interface.AbortError('Stream aborted'));
+      } else {
+        // the stream was closed already, ignore the failure to send
+        resolve();
+      }
+    };
+    options.signal?.addEventListener('abort', abort);
+    try {
+      await new Promise((_resolve, _reject) => {
+        this.sendWindowCapacityUpdate = () => {
+          _resolve();
+        };
+        reject = _reject;
+        resolve = _resolve;
+      });
+    } finally {
+      options.signal?.removeEventListener('abort', abort);
+    }
+  }
+  /**
+   * handleWindowUpdate is called when the stream receives a window update frame
+   */
+  handleWindowUpdate(header) {
+    this.log?.trace('stream received window update id=%s', this._id);
+    this.processFlags(header.flag);
+    // increase send window
+    const available = this.sendWindowCapacity;
+    this.sendWindowCapacity += header.length;
+    // if the update increments a 0 availability, notify the stream that sending can resume
+    if (available === 0 && header.length > 0) {
+      this.sendWindowCapacityUpdate?.();
+    }
+  }
+  /**
+   * handleData is called when the stream receives a data frame
+   */
+  async handleData(header, readData) {
+    this.log?.trace('stream received data id=%s', this._id);
+    this.processFlags(header.flag);
+    // check that our recv window is not exceeded
+    if (this.recvWindowCapacity < header.length) {
+      throw new errors.ReceiveWindowExceededError('Receive window exceeded');
+    }
+    const data = await readData();
+    this.recvWindowCapacity -= header.length;
+    this.sourcePush(data);
+  }
+  /**
+   * processFlags is used to update the state of the stream based on set flags, if any.
+   */
+  processFlags(flags) {
+    if ((flags & frame.Flag.ACK) === frame.Flag.ACK) {
+      if (this.state === exports.StreamState.SYNSent) {
+        this.state = exports.StreamState.Established;
+      }
+    }
+    if ((flags & frame.Flag.FIN) === frame.Flag.FIN) {
+      this.remoteCloseWrite();
+    }
+    if ((flags & frame.Flag.RST) === frame.Flag.RST) {
+      this.reset();
+    }
+  }
+  /**
+   * getSendFlags determines any flags that are appropriate
+   * based on the current stream state.
+   *
+   * The state is updated as a side-effect.
+   */
+  getSendFlags() {
+    switch (this.state) {
+      case exports.StreamState.Init:
+        this.state = exports.StreamState.SYNSent;
+        return frame.Flag.SYN;
+      case exports.StreamState.SYNReceived:
+        this.state = exports.StreamState.Established;
+        return frame.Flag.ACK;
+      default:
+        return 0;
+    }
+  }
+  /**
+   * potentially sends a window update enabling further writes to take place.
+   */
+  sendWindowUpdate() {
+    // determine the flags if any
+    const flags = this.getSendFlags();
+    // If the stream has already been established
+    // and we've processed data within the time it takes for 4 round trips
+    // then we (up to) double the recvWindow
+    const now = Date.now();
+    const rtt = this.getRTT();
+    if (flags === 0 && rtt > -1 && now - this.epochStart < rtt * 4) {
+      // we've already validated that maxStreamWindowSize can't be more than MAX_UINT32
+      this.recvWindow = Math.min(this.recvWindow * 2, this.config.maxStreamWindowSize);
+    }
+    if (this.recvWindowCapacity >= this.recvWindow && flags === 0) {
+      // a window update isn't needed
+      return;
+    }
+    // update the receive window
+    const delta = this.recvWindow - this.recvWindowCapacity;
+    this.recvWindowCapacity = this.recvWindow;
+    // update the epoch start
+    this.epochStart = now;
+    // send window update
+    this.sendFrame({
+      type: frame.FrameType.WindowUpdate,
+      flag: flags,
+      streamID: this._id,
+      length: delta
+    });
+  }
+}
+
+exports.YamuxStream = YamuxStream;

package/dist/cjs/node_modules/@chainsafe/netmask/dist/src/cidr.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var parse = require('../../../is-ip/lib/parse.js');
+var ip = require('./ip.js');
+
+function parseCidr(s) {
+  const [address, maskString] = s.split("/");
+  if (!address || !maskString) throw new Error("Failed to parse given CIDR: " + s);
+  let ipLength = ip.IPv4Len;
+  let ip$1 = parse.parseIPv4(address);
+  if (ip$1 == null) {
+    ipLength = ip.IPv6Len;
+    ip$1 = parse.parseIPv6(address);
+    if (ip$1 == null) throw new Error("Failed to parse given CIDR: " + s);
+  }
+  const m = parseInt(maskString, 10);
+  if (Number.isNaN(m) || String(m).length !== maskString.length || m < 0 || m > ipLength * 8) {
+    throw new Error("Failed to parse given CIDR: " + s);
+  }
+  const mask = cidrMask(m, 8 * ipLength);
+  return {
+    network: ip.maskIp(ip$1, mask),
+    mask
+  };
+}
+function cidrMask(ones, bits) {
+  if (bits !== 8 * ip.IPv4Len && bits !== 8 * ip.IPv6Len) throw new Error("Invalid CIDR mask");
+  if (ones < 0 || ones > bits) throw new Error("Invalid CIDR mask");
+  const l = bits / 8;
+  const m = new Uint8Array(l);
+  for (let i = 0; i < l; i++) {
+    if (ones >= 8) {
+      m[i] = 0xff;
+      ones -= 8;
+      continue;
+    }
+    m[i] = 255 - (0xff >> ones);
+    ones = 0;
+  }
+  return m;
+}
+
+exports.cidrMask = cidrMask;
+exports.parseCidr = parseCidr;

package/dist/cjs/node_modules/@chainsafe/netmask/dist/src/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var ipnet = require('./ipnet.js');
+
+/**
+ * Checks if cidr block contains ip address
+ * @param cidr ipv4 or ipv6 formatted cidr . Example 198.51.100.14/24 or 2001:db8::/48
+ * @param ip ipv4 or ipv6 address Example 198.51.100.14 or 2001:db8::
+ *
+ */
+function cidrContains(cidr, ip) {
+  const ipnet$1 = new ipnet.IpNet(cidr);
+  return ipnet$1.contains(ip);
+}
+
+exports.IpNet = ipnet.IpNet;
+exports.cidrContains = cidrContains;

package/dist/cjs/node_modules/@chainsafe/netmask/dist/src/ip.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var parse = require('../../../is-ip/lib/parse.js');
+var util = require('./util.js');
+
+const IPv4Len = 4;
+const IPv6Len = 16;
+const ipv4Prefix = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255]);
+function maskIp(ip, mask) {
+  if (mask.length === IPv6Len && ip.length === IPv4Len && util.allFF(mask, 0, 11)) {
+    mask = mask.slice(12);
+  }
+  if (mask.length === IPv4Len && ip.length === IPv6Len && util.deepEqual(ip, ipv4Prefix, 0, 11)) {
+    ip = ip.slice(12);
+  }
+  const n = ip.length;
+  if (n != mask.length) {
+    throw new Error("Failed to mask ip");
+  }
+  const out = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    out[i] = ip[i] & mask[i];
+  }
+  return out;
+}
+function containsIp(net, ip) {
+  if (typeof ip === "string") {
+    ip = parse.parseIP(ip);
+  }
+  if (ip == null) throw new Error("Invalid ip");
+  if (ip.length !== net.network.length) {
+    return false;
+  }
+  for (let i = 0; i < ip.length; i++) {
+    if ((net.network[i] & net.mask[i]) !== (ip[i] & net.mask[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+exports.IPv4Len = IPv4Len;
+exports.IPv6Len = IPv6Len;
+exports.containsIp = containsIp;
+exports.ipv4Prefix = ipv4Prefix;
+exports.maskIp = maskIp;

package/dist/cjs/node_modules/@chainsafe/netmask/dist/src/ipnet.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var parse = require('../../../is-ip/lib/parse.js');
+var cidr = require('./cidr.js');
+var ip = require('./ip.js');
+var util = require('./util.js');
+
+class IpNet {
+  /**
+   *
+   * @param ipOrCidr either network ip or full cidr address
+   * @param mask in case ipOrCidr is network this can be either mask in decimal format or as ip address
+   */
+  constructor(ipOrCidr, mask) {
+    if (mask == null) {
+      ({
+        network: this.network,
+        mask: this.mask
+      } = cidr.parseCidr(ipOrCidr));
+    } else {
+      const ipResult = parse.parseIP(ipOrCidr);
+      if (ipResult == null) {
+        throw new Error("Failed to parse network");
+      }
+      mask = String(mask);
+      const m = parseInt(mask, 10);
+      if (Number.isNaN(m) || String(m).length !== mask.length || m < 0 || m > ipResult.length * 8) {
+        const maskResult = parse.parseIP(mask);
+        if (maskResult == null) {
+          throw new Error("Failed to parse mask");
+        }
+        this.mask = maskResult;
+      } else {
+        this.mask = cidr.cidrMask(m, 8 * ipResult.length);
+      }
+      this.network = ip.maskIp(ipResult, this.mask);
+    }
+  }
+  /**
+   * Checks if netmask contains ip address
+   * @param ip
+   * @returns
+   */
+  contains(ip$1) {
+    return ip.containsIp({
+      network: this.network,
+      mask: this.mask
+    }, ip$1);
+  }
+  /**Serializes back to string format */
+  toString() {
+    const l = util.simpleMaskLength(this.mask);
+    const mask = l !== -1 ? String(l) : util.maskToHex(this.mask);
+    return util.ipToString(this.network) + "/" + mask;
+  }
+}
+
+exports.IpNet = IpNet;

package/dist/cjs/node_modules/@chainsafe/netmask/dist/src/util.js

@@ -0,0 +1,89 @@
+'use strict';
+
+var ip = require('./ip.js');
+
+function allFF(a, from, to) {
+  let i = 0;
+  for (const e of a) {
+    if (i < from) continue;
+    if (i > to) break;
+    if (e !== 0xff) return false;
+    i++;
+  }
+  return true;
+}
+function deepEqual(a, b, from, to) {
+  let i = 0;
+  for (const e of a) {
+    if (i < from) continue;
+    if (i > to) break;
+    if (e !== b[i]) return false;
+    i++;
+  }
+  return true;
+}
+/***
+ * Returns long ip format
+ */
+function ipToString(ip$1) {
+  switch (ip$1.length) {
+    case ip.IPv4Len:
+      {
+        return ip$1.join(".");
+      }
+    case ip.IPv6Len:
+      {
+        const result = [];
+        for (let i = 0; i < ip$1.length; i++) {
+          if (i % 2 === 0) {
+            result.push(ip$1[i].toString(16).padStart(2, "0") + ip$1[i + 1].toString(16).padStart(2, "0"));
+          }
+        }
+        return result.join(":");
+      }
+    default:
+      {
+        throw new Error("Invalid ip length");
+      }
+  }
+}
+/**
+ * If mask is a sequence of 1 bits followed by 0 bits, return number of 1 bits else -1
+ */
+function simpleMaskLength(mask) {
+  let ones = 0;
+  // eslint-disable-next-line prefer-const
+  for (let [index, byte] of mask.entries()) {
+    if (byte === 0xff) {
+      ones += 8;
+      continue;
+    }
+    while ((byte & 0x80) != 0) {
+      ones++;
+      byte = byte << 1;
+    }
+    if ((byte & 0x80) != 0) {
+      return -1;
+    }
+    for (let i = index + 1; i < mask.length; i++) {
+      if (mask[i] != 0) {
+        return -1;
+      }
+    }
+    break;
+  }
+  return ones;
+}
+function maskToHex(mask) {
+  let hex = "0x";
+  for (const byte of mask) {
+    hex += (byte >> 4).toString(16) + (byte & 0x0f).toString(16);
+  }
+  return hex;
+}
+
+exports.allFF = allFF;
+exports.deepEqual = deepEqual;
+exports.ipToString = ipToString;
+exports.maskToHex = maskToHex;
+exports.simpleMaskLength = simpleMaskLength;