web-dc-api 0.0.58 → 0.0.59

package/dist/cjs/node_modules/@chainsafe/libp2p-noise/dist/src/protocol.js

@@ -0,0 +1,272 @@
+'use strict';
+
+var index = require('../../../../uint8arraylist/dist/src/index.js');
+var bytes = require('uint8arrays');
+var alloc = require('../../../../uint8arrays/dist/src/alloc.js');
+var errors = require('./errors.js');
+var nonce = require('./nonce.js');
+
+// Code in this file is a direct translation of a subset of the noise protocol https://noiseprotocol.org/noise.html,
+// agnostic to libp2p's usage of noise
+const ZEROLEN = alloc.alloc(0);
+class CipherState {
+  k;
+  n;
+  crypto;
+  constructor(crypto) {
+    let k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+    let n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    this.crypto = crypto;
+    this.k = k;
+    this.n = new nonce.Nonce(n);
+  }
+  hasKey() {
+    return Boolean(this.k);
+  }
+  encryptWithAd(ad, plaintext) {
+    if (!this.hasKey()) {
+      return plaintext;
+    }
+    this.n.assertValue();
+    const e = this.crypto.encrypt(plaintext, this.n.getBytes(), ad, this.k);
+    this.n.increment();
+    return e;
+  }
+  decryptWithAd(ad, ciphertext, dst) {
+    if (!this.hasKey()) {
+      return ciphertext;
+    }
+    this.n.assertValue();
+    const plaintext = this.crypto.decrypt(ciphertext, this.n.getBytes(), ad, this.k, dst);
+    this.n.increment();
+    return plaintext;
+  }
+}
+class SymmetricState {
+  cs;
+  ck;
+  h;
+  crypto;
+  constructor(crypto, protocolName) {
+    this.crypto = crypto;
+    const protocolNameBytes = bytes.fromString(protocolName, 'utf-8');
+    this.h = hashProtocolName(crypto, protocolNameBytes);
+    this.ck = this.h;
+    this.cs = new CipherState(crypto);
+  }
+  mixKey(ikm) {
+    const [ck, tempK] = this.crypto.hkdf(this.ck, ikm);
+    this.ck = ck;
+    this.cs = new CipherState(this.crypto, tempK);
+  }
+  mixHash(data) {
+    this.h = this.crypto.hash(new index.Uint8ArrayList(this.h, data));
+  }
+  encryptAndHash(plaintext) {
+    const ciphertext = this.cs.encryptWithAd(this.h, plaintext);
+    this.mixHash(ciphertext);
+    return ciphertext;
+  }
+  decryptAndHash(ciphertext) {
+    const plaintext = this.cs.decryptWithAd(this.h, ciphertext);
+    this.mixHash(ciphertext);
+    return plaintext;
+  }
+  split() {
+    const [tempK1, tempK2] = this.crypto.hkdf(this.ck, ZEROLEN);
+    return [new CipherState(this.crypto, tempK1), new CipherState(this.crypto, tempK2)];
+  }
+}
+class AbstractHandshakeState {
+  ss;
+  s;
+  e;
+  rs;
+  re;
+  initiator;
+  crypto;
+  constructor(init) {
+    const {
+      crypto,
+      protocolName,
+      prologue,
+      initiator,
+      s,
+      e,
+      rs,
+      re
+    } = init;
+    this.crypto = crypto;
+    this.ss = new SymmetricState(crypto, protocolName);
+    this.ss.mixHash(prologue);
+    this.initiator = initiator;
+    this.s = s;
+    this.e = e;
+    this.rs = rs;
+    this.re = re;
+  }
+  writeE() {
+    if (this.e) {
+      throw new Error('ephemeral keypair is already set');
+    }
+    const e = this.crypto.generateKeypair();
+    this.ss.mixHash(e.publicKey);
+    this.e = e;
+    return e.publicKey;
+  }
+  writeS() {
+    if (!this.s) {
+      throw new Error('static keypair is not set');
+    }
+    return this.ss.encryptAndHash(this.s.publicKey);
+  }
+  writeEE() {
+    if (!this.e) {
+      throw new Error('ephemeral keypair is not set');
+    }
+    if (!this.re) {
+      throw new Error('remote ephemeral public key is not set');
+    }
+    this.ss.mixKey(this.crypto.dh(this.e, this.re));
+  }
+  writeES() {
+    if (this.initiator) {
+      if (!this.e) {
+        throw new Error('ephemeral keypair is not set');
+      }
+      if (!this.rs) {
+        throw new Error('remote static public key is not set');
+      }
+      this.ss.mixKey(this.crypto.dh(this.e, this.rs));
+    } else {
+      if (!this.s) {
+        throw new Error('static keypair is not set');
+      }
+      if (!this.re) {
+        throw new Error('remote ephemeral public key is not set');
+      }
+      this.ss.mixKey(this.crypto.dh(this.s, this.re));
+    }
+  }
+  writeSE() {
+    if (this.initiator) {
+      if (!this.s) {
+        throw new Error('static keypair is not set');
+      }
+      if (!this.re) {
+        throw new Error('remote ephemeral public key is not set');
+      }
+      this.ss.mixKey(this.crypto.dh(this.s, this.re));
+    } else {
+      if (!this.e) {
+        throw new Error('ephemeral keypair is not set');
+      }
+      if (!this.rs) {
+        throw new Error('remote static public key is not set');
+      }
+      this.ss.mixKey(this.crypto.dh(this.e, this.rs));
+    }
+  }
+  readE(message) {
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (this.re) {
+      throw new Error('remote ephemeral public key is already set');
+    }
+    if (message.byteLength < offset + 32) {
+      throw new Error('message is not long enough');
+    }
+    this.re = message.sublist(offset, offset + 32);
+    this.ss.mixHash(this.re);
+  }
+  readS(message) {
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (this.rs) {
+      throw new Error('remote static public key is already set');
+    }
+    const cipherLength = 32 + (this.ss.cs.hasKey() ? 16 : 0);
+    if (message.byteLength < offset + cipherLength) {
+      throw new Error('message is not long enough');
+    }
+    const temp = message.sublist(offset, offset + cipherLength);
+    this.rs = this.ss.decryptAndHash(temp);
+    return cipherLength;
+  }
+  readEE() {
+    this.writeEE();
+  }
+  readES() {
+    this.writeES();
+  }
+  readSE() {
+    this.writeSE();
+  }
+}
+/**
+ * A IHandshakeState that's optimized for the XX pattern
+ */
+class XXHandshakeState extends AbstractHandshakeState {
+  // e
+  writeMessageA(payload) {
+    return new index.Uint8ArrayList(this.writeE(), this.ss.encryptAndHash(payload));
+  }
+  // e, ee, s, es
+  writeMessageB(payload) {
+    const e = this.writeE();
+    this.writeEE();
+    const encS = this.writeS();
+    this.writeES();
+    return new index.Uint8ArrayList(e, encS, this.ss.encryptAndHash(payload));
+  }
+  // s, se
+  writeMessageC(payload) {
+    const encS = this.writeS();
+    this.writeSE();
+    return new index.Uint8ArrayList(encS, this.ss.encryptAndHash(payload));
+  }
+  // e
+  readMessageA(message) {
+    try {
+      this.readE(message);
+      return this.ss.decryptAndHash(message.sublist(32));
+    } catch (e) {
+      throw new errors.InvalidCryptoExchangeError(`handshake stage 0 validation fail: ${e.message}`);
+    }
+  }
+  // e, ee, s, es
+  readMessageB(message) {
+    try {
+      this.readE(message);
+      this.readEE();
+      const consumed = this.readS(message, 32);
+      this.readES();
+      return this.ss.decryptAndHash(message.sublist(32 + consumed));
+    } catch (e) {
+      throw new errors.InvalidCryptoExchangeError(`handshake stage 1 validation fail: ${e.message}`);
+    }
+  }
+  // s, se
+  readMessageC(message) {
+    try {
+      const consumed = this.readS(message);
+      this.readSE();
+      return this.ss.decryptAndHash(message.sublist(consumed));
+    } catch (e) {
+      throw new errors.InvalidCryptoExchangeError(`handshake stage 2 validation fail: ${e.message}`);
+    }
+  }
+}
+function hashProtocolName(crypto, protocolName) {
+  if (protocolName.length <= 32) {
+    const h = alloc.alloc(32);
+    h.set(protocolName);
+    return h;
+  } else {
+    return crypto.hash(protocolName);
+  }
+}
+
+exports.AbstractHandshakeState = AbstractHandshakeState;
+exports.CipherState = CipherState;
+exports.SymmetricState = SymmetricState;
+exports.XXHandshakeState = XXHandshakeState;
+exports.ZEROLEN = ZEROLEN;

package/dist/cjs/node_modules/@chainsafe/libp2p-noise/dist/src/streaming.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var index = require('../../../../uint8arraylist/dist/src/index.js');
+var constants = require('./constants.js');
+var encoder = require('./encoder.js');
+
+const CHACHA_TAG_LENGTH = 16;
+// Returns generator that encrypts payload from the user
+function encryptStream(handshake, metrics) {
+  return async function* (source) {
+    for await (const chunk of source) {
+      for (let i = 0; i < chunk.length; i += constants.NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG) {
+        let end = i + constants.NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG;
+        if (end > chunk.length) {
+          end = chunk.length;
+        }
+        let data;
+        if (chunk instanceof Uint8Array) {
+          data = handshake.encrypt(chunk.subarray(i, end));
+        } else {
+          data = handshake.encrypt(chunk.sublist(i, end));
+        }
+        metrics?.encryptedPackets.increment();
+        yield new index.Uint8ArrayList(encoder.uint16BEEncode(data.byteLength), data);
+      }
+    }
+  };
+}
+// Decrypt received payload to the user
+function decryptStream(handshake, metrics) {
+  return async function* (source) {
+    for await (const chunk of source) {
+      for (let i = 0; i < chunk.length; i += constants.NOISE_MSG_MAX_LENGTH_BYTES) {
+        let end = i + constants.NOISE_MSG_MAX_LENGTH_BYTES;
+        if (end > chunk.length) {
+          end = chunk.length;
+        }
+        if (end - CHACHA_TAG_LENGTH < i) {
+          throw new Error('Invalid chunk');
+        }
+        const encrypted = chunk.sublist(i, end);
+        // memory allocation is not cheap so reuse the encrypted Uint8Array
+        // see https://github.com/ChainSafe/js-libp2p-noise/pull/242#issue-1422126164
+        // this is ok because chacha20 reads bytes one by one and don't reread after that
+        // it's also tested in https://github.com/ChainSafe/as-chacha20poly1305/pull/1/files#diff-25252846b58979dcaf4e41d47b3eadd7e4f335e7fb98da6c049b1f9cd011f381R48
+        const dst = chunk.subarray(i, end - CHACHA_TAG_LENGTH);
+        try {
+          const plaintext = handshake.decrypt(encrypted, dst);
+          metrics?.decryptedPackets.increment();
+          yield plaintext;
+        } catch (e) {
+          metrics?.decryptErrors.increment();
+          throw e;
+        }
+      }
+    }
+  };
+}
+
+exports.decryptStream = decryptStream;
+exports.encryptStream = encryptStream;

package/dist/cjs/node_modules/@chainsafe/libp2p-noise/dist/src/utils.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var index = require('../../../../@libp2p/crypto/dist/src/keys/index.js');
+var _interface = require('@libp2p/interface');
+var concat = require('../../../../uint8arrays/dist/src/concat.js');
+var fromString = require('../../../../uint8arrays/dist/src/from-string.js');
+var payload = require('./proto/payload.js');
+
+async function createHandshakePayload(privateKey, staticPublicKey, extensions) {
+  const identitySig = await privateKey.sign(getSignaturePayload(staticPublicKey));
+  return payload.NoiseHandshakePayload.encode({
+    identityKey: index.publicKeyToProtobuf(privateKey.publicKey),
+    identitySig,
+    extensions
+  });
+}
+async function decodeHandshakePayload(payloadBytes, remoteStaticKey, remoteIdentityKey) {
+  try {
+    const payload$1 = payload.NoiseHandshakePayload.decode(payloadBytes);
+    const publicKey = index.publicKeyFromProtobuf(payload$1.identityKey);
+    if (remoteIdentityKey?.equals(publicKey) === false) {
+      throw new Error(`Payload identity key ${publicKey} does not match expected remote identity key ${remoteIdentityKey}`);
+    }
+    if (!remoteStaticKey) {
+      throw new Error('Remote static does not exist');
+    }
+    const signaturePayload = getSignaturePayload(remoteStaticKey);
+    if (!(await publicKey.verify(signaturePayload, payload$1.identitySig))) {
+      throw new Error('Invalid payload signature');
+    }
+    return payload$1;
+  } catch (e) {
+    throw new _interface.UnexpectedPeerError(e.message);
+  }
+}
+function getSignaturePayload(publicKey) {
+  const prefix = fromString.fromString('noise-libp2p-static-key:');
+  if (publicKey instanceof Uint8Array) {
+    return concat.concat([prefix, publicKey], prefix.length + publicKey.length);
+  }
+  publicKey.prepend(prefix);
+  return publicKey;
+}
+
+exports.createHandshakePayload = createHandshakePayload;
+exports.decodeHandshakePayload = decodeHandshakePayload;
+exports.getSignaturePayload = getSignaturePayload;

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

@@ -0,0 +1,40 @@
+'use strict';
+
+var _interface = require('@libp2p/interface');
+var constants = require('./constants.js');
+
+const defaultConfig = {
+  enableKeepAlive: true,
+  keepAliveInterval: 30_000,
+  maxInboundStreams: 1_000,
+  maxOutboundStreams: 1_000,
+  initialStreamWindowSize: constants.INITIAL_STREAM_WINDOW,
+  maxStreamWindowSize: constants.MAX_STREAM_WINDOW,
+  maxMessageSize: 64 * 1024
+};
+function verifyConfig(config) {
+  if (config.keepAliveInterval <= 0) {
+    throw new _interface.InvalidParametersError('keep-alive interval must be positive');
+  }
+  if (config.maxInboundStreams < 0) {
+    throw new _interface.InvalidParametersError('max inbound streams must be larger or equal 0');
+  }
+  if (config.maxOutboundStreams < 0) {
+    throw new _interface.InvalidParametersError('max outbound streams must be larger or equal 0');
+  }
+  if (config.initialStreamWindowSize < constants.INITIAL_STREAM_WINDOW) {
+    throw new _interface.InvalidParametersError('InitialStreamWindowSize must be larger or equal 256 kB');
+  }
+  if (config.maxStreamWindowSize < config.initialStreamWindowSize) {
+    throw new _interface.InvalidParametersError('MaxStreamWindowSize must be larger than the InitialStreamWindowSize');
+  }
+  if (config.maxStreamWindowSize > 2 ** 32 - 1) {
+    throw new _interface.InvalidParametersError('MaxStreamWindowSize must be less than equal MAX_UINT32');
+  }
+  if (config.maxMessageSize < 1024) {
+    throw new _interface.InvalidParametersError('MaxMessageSize must be greater than a kilobyte');
+  }
+}
+
+exports.defaultConfig = defaultConfig;
+exports.verifyConfig = verifyConfig;

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var errors = require('./errors.js');
+
+// Protocol violation errors
+const PROTOCOL_ERRORS = new Set([errors.InvalidFrameError.name, errors.UnrequestedPingError.name, errors.NotMatchingPingError.name, errors.StreamAlreadyExistsError.name, errors.DecodeInvalidVersionError.name, errors.BothClientsError.name, errors.ReceiveWindowExceededError.name]);
+/**
+ * INITIAL_STREAM_WINDOW is the initial stream window size.
+ *
+ * Not an implementation choice, this is defined in the specification
+ */
+const INITIAL_STREAM_WINDOW = 256 * 1024;
+/**
+ * Default max stream window
+ */
+const MAX_STREAM_WINDOW = 16 * 1024 * 1024;
+
+exports.INITIAL_STREAM_WINDOW = INITIAL_STREAM_WINDOW;
+exports.MAX_STREAM_WINDOW = MAX_STREAM_WINDOW;
+exports.PROTOCOL_ERRORS = PROTOCOL_ERRORS;

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

@@ -0,0 +1,142 @@
+'use strict';
+
+var index = require('../../../../uint8arraylist/dist/src/index.js');
+var errors = require('./errors.js');
+var frame = require('./frame.js');
+
+// used to bitshift in decoding
+// native bitshift can overflow into a negative number, so we bitshift by multiplying by a power of 2
+const twoPow24 = 2 ** 24;
+/**
+ * Decode a header from the front of a buffer
+ *
+ * @param data - Assumed to have enough bytes for a header
+ */
+function decodeHeader(data) {
+  if (data[0] !== frame.YAMUX_VERSION) {
+    throw new errors.InvalidFrameError('Invalid frame version');
+  }
+  return {
+    type: data[1],
+    flag: (data[2] << 8) + data[3],
+    streamID: data[4] * twoPow24 + (data[5] << 16) + (data[6] << 8) + data[7],
+    length: data[8] * twoPow24 + (data[9] << 16) + (data[10] << 8) + data[11]
+  };
+}
+/**
+ * Decodes yamux frames from a source
+ */
+class Decoder {
+  source;
+  /** Buffer for in-progress frames */
+  buffer;
+  /** Used to sanity check against decoding while in an inconsistent state */
+  frameInProgress;
+  constructor(source) {
+    // Normally, when entering a for-await loop with an iterable/async iterable, the only ways to exit the loop are:
+    // 1. exhaust the iterable
+    // 2. throw an error - slow, undesirable if there's not actually an error
+    // 3. break or return - calls the iterable's `return` method, finalizing the iterable, no more iteration possible
+    //
+    // In this case, we want to enter (and exit) a for-await loop per chunked data frame and continue processing the iterable.
+    // To do this, we strip the `return` method from the iterator and can now `break` early and continue iterating.
+    // Exiting the main for-await is still possible via 1. and 2.
+    this.source = returnlessSource(source);
+    this.buffer = new index.Uint8ArrayList();
+    this.frameInProgress = false;
+  }
+  /**
+   * Emits frames from the decoder source.
+   *
+   * Note: If `readData` is emitted, it _must_ be called before the next iteration
+   * Otherwise an error is thrown
+   */
+  async *emitFrames() {
+    for await (const chunk of this.source) {
+      this.buffer.append(chunk);
+      // Loop to consume as many bytes from the buffer as possible
+      // Eg: when a single chunk contains several frames
+      while (true) {
+        const header = this.readHeader();
+        if (header === undefined) {
+          break;
+        }
+        const {
+          type,
+          length
+        } = header;
+        if (type === frame.FrameType.Data) {
+          // This is a data frame, the frame body must still be read
+          // `readData` must be called before the next iteration here
+          this.frameInProgress = true;
+          yield {
+            header,
+            readData: this.readBytes.bind(this, length)
+          };
+        } else {
+          yield {
+            header
+          };
+        }
+      }
+    }
+  }
+  readHeader() {
+    // Sanity check to ensure a header isn't read when another frame is partially decoded
+    // In practice this shouldn't happen
+    if (this.frameInProgress) {
+      throw new errors.InvalidStateError('decoding frame already in progress');
+    }
+    if (this.buffer.length < frame.HEADER_LENGTH) {
+      // not enough data yet
+      return;
+    }
+    const header = decodeHeader(this.buffer.subarray(0, frame.HEADER_LENGTH));
+    this.buffer.consume(frame.HEADER_LENGTH);
+    return header;
+  }
+  async readBytes(length) {
+    if (this.buffer.length < length) {
+      for await (const chunk of this.source) {
+        this.buffer.append(chunk);
+        if (this.buffer.length >= length) {
+          // see note above, the iterator is not `return`ed here
+          break;
+        }
+      }
+    }
+    const out = this.buffer.sublist(0, length);
+    this.buffer.consume(length);
+    // The next frame can now be decoded
+    this.frameInProgress = false;
+    return out;
+  }
+}
+/**
+ * Strip the `return` method from a `Source`
+ */
+function returnlessSource(source) {
+  if (source[Symbol.iterator] !== undefined) {
+    const iterator = source[Symbol.iterator]();
+    iterator.return = undefined;
+    return {
+      [Symbol.iterator]() {
+        return iterator;
+      }
+    };
+  } else if (source[Symbol.asyncIterator] !== undefined) {
+    const iterator = source[Symbol.asyncIterator]();
+    iterator.return = undefined;
+    return {
+      [Symbol.asyncIterator]() {
+        return iterator;
+      }
+    };
+  } else {
+    throw new Error('a source must be either an iterable or an async iterable');
+  }
+}
+
+exports.Decoder = Decoder;
+exports.decodeHeader = decodeHeader;
+exports.returnlessSource = returnlessSource;

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var frame = require('./frame.js');
+
+function encodeHeader(header) {
+  const frame$1 = new Uint8Array(frame.HEADER_LENGTH);
+  // always assume version 0
+  // frameView.setUint8(0, header.version)
+  frame$1[1] = header.type;
+  frame$1[2] = header.flag >>> 8;
+  frame$1[3] = header.flag;
+  frame$1[4] = header.streamID >>> 24;
+  frame$1[5] = header.streamID >>> 16;
+  frame$1[6] = header.streamID >>> 8;
+  frame$1[7] = header.streamID;
+  frame$1[8] = header.length >>> 24;
+  frame$1[9] = header.length >>> 16;
+  frame$1[10] = header.length >>> 8;
+  frame$1[11] = header.length;
+  return frame$1;
+}
+
+exports.encodeHeader = encodeHeader;

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

@@ -0,0 +1,75 @@
+'use strict';
+
+class InvalidFrameError extends Error {
+  static name = 'InvalidFrameError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'The frame was invalid';
+    super(message);
+    this.name = 'InvalidFrameError';
+  }
+}
+class UnrequestedPingError extends Error {
+  static name = 'UnrequestedPingError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Unrequested ping error';
+    super(message);
+    this.name = 'UnrequestedPingError';
+  }
+}
+class NotMatchingPingError extends Error {
+  static name = 'NotMatchingPingError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Unrequested ping error';
+    super(message);
+    this.name = 'NotMatchingPingError';
+  }
+}
+class InvalidStateError extends Error {
+  static name = 'InvalidStateError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Invalid state';
+    super(message);
+    this.name = 'InvalidStateError';
+  }
+}
+class StreamAlreadyExistsError extends Error {
+  static name = 'StreamAlreadyExistsError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Strean already exists';
+    super(message);
+    this.name = 'StreamAlreadyExistsError';
+  }
+}
+class DecodeInvalidVersionError extends Error {
+  static name = 'DecodeInvalidVersionError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Decode invalid version';
+    super(message);
+    this.name = 'DecodeInvalidVersionError';
+  }
+}
+class BothClientsError extends Error {
+  static name = 'BothClientsError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Both clients';
+    super(message);
+    this.name = 'BothClientsError';
+  }
+}
+class ReceiveWindowExceededError extends Error {
+  static name = 'ReceiveWindowExceededError';
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Receive window exceeded';
+    super(message);
+    this.name = 'ReceiveWindowExceededError';
+  }
+}
+
+exports.BothClientsError = BothClientsError;
+exports.DecodeInvalidVersionError = DecodeInvalidVersionError;
+exports.InvalidFrameError = InvalidFrameError;
+exports.InvalidStateError = InvalidStateError;
+exports.NotMatchingPingError = NotMatchingPingError;
+exports.ReceiveWindowExceededError = ReceiveWindowExceededError;
+exports.StreamAlreadyExistsError = StreamAlreadyExistsError;
+exports.UnrequestedPingError = UnrequestedPingError;