@dashevo/wasm-dpp 0.23.0-dev.10

package/test/unit/stateTransition/validation/validateStateTransitionIdentitySignatureFactory.spec.js

@@ -0,0 +1,339 @@
+const validateStateTransitionSignatureFactory = require('../../../../lib/stateTransition/validation/validateStateTransitionIdentitySignatureFactory');
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+const IdentityPublicKey = require('../../../../lib/identity/IdentityPublicKey');
+const InvalidStateTransitionSignatureError = require('../../../../lib/errors/consensus/signature/InvalidStateTransitionSignatureError');
+const MissingPublicKeyError = require('../../../../lib/errors/consensus/signature/MissingPublicKeyError');
+const generateRandomIdentifier = require('../../../../lib/test/utils/generateRandomIdentifier');
+
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+const stateTransitionTypes = require('../../../../lib/stateTransition/stateTransitionTypes');
+const StateTransitionExecutionContext = require('../../../../lib/stateTransition/StateTransitionExecutionContext');
+const PublicKeyIsDisabledConsensusError = require('../../../../lib/errors/consensus/signature/PublicKeyIsDisabledError');
+const WrongPublicKeyPurposeConsensusError = require('../../../../lib/errors/consensus/signature/WrongPublicKeyPurposeError');
+const PublicKeySecurityLevelNotMetConsensusError = require('../../../../lib/errors/consensus/signature/PublicKeySecurityLevelNotMetError');
+const InvalidSignaturePublicKeySecurityLevelConsensusError = require('../../../../lib/errors/consensus/signature/InvalidSignaturePublicKeySecurityLevelError');
+const InvalidIdentityPublicKeyTypeConsensusError = require('../../../../lib/errors/consensus/signature/InvalidIdentityPublicKeyTypeError');
+const InvalidSignaturePublicKeySecurityLevelError = require('../../../../lib/stateTransition/errors/InvalidSignaturePublicKeySecurityLevelError');
+const PublicKeySecurityLevelNotMetError = require('../../../../lib/stateTransition/errors/PublicKeySecurityLevelNotMetError');
+const WrongPublicKeyPurposeError = require('../../../../lib/stateTransition/errors/WrongPublicKeyPurposeError');
+const PublicKeyIsDisabledError = require('../../../../lib/stateTransition/errors/PublicKeyIsDisabledError');
+const DPPError = require('../../../../lib/errors/DPPError');
+const createStateRepositoryMock = require('../../../../lib/test/mocks/createStateRepositoryMock');
+const IdentityNotFoundError = require('../../../../lib/errors/consensus/signature/IdentityNotFoundError');
+
+describe('validateStateTransitionIdentitySignatureFactory', () => {
+  let validateStateTransitionIdentitySignature;
+  let stateTransition;
+  let ownerId;
+  let identity;
+  let identityPublicKey;
+  let publicKeyId;
+  let executionContext;
+  let stateRepositoryMock;
+
+  beforeEach(function beforeEach() {
+    executionContext = new StateTransitionExecutionContext();
+
+    ownerId = generateRandomIdentifier();
+    publicKeyId = 1;
+    stateTransition = {
+      verifySignature: this.sinonSandbox.stub().returns(true),
+      getSignaturePublicKeyId: this.sinonSandbox.stub().returns(publicKeyId),
+      getSignature: this.sinonSandbox.stub(),
+      getOwnerId: this.sinonSandbox.stub().returns(ownerId),
+      getType: this.sinonSandbox.stub().returns(stateTransitionTypes.IDENTITY_CREATE),
+      getExecutionContext: this.sinonSandbox.stub().returns(executionContext),
+    };
+
+    identityPublicKey = {
+      getType: this.sinonSandbox.stub().returns(IdentityPublicKey.TYPES.ECDSA_SECP256K1),
+      getSecurityLevel: this.sinonSandbox.stub(),
+      getId: this.sinonSandbox.stub().returns(publicKeyId),
+    };
+
+    const getPublicKeyById = this.sinonSandbox.stub().returns(identityPublicKey);
+
+    identity = {
+      getPublicKeyById,
+      getId: this.sinonSandbox.stub().returns(ownerId),
+    };
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchIdentity.resolves(identity);
+
+    validateStateTransitionIdentitySignature = validateStateTransitionSignatureFactory(
+      stateRepositoryMock,
+    );
+  });
+
+  it('should pass properly signed state transition', async () => {
+    const result = await validateStateTransitionIdentitySignature(
+      stateTransition,
+    );
+
+    expect(result).to.be.instanceOf(ValidationResult);
+
+    expect(result.isValid()).to.be.true();
+    expect(result.getErrors()).to.be.an('array');
+    expect(result.getErrors()).to.be.empty();
+
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      ownerId,
+      new StateTransitionExecutionContext(),
+    );
+    expect(identity.getPublicKeyById).to.be.calledOnceWithExactly(publicKeyId);
+    expect(identityPublicKey.getType).to.be.calledTwice();
+    expect(stateTransition.getSignaturePublicKeyId).to.be.calledOnce();
+    expect(stateTransition.verifySignature).to.be.calledOnceWithExactly(identityPublicKey);
+    expect(stateTransition.getOwnerId).to.be.calledOnceWithExactly();
+  });
+
+  it('should return invalid result if owner id doesn\'t exist', async () => {
+    stateRepositoryMock.fetchIdentity.resolves(null);
+
+    const result = await validateStateTransitionIdentitySignature(
+      stateTransition,
+    );
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(IdentityNotFoundError);
+    expect(error.getCode()).to.equal(2000);
+    expect(Buffer.isBuffer(error.getIdentityId())).to.be.true();
+    expect(error.getIdentityId()).to.deep.equal(identity.getId().toBuffer());
+
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      ownerId,
+      new StateTransitionExecutionContext(),
+    );
+    expect(identity.getPublicKeyById).to.not.be.called();
+    expect(identityPublicKey.getType).to.not.be.called();
+    expect(stateTransition.getSignaturePublicKeyId).to.not.be.called();
+    expect(stateTransition.verifySignature).to.not.be.called();
+    expect(stateTransition.getOwnerId).to.be.calledOnceWithExactly();
+  });
+
+  it("should return MissingPublicKeyError if the identity doesn't have a matching public key", async () => {
+    const type = IdentityPublicKey.TYPES.ECDSA_SECP256K1 + 1;
+    identityPublicKey.getType.returns(type);
+    identity.getPublicKeyById.returns(undefined);
+
+    const result = await validateStateTransitionIdentitySignature(
+      stateTransition,
+    );
+
+    expect(result).to.be.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.false();
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      ownerId,
+      new StateTransitionExecutionContext(),
+    );
+    expect(identity.getPublicKeyById).to.be.calledOnceWithExactly(publicKeyId);
+    expect(stateTransition.getSignaturePublicKeyId).to.be.calledTwice();
+    expect(stateTransition.verifySignature).to.not.be.called();
+
+    expect(result.getErrors()).to.be.an('array');
+    expect(result.getErrors()).to.have.lengthOf(1);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.instanceOf(MissingPublicKeyError);
+    expect(error.getPublicKeyId()).to.equal(publicKeyId);
+  });
+
+  it('should return InvalidIdentityPublicKeyTypeError if type is not exist', async () => {
+    const type = Math.max(...Object.values(IdentityPublicKey.TYPES)) + 1;
+    identityPublicKey.getType.returns(type);
+
+    const result = await validateStateTransitionIdentitySignature(
+      stateTransition,
+    );
+
+    expect(result).to.be.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.false();
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      ownerId,
+      new StateTransitionExecutionContext(),
+    );
+    expect(identity.getPublicKeyById).to.be.calledOnceWithExactly(publicKeyId);
+    expect(identityPublicKey.getType).to.be.calledTwice();
+    expect(stateTransition.getSignaturePublicKeyId).to.be.calledOnce();
+    expect(stateTransition.verifySignature).to.not.be.called();
+
+    expect(result.getErrors()).to.be.an('array');
+    expect(result.getErrors()).to.have.lengthOf(1);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.instanceOf(InvalidIdentityPublicKeyTypeConsensusError);
+    expect(error.getPublicKeyType()).to.equal(type);
+  });
+
+  it('should return InvalidStateTransitionSignatureError if signature is invalid', async () => {
+    stateTransition.verifySignature.resolves(false);
+
+    const result = await validateStateTransitionIdentitySignature(
+      stateTransition,
+    );
+
+    expect(result).to.be.instanceOf(ValidationResult);
+
+    expect(result.isValid()).to.be.false();
+    expect(result.getErrors()).to.be.an('array');
+    expect(result.getErrors()).to.have.lengthOf(1);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.instanceOf(InvalidStateTransitionSignatureError);
+
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      ownerId,
+      new StateTransitionExecutionContext(),
+    );
+    expect(identity.getPublicKeyById).to.be.calledOnceWithExactly(publicKeyId);
+    expect(identityPublicKey.getType).to.be.calledTwice();
+    expect(stateTransition.getSignaturePublicKeyId).to.be.calledOnce();
+    expect(stateTransition.verifySignature).to.be.calledOnceWithExactly(identityPublicKey);
+  });
+
+  describe('Consensus errors', () => {
+    it('should return InvalidSignaturePublicKeySecurityLevelConsensusError if InvalidSignaturePublicKeySecurityLevelError was thrown', async () => {
+      const e = new InvalidSignaturePublicKeySecurityLevelError(1, 0);
+
+      stateTransition.verifySignature.throws(e);
+
+      const result = await validateStateTransitionIdentitySignature(
+        stateTransition,
+      );
+
+      expect(result).to.be.instanceOf(ValidationResult);
+
+      expect(result.isValid()).to.be.false();
+      expect(result.getErrors()).to.be.an('array');
+      expect(result.getErrors()).to.have.lengthOf(1);
+
+      const [error] = result.getErrors();
+      expect(error).to.be.instanceOf(InvalidSignaturePublicKeySecurityLevelConsensusError);
+      expect(error.getPublicKeySecurityLevel()).to.equal(1);
+      expect(error.getKeySecurityLevelRequirement()).to.equal(0);
+    });
+
+    it('should return PublicKeySecurityLevelNotMetConsensusError if PublicKeySecurityLevelNotMetError was thrown', async () => {
+      const e = new PublicKeySecurityLevelNotMetError(1, 2);
+
+      stateTransition.verifySignature.throws(e);
+
+      const result = await validateStateTransitionIdentitySignature(
+        stateTransition,
+      );
+
+      expect(result).to.be.instanceOf(ValidationResult);
+
+      expect(result.isValid()).to.be.false();
+      expect(result.getErrors()).to.be.an('array');
+      expect(result.getErrors()).to.have.lengthOf(1);
+
+      const [error] = result.getErrors();
+      expect(error).to.be.instanceOf(PublicKeySecurityLevelNotMetConsensusError);
+      expect(error.getPublicKeySecurityLevel()).to.equal(1);
+      expect(error.getKeySecurityLevelRequirement()).to.equal(2);
+    });
+
+    it('should return WrongPublicKeyPurposeConsensusError if WrongPublicKeyPurposeError was thrown', async () => {
+      const e = new WrongPublicKeyPurposeError(4, 2);
+
+      stateTransition.verifySignature.throws(e);
+
+      const result = await validateStateTransitionIdentitySignature(
+        stateTransition,
+      );
+
+      expect(result).to.be.instanceOf(ValidationResult);
+
+      expect(result.isValid()).to.be.false();
+      expect(result.getErrors()).to.be.an('array');
+      expect(result.getErrors()).to.have.lengthOf(1);
+
+      const [error] = result.getErrors();
+      expect(error).to.be.instanceOf(WrongPublicKeyPurposeConsensusError);
+
+      expect(error.getPublicKeyPurpose()).to.equal(4);
+      expect(error.getKeyPurposeRequirement()).to.equal(2);
+    });
+
+    it('should return PublicKeyIsDisabledConsensusError if PublicKeyIsDisabledError was thrown', async () => {
+      const e = new PublicKeyIsDisabledError(identityPublicKey);
+
+      stateTransition.verifySignature.throws(e);
+
+      const result = await validateStateTransitionIdentitySignature(
+        stateTransition,
+      );
+
+      expect(result).to.be.instanceOf(ValidationResult);
+
+      expect(result.isValid()).to.be.false();
+      expect(result.getErrors()).to.be.an('array');
+      expect(result.getErrors()).to.have.lengthOf(1);
+
+      const [error] = result.getErrors();
+      expect(error).to.be.instanceOf(PublicKeyIsDisabledConsensusError);
+      expect(error.getPublicKeyId()).to.deep.equal(publicKeyId);
+    });
+
+    it('should return InvalidStateTransitionSignatureError if DPPError was thrown', async () => {
+      const e = new DPPError('Dpp error');
+
+      stateTransition.verifySignature.throws(e);
+
+      const result = await validateStateTransitionIdentitySignature(
+        stateTransition,
+      );
+
+      expect(result).to.be.instanceOf(ValidationResult);
+
+      expect(result.isValid()).to.be.false();
+      expect(result.getErrors()).to.be.an('array');
+      expect(result.getErrors()).to.have.lengthOf(1);
+
+      const [error] = result.getErrors();
+      expect(error).to.be.instanceOf(InvalidStateTransitionSignatureError);
+    });
+
+    it('should throw unknown error', async () => {
+      const e = new Error('unknown error');
+
+      stateTransition.verifySignature.throws(e);
+
+      try {
+        await validateStateTransitionIdentitySignature(
+          stateTransition,
+        );
+
+        expect.fail('should throw an error');
+      } catch (error) {
+        expect(error).to.equal(e);
+      }
+    });
+
+    it('should not verify signature on dry run', async () => {
+      const e = new DPPError('Dpp error');
+
+      stateTransition.verifySignature.throws(e);
+
+      executionContext.enableDryRun();
+
+      const result = await validateStateTransitionIdentitySignature(
+        stateTransition,
+      );
+
+      executionContext.disableDryRun();
+
+      expect(result.isValid()).to.be.true();
+      expect(result.getErrors()).to.be.an('array');
+      expect(result.getErrors()).to.be.empty();
+    });
+  });
+});

package/test/unit/stateTransition/validation/validateStateTransitionKeySignatureFactory.spec.js

@@ -0,0 +1,86 @@
+const validateStateTransitionKeySignatureFactory = require('../../../../lib/stateTransition/validation/validateStateTransitionKeySignatureFactory');
+
+const getIdentityCreateTransitionFixture = require('../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+const InvalidStateTransitionSignatureError = require('../../../../lib/errors/consensus/signature/InvalidStateTransitionSignatureError');
+
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+const StateTransitionExecutionContext = require('../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('validateStateTransitionKeySignatureFactory', () => {
+  let publicKeyHash;
+  let stateTransition;
+  let stateTransitionHash;
+  let verifyHashSignatureMock;
+  let validateStateTransitionKeySignature;
+  let fetchAssetLockPublicKeyHashMock;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    publicKeyHash = Buffer.alloc(20).fill(1);
+
+    stateTransition = getIdentityCreateTransitionFixture();
+    stateTransitionHash = stateTransition.hash({ skipSignature: true });
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    verifyHashSignatureMock = this.sinonSandbox.stub();
+
+    fetchAssetLockPublicKeyHashMock = this.sinonSandbox.stub().resolves(publicKeyHash);
+
+    validateStateTransitionKeySignature = validateStateTransitionKeySignatureFactory(
+      verifyHashSignatureMock,
+      fetchAssetLockPublicKeyHashMock,
+    );
+  });
+
+  it('should return invalid result if signature is not valid', async () => {
+    verifyHashSignatureMock.returns(false);
+
+    const result = await validateStateTransitionKeySignature(
+      stateTransition,
+    );
+
+    expectValidationError(result, InvalidStateTransitionSignatureError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(2002);
+
+    expect(fetchAssetLockPublicKeyHashMock).to.be.calledOnceWithExactly(
+      stateTransition.getAssetLockProof(),
+      executionContext,
+    );
+
+    expect(verifyHashSignatureMock).to.be.calledOnceWithExactly(
+      stateTransitionHash,
+      stateTransition.getSignature(),
+      publicKeyHash,
+    );
+  });
+
+  it('should return valid result if signature is valid', async () => {
+    verifyHashSignatureMock.returns(true);
+
+    const result = await validateStateTransitionKeySignature(
+      stateTransition,
+    );
+
+    expect(result).to.be.instanceof(ValidationResult);
+    expect(result.isValid()).to.be.true();
+
+    expect(fetchAssetLockPublicKeyHashMock).to.be.calledOnceWithExactly(
+      stateTransition.getAssetLockProof(),
+      executionContext,
+    );
+
+    expect(verifyHashSignatureMock).to.be.calledOnceWithExactly(
+      stateTransitionHash,
+      stateTransition.getSignature(),
+      publicKeyHash,
+    );
+  });
+});

package/test/unit/stateTransition/validation/validateStateTransitionStateFactory.spec.js

@@ -0,0 +1,89 @@
+const stateTransitionTypes = require('../../../../lib/stateTransition/stateTransitionTypes');
+
+const validateStateTransitionStateFactory = require('../../../../lib/stateTransition/validation/validateStateTransitionStateFactory');
+
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+
+const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+
+const DataContractFactory = require('../../../../lib/dataContract/DataContractFactory');
+
+const InvalidStateTransitionTypeError = require('../../../../lib/stateTransition/errors/InvalidStateTransitionTypeError');
+const createDPPMock = require('../../../../lib/test/mocks/createDPPMock');
+const SomeConsensusError = require('../../../../lib/test/mocks/SomeConsensusError');
+
+describe('validateStateTransitionStateFactory', () => {
+  let validateDataContractSTDataMock;
+  let validateStateTransitionState;
+  let stateTransition;
+
+  beforeEach(function beforeEach() {
+    validateDataContractSTDataMock = this.sinonSandbox.stub();
+
+    const dataContractFactory = new DataContractFactory(createDPPMock(), undefined);
+
+    const dataContract = getDataContractFixture();
+    stateTransition = dataContractFactory.createDataContractCreateTransition(dataContract);
+
+    validateStateTransitionState = validateStateTransitionStateFactory({
+      [stateTransitionTypes.DATA_CONTRACT_CREATE]: validateDataContractSTDataMock,
+    });
+  });
+
+  it('should return invalid result if State Transition type is invalid', async () => {
+    const rawStateTransition = {};
+    stateTransition = {
+      getType() {
+        return 4343;
+      },
+      toObject() {
+        return rawStateTransition;
+      },
+    };
+
+    try {
+      await validateStateTransitionState(stateTransition);
+
+      expect.fail('should throw InvalidStateTransitionTypeError');
+    } catch (e) {
+      expect(e).to.be.instanceOf(InvalidStateTransitionTypeError);
+      expect(e.getType()).to.equal(stateTransition.getType());
+
+      expect(validateDataContractSTDataMock).to.not.be.called();
+    }
+  });
+
+  it('should return invalid result if Data Contract State Transition is not valid', async () => {
+    const dataContractError = new SomeConsensusError('test');
+    const dataContractResult = new ValidationResult([
+      dataContractError,
+    ]);
+
+    validateDataContractSTDataMock.resolves(dataContractResult);
+
+    const result = await validateStateTransitionState(stateTransition);
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.equal(dataContractError);
+
+    expect(validateDataContractSTDataMock).to.be.calledOnceWith(stateTransition);
+  });
+
+  it('should return valid result', async () => {
+    const dataContractResult = new ValidationResult();
+
+    validateDataContractSTDataMock.resolves(dataContractResult);
+
+    const result = await validateStateTransitionState(stateTransition);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+
+    expect(validateDataContractSTDataMock).to.be.calledOnceWith(stateTransition);
+  });
+});

package/test/unit/version/validateProtocolVersionFactory.spec.js

@@ -0,0 +1,80 @@
+const UnsupportedProtocolVersionError = require('../../../lib/errors/consensus/basic/UnsupportedProtocolVersionError');
+const CompatibleProtocolVersionIsNotDefinedError = require('../../../lib/errors/CompatibleProtocolVersionIsNotDefinedError');
+const IncompatibleProtocolVersionError = require('../../../lib/errors/consensus/basic/IncompatibleProtocolVersionError');
+
+const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
+const validateProtocolVersionFactory = require('../../../lib/version/validateProtocolVersionFactory');
+
+const { expectValidationError } = require('../../../lib/test/expect/expectError');
+const { latestVersion } = require('../../../lib/version/protocolVersion');
+
+describe('validateProtocolVersionFactory', () => {
+  let validateProtocolVersion;
+  let dppMock;
+  let versionCompatibilityMap;
+  let currentProtocolVersion;
+  let protocolVersion;
+
+  beforeEach(function beforeEach() {
+    protocolVersion = 1;
+    currentProtocolVersion = 1;
+
+    dppMock = createDPPMock(this.sinonSandbox);
+    dppMock.getProtocolVersion.returns(currentProtocolVersion);
+
+    versionCompatibilityMap = {
+      1: 1,
+    };
+
+    validateProtocolVersion = validateProtocolVersionFactory(
+      dppMock,
+      versionCompatibilityMap,
+    );
+  });
+
+  it('should throw UnsupportedProtocolVersionError if protocolVersion is higher than latestVersion', () => {
+    protocolVersion = latestVersion + 1;
+
+    const result = validateProtocolVersion(protocolVersion);
+
+    expectValidationError(result, UnsupportedProtocolVersionError);
+
+    const error = result.getFirstError();
+
+    expect(error.getParsedProtocolVersion()).to.equal(protocolVersion);
+    expect(error.getLatestVersion()).to.equal(latestVersion);
+    expect(error.getCode()).to.equal(1002);
+  });
+
+  it('should throw CompatibleProtocolVersionIsNotDefinedError if compatible version is not'
+    + ' defined for the current protocol version', () => {
+    delete versionCompatibilityMap[currentProtocolVersion.toString()];
+
+    try {
+      validateProtocolVersion(protocolVersion);
+
+      expect.fail('should throw CompatibleProtocolVersionIsNotDefinedError');
+    } catch (e) {
+      expect(e).to.be.an.instanceOf(CompatibleProtocolVersionIsNotDefinedError);
+    }
+  });
+
+  it('should throw IncompatibleProtocolVersionError if parsed version is lower than compatible one', () => {
+    const minimalProtocolVersion = 1;
+
+    protocolVersion = 0;
+    currentProtocolVersion = 5;
+
+    versionCompatibilityMap[currentProtocolVersion.toString()] = minimalProtocolVersion;
+
+    const result = validateProtocolVersion(protocolVersion);
+
+    expectValidationError(result, IncompatibleProtocolVersionError);
+
+    const error = result.getFirstError();
+
+    expect(error.getParsedProtocolVersion()).to.equal(protocolVersion);
+    expect(error.getMinimalProtocolVersion()).to.equal(minimalProtocolVersion);
+    expect(error.getCode()).to.equal(1003);
+  });
+});

package/webpack.config.js

@@ -0,0 +1,49 @@
+const path = require('path');
+const webpack = require('webpack');
+
+const commonJSConfig = {
+  entry: ['core-js/stable', './lib/DashPlatformProtocol.js'],
+  mode: 'production',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'DashPlatformProtocol.min.js',
+    library: 'DashPlatformProtocol',
+    libraryTarget: 'umd',
+  },
+  resolve: {
+    fallback: {
+      fs: false,
+      ws: false,
+      crypto: require.resolve('crypto-browserify'),
+      http: require.resolve('stream-http'),
+      https: require.resolve('https-browserify'),
+      stream: require.resolve('stream-browserify'),
+      path: require.resolve('path-browserify'),
+      url: require.resolve('url/'),
+      util: require.resolve('util/'),
+      buffer: require.resolve('buffer/'),
+      events: require.resolve('events/'),
+      assert: require.resolve('assert/'),
+      string_decoder: require.resolve('string_decoder/'),
+    },
+  },
+  plugins: [
+    new webpack.ProvidePlugin({
+      Buffer: [require.resolve('buffer/'), 'Buffer'],
+      process: require.resolve('process/browser'),
+    }),
+  ],
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /(node_modules)/,
+        use: {
+          loader: 'babel-loader',
+        },
+      },
+    ],
+  },
+};
+
+module.exports = [commonJSConfig];