@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.14

package/test/unit/stateTransition/StateTransitionFactory.spec.js

@@ -1,159 +1,107 @@
-const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-
-const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const InvalidStateTransitionError = require('@dashevo/dpp/lib/stateTransition/errors/InvalidStateTransitionError');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const SerializedObjectParsingError = require('@dashevo/dpp/lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+const { default: loadWasmDpp } = require('../../../dist');
+const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
 
-const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
-const StateTransitionFactory = require('@dashevo/dpp/lib/stateTransition/StateTransitionFactory');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
+describe('StateTransitionFactory', function main() {
+  this.timeout(100000);
 
-describe('StateTransitionFactory', () => {
-  let validateStateTransitionBasicMock;
-  let createStateTransitionMock;
   let factory;
   let stateTransition;
   let rawStateTransition;
-  let decodeProtocolEntityMock;
-  let dppMock;
+  let stateRepositoryMock;
+  let StateTransitionFactory;
+  let DataContractCreateTransition;
+  let InvalidStateTransitionError;
+  let MissingStateTransitionTypeError;
+
+  before(async () => {
+    ({
+      DataContractCreateTransition,
+      StateTransitionFactory,
+      InvalidStateTransitionError,
+      MissingStateTransitionTypeError,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
+  beforeEach(async function beforeEach() {
     const dataContract = getDataContractFixture();
 
+    const rawDataContract = dataContract.toObject();
+
     stateTransition = new DataContractCreateTransition({
-      dataContract: dataContract.toObject(),
+      protocolVersion: protocolVersion.latestVersion,
+      dataContract: rawDataContract,
       entropy: dataContract.getEntropy(),
+      signature: Buffer.alloc(65),
+      signaturePublicKeyId: 0,
     });
     rawStateTransition = stateTransition.toObject();
 
-    decodeProtocolEntityMock = this.sinonSandbox.stub();
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    validateStateTransitionBasicMock = this.sinonSandbox.stub();
-    createStateTransitionMock = this.sinonSandbox.stub().returns(stateTransition);
-
-    dppMock = createDPPMock();
+    const blsAdapter = await getBlsAdapterMock();
 
     factory = new StateTransitionFactory(
-      validateStateTransitionBasicMock,
-      createStateTransitionMock,
-      dppMock,
-      decodeProtocolEntityMock,
+      stateRepositoryMock,
+      blsAdapter,
     );
   });
 
   describe('createFromObject', () => {
     it('should return new State Transition with data from passed object', async () => {
-      validateStateTransitionBasicMock.returns(new ValidationResult());
-
       const result = await factory.createFromObject(rawStateTransition);
 
-      expect(result).to.equal(stateTransition);
-
-      expect(validateStateTransitionBasicMock).to.have.been.calledOnceWith(rawStateTransition);
-
-      expect(createStateTransitionMock).to.have.been.calledOnceWith(rawStateTransition);
+      expect(result.toObject()).to.deep.equal(stateTransition.toObject());
     });
 
     it('should return new State Transition without validation if "skipValidation" option is passed', async () => {
       const result = await factory.createFromObject(rawStateTransition, { skipValidation: true });
 
-      expect(result).to.equal(stateTransition);
-
-      expect(validateStateTransitionBasicMock).to.have.not.been.called();
-
-      expect(createStateTransitionMock).to.have.been.calledOnceWith(rawStateTransition);
+      expect(result.toObject()).to.deep.equal(stateTransition.toObject());
     });
 
-    it('should throw InvalidStateTransitionError if passed object is not valid', async () => {
-      const validationError = new SomeConsensusError('test');
-
-      validateStateTransitionBasicMock.returns(new ValidationResult([validationError]));
+    it('should throw InvalidStateTransition error in case validation failed', async () => {
+      rawStateTransition.type = undefined;
 
       try {
         await factory.createFromObject(rawStateTransition);
-
-        expect.fail('InvalidStateTransitionError is not thrown');
+        expect.fail('should throw an error');
       } catch (e) {
         expect(e).to.be.an.instanceOf(InvalidStateTransitionError);
-        expect(e.getRawStateTransition()).to.equal(rawStateTransition);
-
-        expect(e.getErrors()).to.have.length(1);
 
-        const [consensusError] = e.getErrors();
+        const [error] = e.getErrors();
 
-        expect(consensusError).to.equal(validationError);
-
-        expect(validateStateTransitionBasicMock).to.have.been.calledOnceWith(
-          rawStateTransition,
-        );
+        expect(error).to.be.an.instanceOf(MissingStateTransitionTypeError);
       }
     });
   });
 
   describe('createFromBuffer', () => {
-    let serializedStateTransition;
-
-    beforeEach(function beforeEach() {
-      this.sinonSandbox.stub(factory, 'createFromObject');
-
-      serializedStateTransition = stateTransition.toBuffer();
-    });
-
-    afterEach(() => {
-      factory.createFromObject.restore();
-    });
-
     it('should return new State Transition from serialized contract', async () => {
-      decodeProtocolEntityMock.returns([rawStateTransition.protocolVersion, rawStateTransition]);
-
-      factory.createFromObject.resolves(stateTransition);
-
-      const result = await factory.createFromBuffer(serializedStateTransition);
+      const result = await factory.createFromBuffer(stateTransition.toBuffer());
 
-      expect(result).to.equal(stateTransition);
-
-      expect(factory.createFromObject).to.have.been.calledOnceWith(rawStateTransition);
-
-      expect(decodeProtocolEntityMock).to.have.been.calledOnceWith(
-        serializedStateTransition,
-      );
+      expect(result.toObject()).to.deep.equal(stateTransition.toObject());
     });
 
-    it('should throw InvalidStateTransitionError if the decoding fails with consensus error', async () => {
-      const parsingError = new SerializedObjectParsingError(
-        serializedStateTransition,
-        new Error(),
-      );
-
-      decodeProtocolEntityMock.throws(parsingError);
+    it('should throw InvalidStateTransition error in case validation failed', async () => {
+      // CBOR that have invalid "type" property
+      const stateTransitionHex = '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';
+      const stateTransitionBuffer = Buffer.from(stateTransitionHex, 'hex');
 
       try {
-        await factory.createFromBuffer(serializedStateTransition);
-
-        expect.fail('should throw InvalidStateTransitionError');
+        await factory.createFromBuffer(stateTransitionBuffer);
+        expect.fail('should throw an error');
       } catch (e) {
         expect(e).to.be.an.instanceOf(InvalidStateTransitionError);
 
-        const [innerError] = e.getErrors();
-        expect(innerError).to.be.equal(parsingError);
-      }
-    });
-
-    it('should throw an error if decoding fails with any other error', async () => {
-      const otherParsingError = new Error();
-
-      decodeProtocolEntityMock.throws(otherParsingError);
+        const [error] = e.getErrors();
 
-      try {
-        await factory.createFromBuffer(serializedStateTransition);
-
-        expect.fail('should throw an error');
-      } catch (e) {
-        expect(e).to.be.equal(otherParsingError);
+        expect(error).to.be.an.instanceOf(MissingStateTransitionTypeError);
       }
     });
   });

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

@@ -2,7 +2,6 @@ const validateStateTransitionFeeFactory = require('@dashevo/dpp/lib/stateTransit
 
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
@@ -23,20 +22,19 @@ const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransitio
 describe('validateStateTransitionFeeFactory', () => {
   let stateRepositoryMock;
   let validateStateTransitionFee;
-  let identity;
   let dataContract;
   let calculateStateTransitionFeeMock;
   let fetchAssetLockTransactionOutputMock;
 
   beforeEach(function beforeEach() {
-    identity = getIdentityFixture();
-
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchIdentity.resolves(identity);
 
     const output = getIdentityCreateTransitionFixture().getAssetLockProof().getOutput();
 
-    calculateStateTransitionFeeMock = this.sinonSandbox.stub().returns(42);
+    calculateStateTransitionFeeMock = this.sinonSandbox.stub().returns({
+      desiredAmount: 42,
+    });
+
     fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
 
     validateStateTransitionFee = validateStateTransitionFeeFactory(
@@ -59,7 +57,7 @@ describe('validateStateTransitionFeeFactory', () => {
     });
 
     it('should return invalid result if balance is not enough', async () => {
-      identity.balance = 1;
+      stateRepositoryMock.fetchIdentityBalance.resolves(1);
 
       const result = await validateStateTransitionFee(dataContractCreateTransition);
 
@@ -68,9 +66,9 @@ describe('validateStateTransitionFeeFactory', () => {
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(3000);
-      expect(error.getBalance()).to.equal(identity.balance);
+      expect(error.getBalance()).to.equal(1);
 
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
         dataContract.getOwnerId(),
         dataContractCreateTransition.getExecutionContext(),
       );
@@ -83,13 +81,13 @@ describe('validateStateTransitionFeeFactory', () => {
     });
 
     it('should return valid result', async () => {
-      identity.balance = 42;
+      stateRepositoryMock.fetchIdentityBalance.resolves(42);
 
       const result = await validateStateTransitionFee(dataContractCreateTransition);
 
       expect(result.isValid()).to.be.true();
 
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
         dataContract.getOwnerId(),
         dataContractCreateTransition.getExecutionContext(),
       );
@@ -120,7 +118,7 @@ describe('validateStateTransitionFeeFactory', () => {
     });
 
     it('should return invalid result if balance is not enough', async () => {
-      identity.balance = 1;
+      stateRepositoryMock.fetchIdentityBalance.resolves(1);
 
       const result = await validateStateTransitionFee(documentsBatchTransition);
 
@@ -129,9 +127,9 @@ describe('validateStateTransitionFeeFactory', () => {
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(3000);
-      expect(error.getBalance()).to.equal(identity.balance);
+      expect(error.getBalance()).to.equal(1);
 
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
         getDocumentsFixture.ownerId,
         documentsBatchTransition.getExecutionContext(),
       );
@@ -144,13 +142,13 @@ describe('validateStateTransitionFeeFactory', () => {
     });
 
     it('should return valid result', async () => {
-      identity.balance = 42;
+      stateRepositoryMock.fetchIdentityBalance.resolves(42);
 
       const result = await validateStateTransitionFee(documentsBatchTransition);
 
       expect(result.isValid()).to.be.true();
 
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
         getDocumentsFixture.ownerId,
         documentsBatchTransition.getExecutionContext(),
       );
@@ -172,7 +170,7 @@ describe('validateStateTransitionFeeFactory', () => {
       expect(result.isValid()).to.be.true();
 
       expect(calculateStateTransitionFeeMock).to.be.not.called();
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
         getDocumentsFixture.ownerId,
         documentsBatchTransition.getExecutionContext(),
       );
@@ -195,7 +193,7 @@ describe('validateStateTransitionFeeFactory', () => {
     });
 
     it('should return invalid result if asset lock output amount is not enough', async () => {
-      calculateStateTransitionFeeMock.returns(outputAmount + 1);
+      calculateStateTransitionFeeMock.returns({ desiredAmount: outputAmount + 1 });
 
       const result = await validateStateTransitionFee(identityCreateTransition);
 
@@ -269,9 +267,9 @@ describe('validateStateTransitionFeeFactory', () => {
     });
 
     it('should return invalid result if sum of balance and asset lock output amount is not enough', async () => {
-      identity.balance = 1;
+      stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(1);
 
-      calculateStateTransitionFeeMock.returns(outputAmount + 2);
+      calculateStateTransitionFeeMock.returns({ desiredAmount: outputAmount + 2 });
 
       const result = await validateStateTransitionFee(identityTopUpTransition);
 
@@ -280,9 +278,9 @@ describe('validateStateTransitionFeeFactory', () => {
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(3000);
-      expect(error.getBalance()).to.equal(outputAmount + identity.balance);
+      expect(error.getBalance()).to.equal(outputAmount + 1);
 
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnceWithExactly(
         identityTopUpTransition.getIdentityId(),
         identityTopUpTransition.getExecutionContext(),
       );
@@ -298,7 +296,7 @@ describe('validateStateTransitionFeeFactory', () => {
     });
 
     it('should return valid result', async () => {
-      identity.balance = 41;
+      stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(41);
 
       calculateStateTransitionFeeMock.returns(outputAmount - 1);
 
@@ -306,7 +304,7 @@ describe('validateStateTransitionFeeFactory', () => {
 
       expect(result.isValid()).to.be.true();
 
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnceWithExactly(
         identityTopUpTransition.getIdentityId(),
         identityTopUpTransition.getExecutionContext(),
       );
@@ -335,7 +333,7 @@ describe('validateStateTransitionFeeFactory', () => {
         identityTopUpTransition.getAssetLockProof(),
         identityTopUpTransition.getExecutionContext(),
       );
-      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnceWithExactly(
         identityTopUpTransition.getIdentityId(),
         identityTopUpTransition.getExecutionContext(),
       );

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

@@ -1,69 +1,84 @@
-const validateStateTransitionKeySignatureFactory = require('@dashevo/dpp/lib/stateTransition/validation/validateStateTransitionKeySignatureFactory');
+const { Transaction, PrivateKey, Script } = require('@dashevo/dashcore-lib');
 
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-const InvalidStateTransitionSignatureError = require('@dashevo/dpp/lib/errors/consensus/signature/InvalidStateTransitionSignatureError');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
 
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../dist');
 
 describe('validateStateTransitionKeySignatureFactory', () => {
-  let publicKeyHash;
   let stateTransition;
-  let stateTransitionHash;
-  let verifyHashSignatureMock;
+  let stateRepositoryMock;
   let validateStateTransitionKeySignature;
-  let fetchAssetLockPublicKeyHashMock;
-  let executionContext;
-
-  beforeEach(function beforeEach() {
-    publicKeyHash = Buffer.alloc(20).fill(1);
 
-    stateTransition = getIdentityCreateTransitionFixture();
-    stateTransitionHash = stateTransition.hash({ skipSignature: true });
+  let InvalidStateTransitionSignatureError;
+  let StateTransitionKeySignatureValidator;
+  let StateTransitionExecutionContext;
+  let IdentityCreateTransition;
+  let IdentityTopUpTransition;
+  let IdentityNotFoundError;
+  let ValidationResult;
+
+  before(async () => {
+    ({
+      InvalidStateTransitionSignatureError,
+      StateTransitionKeySignatureValidator,
+      StateTransitionExecutionContext,
+      IdentityCreateTransition,
+      IdentityTopUpTransition,
+      IdentityNotFoundError,
+      ValidationResult,
+    } = await loadWasmDpp());
+  });
 
-    executionContext = new StateTransitionExecutionContext();
+  beforeEach(function beforeEach() {
+    const stateTransitionJS = getIdentityCreateTransitionFixture();
+    const rawStateTransition = stateTransitionJS.toObject();
 
-    stateTransition.setExecutionContext(executionContext);
+    stateTransition = new IdentityCreateTransition(rawStateTransition);
 
-    verifyHashSignatureMock = this.sinonSandbox.stub();
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    fetchAssetLockPublicKeyHashMock = this.sinonSandbox.stub().resolves(publicKeyHash);
+    const validator = new StateTransitionKeySignatureValidator(stateRepositoryMock);
 
-    validateStateTransitionKeySignature = validateStateTransitionKeySignatureFactory(
-      verifyHashSignatureMock,
-      fetchAssetLockPublicKeyHashMock,
-    );
+    validateStateTransitionKeySignature = (st) => validator.validate(st);
   });
 
   it('should return invalid result if signature is not valid', async () => {
-    verifyHashSignatureMock.returns(false);
-
     const result = await validateStateTransitionKeySignature(
       stateTransition,
     );
 
-    expectValidationError(result, InvalidStateTransitionSignatureError);
+    await 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 rawStateTransition = stateTransition.toObject();
+
+    // Sign state transition and provide relevant public key to transaction output
+    const { transaction: rawTransaction } = rawStateTransition.assetLockProof;
+
+    const transaction = new Transaction(Buffer.from(rawTransaction));
+
+    const privateKey = new PrivateKey('9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2');
+    const publicKey = privateKey.toPublicKey();
+
+    transaction.outputs[0]
+      .setScript(Script.buildDataOut(publicKey.hash));
+
+    rawStateTransition.assetLockProof.transaction = transaction.toBuffer();
+
+    stateTransition = new IdentityCreateTransition(rawStateTransition);
+
+    await stateTransition.signByPrivateKey(
+      privateKey.toBuffer(),
+      0,
+    );
 
     const result = await validateStateTransitionKeySignature(
       stateTransition,
@@ -71,16 +86,28 @@ describe('validateStateTransitionKeySignatureFactory', () => {
 
     expect(result).to.be.instanceof(ValidationResult);
     expect(result.isValid()).to.be.true();
+  });
+
+  it('should return IdentityNotFoundError if identity not exist on topup transaction', async function () {
+    const stateTransitionJS = getIdentityTopUpTransitionFixture();
+    stateTransition = new IdentityTopUpTransition(stateTransitionJS.toObject());
+    stateRepositoryMock.fetchIdentityBalance.resolves(undefined);
 
-    expect(fetchAssetLockPublicKeyHashMock).to.be.calledOnceWithExactly(
-      stateTransition.getAssetLockProof(),
-      executionContext,
+    const result = await validateStateTransitionKeySignature(
+      stateTransition,
     );
 
-    expect(verifyHashSignatureMock).to.be.calledOnceWithExactly(
-      stateTransitionHash,
-      stateTransition.getSignature(),
-      publicKeyHash,
+    await expectValidationError(result, IdentityNotFoundError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(2000);
+
+    const { match } = this.sinonSandbox;
+    expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
+      match((identityId) => Buffer.from(identityId.toBuffer())
+        .equals(stateTransition.getIdentityId().toBuffer())),
+      match.instanceOf(StateTransitionExecutionContext),
     );
   });
 });

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

@@ -1,48 +1,54 @@
-const UnsupportedProtocolVersionError = require('@dashevo/dpp/lib/errors/consensus/basic/UnsupportedProtocolVersionError');
-const CompatibleProtocolVersionIsNotDefinedError = require('@dashevo/dpp/lib/errors/CompatibleProtocolVersionIsNotDefinedError');
-const IncompatibleProtocolVersionError = require('@dashevo/dpp/lib/errors/consensus/basic/IncompatibleProtocolVersionError');
+const { expectValidationError } = require('../../../lib/test/expect/expectError');
 
-const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
-const validateProtocolVersionFactory = require('@dashevo/dpp/lib/version/validateProtocolVersionFactory');
-
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-const { latestVersion } = require('@dashevo/dpp/lib/version/protocolVersion');
+let {
+  UnsupportedProtocolVersionError,
+  CompatibleProtocolVersionIsNotDefinedError,
+  IncompatibleProtocolVersionError,
+  ProtocolVersionValidator,
+} = require('../../..');
+const { default: loadWasmDpp } = require('../../..');
 
 describe('validateProtocolVersionFactory', () => {
-  let validateProtocolVersion;
-  let dppMock;
+  let protocolVersionValidator;
   let versionCompatibilityMap;
   let currentProtocolVersion;
   let protocolVersion;
 
-  beforeEach(function beforeEach() {
+  before(async () => {
+    ({
+      UnsupportedProtocolVersionError,
+      CompatibleProtocolVersionIsNotDefinedError,
+      IncompatibleProtocolVersionError,
+      ProtocolVersionValidator,
+    } = await loadWasmDpp());
+  });
+
+  beforeEach(() => {
     protocolVersion = 1;
     currentProtocolVersion = 1;
 
-    dppMock = createDPPMock(this.sinonSandbox);
-    dppMock.getProtocolVersion.returns(currentProtocolVersion);
-
     versionCompatibilityMap = {
       1: 1,
     };
 
-    validateProtocolVersion = validateProtocolVersionFactory(
-      dppMock,
+    protocolVersionValidator = new ProtocolVersionValidator({
+      currentProtocolVersion,
+      latestProtocolVersion: protocolVersion,
       versionCompatibilityMap,
-    );
+    });
   });
 
-  it('should throw UnsupportedProtocolVersionError if protocolVersion is higher than latestVersion', () => {
-    protocolVersion = latestVersion + 1;
+  it('should throw UnsupportedProtocolVersionError if protocolVersion is higher than latestVersion', async () => {
+    const highVersion = protocolVersion + 1;
 
-    const result = validateProtocolVersion(protocolVersion);
+    const result = protocolVersionValidator.validate(highVersion);
 
-    expectValidationError(result, UnsupportedProtocolVersionError);
+    await expectValidationError(result, UnsupportedProtocolVersionError);
 
     const error = result.getFirstError();
 
-    expect(error.getParsedProtocolVersion()).to.equal(protocolVersion);
-    expect(error.getLatestVersion()).to.equal(latestVersion);
+    expect(error.getParsedProtocolVersion()).to.equal(highVersion);
+    expect(error.getLatestVersion()).to.equal(protocolVersion);
     expect(error.getCode()).to.equal(1002);
   });
 
@@ -50,8 +56,14 @@ describe('validateProtocolVersionFactory', () => {
     + ' defined for the current protocol version', () => {
     delete versionCompatibilityMap[currentProtocolVersion.toString()];
 
+    protocolVersionValidator = new ProtocolVersionValidator({
+      currentProtocolVersion,
+      latestProtocolVersion: protocolVersion,
+      versionCompatibilityMap,
+    });
+
     try {
-      validateProtocolVersion(protocolVersion);
+      protocolVersionValidator.validate(protocolVersion);
 
       expect.fail('should throw CompatibleProtocolVersionIsNotDefinedError');
     } catch (e) {
@@ -59,7 +71,7 @@ describe('validateProtocolVersionFactory', () => {
     }
   });
 
-  it('should throw IncompatibleProtocolVersionError if parsed version is lower than compatible one', () => {
+  it('should throw IncompatibleProtocolVersionError if parsed version is lower than compatible one', async () => {
     const minimalProtocolVersion = 1;
 
     protocolVersion = 0;
@@ -67,9 +79,15 @@ describe('validateProtocolVersionFactory', () => {
 
     versionCompatibilityMap[currentProtocolVersion.toString()] = minimalProtocolVersion;
 
-    const result = validateProtocolVersion(protocolVersion);
+    protocolVersionValidator = new ProtocolVersionValidator({
+      currentProtocolVersion,
+      latestProtocolVersion: protocolVersion,
+      versionCompatibilityMap,
+    });
+
+    const result = protocolVersionValidator.validate(protocolVersion);
 
-    expectValidationError(result, IncompatibleProtocolVersionError);
+    await expectValidationError(result, IncompatibleProtocolVersionError);
 
     const error = result.getFirstError();