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

package/test/integration/document/stateTransition/DocumentsBatchTransition/validation/basic/validateDocumentsBatchTransitionBasicFactory.spec.js

@@ -1,63 +1,67 @@
-const { getRE2Class } = require('@dashevo/wasm-re2');
-
-const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
-
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-
-const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
-
 const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
-
-const enrichDataContractWithBaseSchema = require('@dashevo/dpp/lib/dataContract/enrichDataContractWithBaseSchema');
-
-const DocumentsBatchTransition = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
-
 const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
-const validateDocumentsBatchTransitionBasicFactory = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/validation/basic/validateDocumentsBatchTransitionBasicFactory');
-
-const { expectValidationError, expectJsonSchemaError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const InvalidDocumentTransitionIdError = require('@dashevo/dpp/lib/errors/consensus/basic/document/InvalidDocumentTransitionIdError');
-const DataContractNotPresentError = require('@dashevo/dpp/lib/errors/consensus/basic/document/DataContractNotPresentError');
-const MissingDataContractIdError = require('@dashevo/dpp/lib/errors/consensus/basic/document/MissingDataContractIdError');
-const MissingDocumentTransitionTypeError = require('@dashevo/dpp/lib/errors/consensus/basic/document/MissingDocumentTransitionTypeError');
-const InvalidDocumentTypeError = require('@dashevo/dpp/lib/errors/consensus/basic/document/InvalidDocumentTypeError');
-const MissingDocumentTransitionActionError = require('@dashevo/dpp/lib/errors/consensus/basic/document/MissingDocumentTransitionActionError');
-const InvalidDocumentTransitionActionError = require('@dashevo/dpp/lib/errors/consensus/basic/document/InvalidDocumentTransitionActionError');
-const InvalidIdentifierError = require('@dashevo/dpp/lib/errors/consensus/basic/InvalidIdentifierError');
-const DuplicateDocumentTransitionsWithIndicesError = require('@dashevo/dpp/lib/errors/consensus/basic/document/DuplicateDocumentTransitionsWithIndicesError');
-const DuplicateDocumentTransitionsWithIdsError = require('@dashevo/dpp/lib/errors/consensus/basic/document/DuplicateDocumentTransitionsWithIdsError');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+const { expectJsonSchemaError, expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+
+let DataContract;
+let DocumentsBatchTransition;
+let StateTransitionExecutionContext;
+let validateDocumentsBatchTransitionBasic;
+let generateDocumentId;
+let MissingDataContractIdError;
+let InvalidIdentifierError;
+let DataContractNotPresentError;
+let MissingDocumentTransitionTypeError;
+let InvalidDocumentTypeError;
+let MissingDocumentTransitionActionError;
+let InvalidDocumentTransitionActionError;
+let InvalidDocumentTransitionIdError;
+let DuplicateDocumentTransitionsWithIndicesError;
+let DuplicateDocumentTransitionsWithIdsError;
+let ValidationResult;
+let ProtocolVersionValidator;
 
 describe('validateDocumentsBatchTransitionBasicFactory', () => {
   let dataContract;
   let documents;
   let rawStateTransition;
-  let findDuplicatesByIdMock;
-  let findDuplicatesByIndicesMock;
-  let validateDocumentsBatchTransitionBasic;
   let stateTransition;
   let ownerId;
   let stateRepositoryMock;
-  let validator;
-  let enrichSpy;
   let documentTransitions;
-  let validatePartialCompoundIndicesMock;
-  let validateProtocolVersionMock;
+  let protocolVersionValidator;
   let executionContext;
 
   beforeEach(async function beforeEach() {
-    dataContract = getDataContractFixture();
-    documents = getDocumentsFixture(dataContract);
-
+    ({
+      ProtocolVersionValidator,
+      DataContract,
+      StateTransitionExecutionContext,
+      DocumentsBatchTransition,
+      ValidationResult,
+      validateDocumentsBatchTransitionBasic,
+      generateDocumentId,
+      InvalidIdentifierError,
+      MissingDataContractIdError,
+      DataContractNotPresentError,
+      MissingDocumentTransitionTypeError,
+      InvalidDocumentTypeError,
+      MissingDocumentTransitionActionError,
+      InvalidDocumentTransitionActionError,
+      InvalidDocumentTransitionIdError,
+      DuplicateDocumentTransitionsWithIndicesError,
+      DuplicateDocumentTransitionsWithIdsError,
+    } = await loadWasmDpp());
+
+    const dataContractJs = getDataContractFixture();
+    dataContract = new DataContract(dataContractJs.toObject());
+
+    documents = getDocumentsFixture(dataContractJs);
     ownerId = getDocumentsFixture.ownerId;
 
     documentTransitions = getDocumentTransitionsFixture({
@@ -73,53 +77,28 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
       transitions: documentTransitions.map((t) => t.toObject()),
       signature: Buffer.alloc(65),
       signaturePublicKeyId: 0,
-    }, [dataContract]);
+    }, [dataContract.clone()]);
 
     rawStateTransition = stateTransition.toObject();
 
-    findDuplicatesByIdMock = this.sinonSandbox.stub().returns([]);
-    findDuplicatesByIndicesMock = this.sinonSandbox.stub().returns([]);
-
-    const dataContractValidationResult = new ValidationResult();
-    dataContractValidationResult.setData(dataContract);
-
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+    stateRepositoryMock.fetchDataContract.resolves(dataContract.clone());
 
-    const RE2 = await getRE2Class();
-    const ajv = createAjv(RE2);
-
-    validator = new JsonSchemaValidator(ajv);
-
-    enrichSpy = this.sinonSandbox.spy(enrichDataContractWithBaseSchema);
-
-    validatePartialCompoundIndicesMock = this.sinonSandbox.stub().returns(
-      new ValidationResult(),
-    );
-
-    validateProtocolVersionMock = this.sinonSandbox.stub().returns(new ValidationResult());
-
-    validateDocumentsBatchTransitionBasic = validateDocumentsBatchTransitionBasicFactory(
-      findDuplicatesByIdMock,
-      findDuplicatesByIndicesMock,
-      stateRepositoryMock,
-      validator,
-      enrichSpy,
-      validatePartialCompoundIndicesMock,
-      validateProtocolVersionMock,
-    );
+    protocolVersionValidator = new ProtocolVersionValidator();
   });
 
   describe('protocolVersion', () => {
-    it('should be present', async () => {
+    it('should be present - Rust', async () => {
       delete rawStateTransition.protocolVersion;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
@@ -128,15 +107,17 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
       expect(error.getParams().missingProperty).to.equal('protocolVersion');
     });
 
-    it('should be an integer', async () => {
+    it('should be an integer - Rust', async () => {
       rawStateTransition.protocolVersion = '1';
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
@@ -144,43 +125,33 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
       expect(error.getKeyword()).to.equal('type');
     });
 
-    it('should be valid', async () => {
+    it('should be valid - Rust', async () => {
       rawStateTransition.protocolVersion = -1;
-
-      const protocolVersionError = new SomeConsensusError('test');
-      const protocolVersionResult = new ValidationResult([
-        protocolVersionError,
-      ]);
-
-      validateProtocolVersionMock.returns(protocolVersionResult);
-
-      const result = await validateDocumentsBatchTransitionBasic(
-        rawStateTransition,
-        executionContext,
-      );
-
-      expectValidationError(result, SomeConsensusError);
-
-      const [error] = result.getErrors();
-
-      expect(error).to.equal(protocolVersionError);
-
-      expect(validateProtocolVersionMock).to.be.calledOnceWith(
-        rawStateTransition.protocolVersion,
-      );
+      try {
+        await validateDocumentsBatchTransitionBasic(
+          protocolVersionValidator,
+          stateRepositoryMock,
+          rawStateTransition,
+          executionContext,
+        );
+      } catch (e) {
+        expect(e).equal('Error conversion not implemented: unable convert -1 to u64');
+      }
     });
   });
 
   describe('type', () => {
-    it('should be present', async () => {
+    it('should be present - Rust', async () => {
       delete rawStateTransition.type;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
@@ -189,15 +160,17 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
       expect(error.getParams().missingProperty).to.equal('type');
     });
 
-    it('should be equal 1', async () => {
+    it('should be equal 1 - Rust', async () => {
       rawStateTransition.type = 666;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
@@ -208,15 +181,17 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
   });
 
   describe('ownerId', () => {
-    it('should be present', async () => {
+    it('should be present - Rust', async () => {
       delete rawStateTransition.ownerId;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
@@ -225,439 +200,425 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
       expect(error.getParams().missingProperty).to.equal('ownerId');
     });
 
-    it('should be a byte array', async () => {
+    it('should be a byte array - Rust', async () => {
       rawStateTransition.ownerId = new Array(32).fill('string');
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result, 2);
+      await expectJsonSchemaError(result, 32);
 
-      const [error, byteArrayError] = result.getErrors();
+      const [error] = result.getErrors();
 
       expect(error.getInstancePath()).to.equal('/ownerId/0');
       expect(error.getKeyword()).to.equal('type');
-
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
     });
 
-    it('should be no less than 32 bytes', async () => {
+    it('should be no less than 32 bytes - Rust', async () => {
       rawStateTransition.ownerId = Buffer.alloc(31);
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/ownerId');
+      expect(error.getInstancePath()).to.equal('/ownerId');
       expect(error.getKeyword()).to.equal('minItems');
     });
 
-    it('should be no longer than 32 bytes', async () => {
+    it('should be no longer than 32 bytes - Rust', async () => {
       rawStateTransition.ownerId = Buffer.alloc(33);
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/ownerId');
+      expect(error.getInstancePath()).to.equal('/ownerId');
       expect(error.getKeyword()).to.equal('maxItems');
     });
   });
 
   describe('document transitions', () => {
-    it('should be present', async () => {
+    it('should be present Rust', async () => {
       delete rawStateTransition.transitions;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
-
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('');
+      expect(error.getInstancePath()).to.equal('');
       expect(error.getKeyword()).to.equal('required');
       expect(error.getParams().missingProperty).to.equal('transitions');
     });
 
-    it('should be an array', async () => {
+    it('should be an array - Rust', async () => {
       rawStateTransition.transitions = {};
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/transitions');
+      expect(error.getInstancePath()).to.equal('/transitions');
       expect(error.getKeyword()).to.equal('type');
     });
 
-    it('should have at least one element', async () => {
+    it('should have at least one element - Rust', async () => {
       rawStateTransition.transitions = [];
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/transitions');
+      expect(error.getInstancePath()).to.equal('/transitions');
       expect(error.getKeyword()).to.equal('minItems');
-      expect(error.getParams().limit).to.equal(1);
+      expect(error.getParams().minItems).to.equal(1);
     });
 
-    it('should have no more than 10 elements', async () => {
+    it('should have no more than 10 elements - Rust', async () => {
       rawStateTransition.transitions = Array(11).fill({});
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/transitions');
+      expect(error.getInstancePath()).to.equal('/transitions');
       expect(error.getKeyword()).to.equal('maxItems');
-      expect(error.getParams().limit).to.equal(10);
+      expect(error.getParams().maxItems).to.equal(10);
     });
 
-    it('should have objects as elements', async () => {
+    it('should have objects as elements - Rust', async () => {
       rawStateTransition.transitions = [1];
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/transitions/0');
+      expect(error.getInstancePath()).to.equal('/transitions/0');
       expect(error.getKeyword()).to.equal('type');
     });
 
     describe('document transition', () => {
       describe('$id', () => {
-        it('should be present', async () => {
+        it('should be present - Rust', async () => {
           const [documentTransition] = rawStateTransition.transitions;
-
           delete documentTransition.$id;
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectJsonSchemaError(result);
+          await expectJsonSchemaError(result, 1);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal('');
+          expect(error.getInstancePath()).to.equal('');
           expect(error.getKeyword()).to.equal('required');
           expect(error.getParams().missingProperty).to.equal('$id');
         });
 
-        it('should be a byte array', async () => {
+        it('should be a byte array - Rust', async () => {
           const [documentTransition] = rawStateTransition.transitions;
 
           documentTransition.$id = new Array(32).fill('string');
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectJsonSchemaError(result, 2);
+          await expectJsonSchemaError(result, 32);
 
-          const [error, byteArrayError] = result.getErrors();
+          const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal('/$id/0');
+          expect(error.getInstancePath()).to.equal('/$id/0');
           expect(error.getKeyword()).to.equal('type');
-
-          expect(byteArrayError.getKeyword()).to.equal('byteArray');
         });
 
-        it('should be no less than 32 bytes', async () => {
+        it('should be no less than 32 bytes - Rust', async () => {
           const [documentTransition] = rawStateTransition.transitions;
 
           documentTransition.$id = Buffer.alloc(31);
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectJsonSchemaError(result);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal('/$id');
+          expect(error.getInstancePath()).to.equal('/$id');
           expect(error.getKeyword()).to.equal('minItems');
-          expect(error.getParams().limit).to.equal(32);
+          expect(error.getParams().minItems).to.equal(32);
         });
 
-        it('should be no longer than 32 bytes', async () => {
+        it('should be no longer than 32 bytes - Rust', async () => {
           const [documentTransition] = rawStateTransition.transitions;
 
           documentTransition.$id = Buffer.alloc(33);
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
-
-          expectJsonSchemaError(result);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal('/$id');
+          expect(error.getInstancePath()).to.equal('/$id');
           expect(error.getKeyword()).to.equal('maxItems');
-          expect(error.getParams().limit).to.equal(32);
+          expect(error.getParams().maxItems).to.equal(32);
         });
 
-        it('should no have duplicate IDs in the state transition', async () => {
-          const duplicates = [documentTransitions[0].toObject()];
+        it('should no have duplicate IDs in the state transition - Rust', async () => {
+          const [documentTransition] = documentTransitions.map((t) => t.toObject());
+
+          stateTransition = new DocumentsBatchTransition({
+            protocolVersion: protocolVersion.latestVersion,
+            ownerId,
+            contractId: dataContract.getId(),
+            transitions: [documentTransition, documentTransition],
+            signature: Buffer.alloc(65),
+            signaturePublicKeyId: 0,
+          }, [dataContract.clone()]);
 
-          findDuplicatesByIdMock.returns(duplicates);
+          rawStateTransition = stateTransition.toObject();
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectValidationError(result, DuplicateDocumentTransitionsWithIdsError);
+          await expectValidationError(result, DuplicateDocumentTransitionsWithIdsError);
 
           const [error] = result.getErrors();
 
           expect(error.getCode()).to.equal(1019);
-          expect(error.getDocumentTransitionReferences()).to.deep.equal(
-            duplicates.map((d) => [d.$type, d.$id]),
-          );
 
-          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-            dataContract.getId(),
-            executionContext,
-          );
-          expect(enrichSpy).to.have.been.calledThrice();
-          expect(findDuplicatesByIdMock).to.have.been.calledOnceWithExactly(
-            rawStateTransition.transitions,
-          );
-          expect(findDuplicatesByIndicesMock).to.have.been.calledOnceWithExactly(
-            rawStateTransition.transitions, dataContract,
-          );
+          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+          const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+          expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
         });
       });
 
       describe('$dataContractId', () => {
-        it('should be present', async () => {
+        it('should be present - Rust', async () => {
           const [firstDocumentTransition] = rawStateTransition.transitions;
 
           delete firstDocumentTransition.$dataContractId;
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectValidationError(result, MissingDataContractIdError);
+          await expectValidationError(result, MissingDataContractIdError);
 
           const [error] = result.getErrors();
-
           expect(error.getCode()).to.equal(1025);
 
-          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-            dataContract.getId(),
-            executionContext,
-          );
-
-          expect(enrichSpy).to.have.been.calledThrice();
-
-          expect(findDuplicatesByIdMock).to.have.been.calledOnceWithExactly(
-            rawStateTransition.transitions.slice(1),
-          );
-          expect(findDuplicatesByIndicesMock).to.have.been.calledOnceWithExactly(
-            rawStateTransition.transitions.slice(1), dataContract,
-          );
+          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+          const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+          expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
         });
 
-        it('should be a byte array', async () => {
+        it('should be a byte array - Rust', async () => {
           const [firstDocumentTransition] = rawStateTransition.transitions;
 
-          firstDocumentTransition.$dataContractId = 'something';
+          firstDocumentTransition.$dataContractId = Buffer.alloc(2);
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectValidationError(result, InvalidIdentifierError);
+          await expectValidationError(result, InvalidIdentifierError);
 
           const [error] = result.getErrors();
 
           expect(error.getCode()).to.equal(1006);
 
           expect(error.getIdentifierName()).to.equal('$dataContractId');
+          expect(error.getIdentifierError()).to.equal('Identifier Error: Identifier must be 32 bytes long');
 
-          expect(error.getIdentifierError()).to.be.instanceOf(Error);
-          expect(error.getIdentifierError().message).to.equal('Identifier expects Buffer');
-
-          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-            dataContract.getId(),
-            executionContext,
-          );
-
-          expect(enrichSpy).to.have.been.calledThrice();
-
-          expect(findDuplicatesByIdMock).to.have.been.calledOnceWithExactly(
-            rawStateTransition.transitions.slice(1),
-          );
-          expect(findDuplicatesByIndicesMock).to.have.been.calledOnceWithExactly(
-            rawStateTransition.transitions.slice(1), dataContract,
-          );
+          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+          const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+          expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
         });
 
-        it('should exists in the state', async () => {
+        it('should exists in the state - Rust', async () => {
           stateRepositoryMock.fetchDataContract.resolves(undefined);
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectValidationError(result, DataContractNotPresentError);
+          await expectValidationError(result, DataContractNotPresentError);
 
           const [error] = result.getErrors();
 
           expect(error.getCode()).to.equal(1018);
-          expect(error.getDataContractId()).to.deep.equal(dataContract.getId());
-
-          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-            dataContract.getId(),
-            executionContext,
-          );
+          expect(error.getDataContractId()).to.deep.equal(dataContract.getId().toBuffer());
 
-          expect(enrichSpy).to.have.not.been.called();
-          expect(findDuplicatesByIdMock).to.have.not.been.called();
-          expect(findDuplicatesByIndicesMock).to.have.not.been.called();
+          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+          const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+          expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
         });
       });
 
       describe('$type', () => {
-        it('should be present', async () => {
+        it('should be present - Rust', async () => {
           const [firstDocumentTransition] = rawStateTransition.transitions;
 
           delete firstDocumentTransition.$type;
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
-
-          expectValidationError(result, MissingDocumentTransitionTypeError);
+          await expectValidationError(result, MissingDocumentTransitionTypeError);
 
           const [error] = result.getErrors();
 
           expect(error.getCode()).to.equal(1027);
 
-          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-            dataContract.getId(),
-            executionContext,
-          );
-
-          expect(enrichSpy).to.have.been.calledThrice();
-          expect(findDuplicatesByIdMock).to.have.not.been.called();
-          expect(findDuplicatesByIndicesMock).to.have.not.been.called();
+          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+          const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+          expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
         });
 
-        it('should be defined in Data Contract', async () => {
+        it('should be defined in Data Contract - Rust', async () => {
           const [firstDocumentTransition] = rawStateTransition.transitions;
 
           firstDocumentTransition.$type = 'wrong';
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectValidationError(result, InvalidDocumentTypeError);
+          await expectValidationError(result, InvalidDocumentTypeError);
 
           const [error] = result.getErrors();
 
           expect(error.getCode()).to.equal(1024);
           expect(error.getType()).to.equal(firstDocumentTransition.$type);
 
-          expect(Buffer.isBuffer(error.getDataContractId())).to.be.true();
           expect(error.getDataContractId()).to.deep.equal(dataContract.getId().toBuffer());
 
-          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-            dataContract.getId(),
-            executionContext,
-          );
-
-          expect(enrichSpy).to.have.been.calledThrice();
-          expect(findDuplicatesByIdMock).to.have.not.been.called();
-          expect(findDuplicatesByIndicesMock).to.have.not.been.called();
+          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+          const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+          expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
         });
       });
 
       describe('$action', () => {
-        it('should be present', async () => {
+        it('should be present - Rust', async () => {
           const [firstDocumentTransition] = rawStateTransition.transitions;
 
           delete firstDocumentTransition.$action;
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectValidationError(result, MissingDocumentTransitionActionError);
+          await expectValidationError(result, MissingDocumentTransitionActionError);
 
           const [error] = result.getErrors();
 
           expect(error.getCode()).to.equal(1026);
 
-          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-            dataContract.getId(),
-            executionContext,
-          );
-
-          expect(enrichSpy).to.have.been.calledThrice();
-          expect(findDuplicatesByIdMock).to.have.not.been.called();
-          expect(findDuplicatesByIndicesMock).to.have.not.been.called();
+          expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+          const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+          expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
         });
 
-        it('should throw InvalidDocumentTransitionActionError if action is not valid', async () => {
+        it('should throw InvalidDocumentTransitionActionError if action is not valid - Rust', async () => {
           const [firstDocumentTransition] = rawStateTransition.transitions;
 
           firstDocumentTransition.$action = 4;
 
           try {
             await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
@@ -666,130 +627,126 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
             expect(e.getAction()).to.equal(firstDocumentTransition.$action);
             expect(e.getRawDocumentTransition()).to.deep.equal(firstDocumentTransition);
 
-            expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-              dataContract.getId(),
-            );
-
-            expect(enrichSpy).to.have.been.calledThrice();
-            expect(findDuplicatesByIdMock).to.have.not.been.called();
-            expect(findDuplicatesByIndicesMock).to.have.not.been.called();
+            expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+            const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+            expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
           }
         });
       });
 
       describe('create', () => {
         describe('$id', () => {
-          it('should be valid generated ID', async () => {
+          it('should be valid generated ID - Rust', async () => {
             const [firstTransition] = rawStateTransition.transitions;
 
             const expectedId = firstTransition.$id;
-            firstTransition.$id = generateRandomIdentifier();
+            firstTransition.$id = generateRandomIdentifier().toBuffer();
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectValidationError(result, InvalidDocumentTransitionIdError);
-
             const [error] = result.getErrors();
+            console.log(error.toString());
+
+            await expectValidationError(result, InvalidDocumentTransitionIdError);
 
             expect(error.getCode()).to.equal(1023);
 
-            expect(Buffer.isBuffer(error.getExpectedId())).to.be.true();
             expect(error.getExpectedId()).to.deep.equal(expectedId);
-
-            expect(Buffer.isBuffer(error.getInvalidId())).to.be.true();
             expect(error.getInvalidId()).to.deep.equal(firstTransition.$id);
 
-            expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-              dataContract.getId(),
-              executionContext,
-            );
-
-            expect(enrichSpy).to.have.been.calledThrice();
-
-            expect(findDuplicatesByIdMock).to.have.not.been.called();
-            expect(findDuplicatesByIndicesMock).to.have.not.been.called();
+            expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+            const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+            expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
           });
         });
 
         describe('$entropy', () => {
-          it('should be present', async () => {
+          it('should be present - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             delete documentTransition.$entropy;
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('');
+            expect(error.getInstancePath()).to.equal('');
             expect(error.getKeyword()).to.equal('required');
             expect(error.getParams().missingProperty).to.equal('$entropy');
           });
 
-          it('should be a byte array', async () => {
+          it('should be a byte array - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             documentTransition.$entropy = new Array(32).fill('string');
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result, 2);
+            await expectJsonSchemaError(result, 32);
 
-            const [error, byteArrayError] = result.getErrors();
+            const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/$entropy/0');
+            expect(error.getInstancePath()).to.equal('/$entropy/0');
             expect(error.getKeyword()).to.equal('type');
-
-            expect(byteArrayError.getKeyword()).to.equal('byteArray');
           });
 
-          it('should be no less than 32 bytes', async () => {
+          it('should be no less than 32 bytes - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             documentTransition.$entropy = Buffer.alloc(31);
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/$entropy');
+            expect(error.getInstancePath()).to.equal('/$entropy');
             expect(error.getKeyword()).to.equal('minItems');
-            expect(error.getParams().limit).to.equal(32);
+            expect(error.getParams().minItems).to.equal(32);
           });
 
-          it('should be no longer than 32 bytes', async () => {
+          it('should be no longer than 32 bytes - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             documentTransition.$entropy = Buffer.alloc(33);
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/$entropy');
+            expect(error.getInstancePath()).to.equal('/$entropy');
             expect(error.getKeyword()).to.equal('maxItems');
-            expect(error.getParams().limit).to.equal(32);
+            expect(error.getParams().maxItems).to.equal(32);
           });
         });
       });
@@ -808,23 +765,25 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
             transitions: documentTransitions.map((t) => t.toObject()),
             signature: Buffer.alloc(65),
             signaturePublicKeyId: 0,
-          }, [dataContract]);
+          }, [dataContract.clone()]);
 
           rawStateTransition = stateTransition.toObject();
         });
 
         describe('$revision', () => {
-          it('should be present', async () => {
+          it('should be present - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             delete documentTransition.$revision;
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
@@ -832,57 +791,63 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
             expect(error.getKeyword()).to.equal('required');
           });
 
-          it('should be a number', async () => {
+          it('should be a number - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             documentTransition.$revision = '1';
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/$revision');
+            expect(error.getInstancePath()).to.equal('/$revision');
             expect(error.getKeyword()).to.equal('type');
           });
 
-          it('should be multiple of 1.0', async () => {
+          it('should be multiple of 1.0 - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             documentTransition.$revision = 1.2;
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/$revision');
+            expect(error.getInstancePath()).to.equal('/$revision');
             expect(error.getKeyword()).to.equal('type');
           });
 
-          it('should have a minimum value of 1', async () => {
+          it('should have a minimum value of 1 - Rust', async () => {
             const [documentTransition] = rawStateTransition.transitions;
 
             documentTransition.$revision = 0;
 
             const result = await validateDocumentsBatchTransitionBasic(
+              protocolVersionValidator,
+              stateRepositoryMock,
               rawStateTransition,
               executionContext,
             );
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/$revision');
+            expect(error.getInstancePath()).to.equal('/$revision');
             expect(error.getKeyword()).to.equal('minimum');
           });
         });
@@ -903,22 +868,24 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
             transitions: documentTransitions.map((t) => t.toObject()),
             signature: Buffer.alloc(65),
             signaturePublicKeyId: 0,
-          }, [dataContract]);
+          }, [dataContract.clone()]);
 
           rawStateTransition = stateTransition.toObject();
         });
 
-        it('should return invalid result if delete transaction is not valid', async () => {
+        it('should return invalid result if delete transaction is not valid - Rust', async () => {
           const [documentTransition] = rawStateTransition.transitions;
 
           delete documentTransition.$id;
 
           const result = await validateDocumentsBatchTransitionBasic(
+            protocolVersionValidator,
+            stateRepositoryMock,
             rawStateTransition,
             executionContext,
           );
 
-          expectJsonSchemaError(result);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
@@ -927,179 +894,169 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
         });
       });
 
-      it('should return invalid result if there are duplicate unique index values', async () => {
-        const duplicates = [documentTransitions[1].toObject()];
-
-        findDuplicatesByIndicesMock.returns(duplicates);
-
-        const result = await validateDocumentsBatchTransitionBasic(
-          rawStateTransition,
-          executionContext,
-        );
-
-        expectValidationError(result, DuplicateDocumentTransitionsWithIndicesError);
+      it('should return invalid result if there are duplicate unique index values - Rust', async () => {
+        const [, , , indexedTransition] = documentTransitions.map((t) => t.toObject());
+        const duplicatedTransition = { ...indexedTransition };
 
-        const [error] = result.getErrors();
-
-        expect(error.getCode()).to.equal(1020);
-
-        expect(error.getDocumentTransitionReferences()).to.deep.equal(
-          duplicates.map((d) => [d.$type, d.$id]),
-        );
-
-        expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
+        duplicatedTransition.$entropy = Buffer.alloc(32, 'b');
+        duplicatedTransition.$id = generateDocumentId(
           dataContract.getId(),
-          executionContext,
+          ownerId,
+          duplicatedTransition.$type,
+          duplicatedTransition.$entropy,
         );
-        expect(enrichSpy).to.have.been.calledThrice();
-        expect(findDuplicatesByIdMock).to.have.been.calledOnceWithExactly(
-          rawStateTransition.transitions,
-        );
-        expect(findDuplicatesByIndicesMock).to.have.been.calledOnceWithExactly(
-          rawStateTransition.transitions, dataContract,
-        );
-      });
+        const duplicates = [duplicatedTransition, indexedTransition];
 
-      it('should return invalid result if compound index doesn\'t contain all fields', async () => {
-        const consensusError = new SomeConsensusError('error');
+        stateTransition = new DocumentsBatchTransition({
+          protocolVersion: protocolVersion.latestVersion,
+          ownerId,
+          contractId: dataContract.getId(),
+          transitions: duplicates,
+          signature: Buffer.alloc(65),
+          signaturePublicKeyId: 0,
+        }, [dataContract.clone()]);
 
-        validatePartialCompoundIndicesMock.returns(
-          new ValidationResult([consensusError]),
-        );
+        rawStateTransition = stateTransition.toObject();
 
         const result = await validateDocumentsBatchTransitionBasic(
+          protocolVersionValidator,
+          stateRepositoryMock,
           rawStateTransition,
           executionContext,
         );
 
-        expectValidationError(result);
+        await expectValidationError(result, DuplicateDocumentTransitionsWithIndicesError);
 
         const [error] = result.getErrors();
 
-        expect(error).to.equal(consensusError);
-
-        expect(validatePartialCompoundIndicesMock).to.be.calledOnceWithExactly(
-          ownerId.toBuffer(),
-          rawStateTransition.transitions,
-          dataContract,
-        );
+        expect(error.getCode()).to.equal(1020);
 
-        expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-          dataContract.getId(),
-          executionContext,
-        );
-        expect(enrichSpy).to.have.been.calledThrice();
+        expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+        const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+        expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
       });
     });
   });
 
   describe('signature', () => {
-    it('should be present', async () => {
+    it('should be present - Rust', async () => {
       delete rawStateTransition.signature;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('');
+      expect(error.getInstancePath()).to.equal('');
       expect(error.getKeyword()).to.equal('required');
       expect(error.getParams().missingProperty).to.equal('signature');
     });
 
-    it('should be a byte array', async () => {
+    it('should be a byte array - Rust', async () => {
       rawStateTransition.signature = new Array(65).fill('string');
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result, 2);
+      await expectJsonSchemaError(result, 65);
 
-      const [error, byteArrayError] = result.getErrors();
+      const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/signature/0');
+      expect(error.getInstancePath()).to.equal('/signature/0');
       expect(error.getKeyword()).to.equal('type');
-
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
     });
 
-    it('should be not less than 65 bytes', async () => {
+    it('should be not less than 65 bytes - Rust', async () => {
       rawStateTransition.signature = Buffer.alloc(64);
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/signature');
+      expect(error.getInstancePath()).to.equal('/signature');
       expect(error.getKeyword()).to.equal('minItems');
-      expect(error.getParams().limit).to.equal(65);
+      expect(error.getParams().minItems).to.equal(65);
     });
 
-    it('should be not longer than 96 bytes', async () => {
+    it('should be not longer than 96 bytes - Rust', async () => {
       rawStateTransition.signature = Buffer.alloc(97);
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/signature');
+      expect(error.getInstancePath()).to.equal('/signature');
       expect(error.getKeyword()).to.equal('maxItems');
-      expect(error.getParams().limit).to.equal(96);
+      expect(error.getParams().maxItems).to.equal(96);
     });
   });
 
   describe('signaturePublicKeyId', () => {
-    it('should be an integer', async () => {
+    it('should be an integer - Rust', async () => {
       rawStateTransition.signaturePublicKeyId = 1.4;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result, 1);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/signaturePublicKeyId');
+      expect(error.getInstancePath()).to.equal('/signaturePublicKeyId');
       expect(error.getKeyword()).to.equal('type');
     });
 
-    it('should not be < 0', async () => {
+    it('should not be < 0 - Rust', async () => {
       rawStateTransition.signaturePublicKeyId = -1;
 
       const result = await validateDocumentsBatchTransitionBasic(
+        protocolVersionValidator,
+        stateRepositoryMock,
         rawStateTransition,
         executionContext,
       );
 
-      expectJsonSchemaError(result, 1);
+      await expectJsonSchemaError(result, 1);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/signaturePublicKeyId');
+      expect(error.getInstancePath()).to.equal('/signaturePublicKeyId');
       expect(error.getKeyword()).to.equal('minimum');
     });
   });
 
-  it('should return valid result', async () => {
+  it('should return valid result - Rust', async () => {
     const result = await validateDocumentsBatchTransitionBasic(
+      protocolVersionValidator,
+      stateRepositoryMock,
       rawStateTransition,
       executionContext,
     );
@@ -1107,40 +1064,28 @@ describe('validateDocumentsBatchTransitionBasicFactory', () => {
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      executionContext,
-    );
-
-    expect(enrichSpy).to.have.been.calledThrice();
-
-    expect(findDuplicatesByIdMock).to.have.been.calledOnceWithExactly(
-      rawStateTransition.transitions,
-    );
-
-    expect(findDuplicatesByIndicesMock).to.have.been.calledOnceWithExactly(
-      rawStateTransition.transitions, dataContract,
-    );
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
   });
 
-  it('should not validate Document transitions on dry run', async () => {
+  it('should not validate Document transitions on dry run - Rust', async () => {
     stateRepositoryMock.fetchDataContract.resolves(null);
 
     executionContext.enableDryRun();
 
     const result = await validateDocumentsBatchTransitionBasic(
+      protocolVersionValidator,
+      stateRepositoryMock,
       rawStateTransition,
       executionContext,
     );
 
-    executionContext.disableDryRun();
-
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      executionContext,
-    );
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).is.deep.equal(dataContract.getId().toBuffer());
   });
 });