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

package/test/integration/dataContract/validation/validateDataContractFactory.spec.js

@@ -1,86 +1,65 @@
-const { getRE2Class } = require('@dashevo/wasm-re2');
 const lodashCloneDeep = require('lodash/cloneDeep');
-
-const $RefParser = require('@apidevtools/json-schema-ref-parser');
-
-const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
-
-const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
-const validateDataContractFactory = require('@dashevo/dpp/lib/dataContract/validation/validateDataContractFactory');
-const validateDataContractMaxDepthFactory = require('@dashevo/dpp/lib/dataContract/validation/validateDataContractMaxDepthFactory');
-const enrichDataContractWithBaseSchema = require('@dashevo/dpp/lib/dataContract/enrichDataContractWithBaseSchema');
-const validateDataContractPatternsFactory = require('@dashevo/dpp/lib/dataContract/validation/validateDataContractPatternsFactory');
-
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const { expectJsonSchemaError, expectValidationError } = require('../../../../lib/test/expect/expectError');
 
-const { expectJsonSchemaError, expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const DuplicateIndexError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DuplicateIndexError');
-const UndefinedIndexPropertyError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/UndefinedIndexPropertyError');
-const InvalidIndexPropertyTypeError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/InvalidIndexPropertyTypeError');
-const SystemPropertyIndexAlreadyPresentError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/SystemPropertyIndexAlreadyPresentError');
-const UniqueIndicesLimitReachedError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/UniqueIndicesLimitReachedError');
-const InvalidIndexedPropertyConstraintError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/InvalidIndexedPropertyConstraintError');
-const InvalidCompoundIndexError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/InvalidCompoundIndexError');
-const IncompatibleRe2PatternError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/IncompatibleRe2PatternError');
-const InvalidJsonSchemaRefError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/InvalidJsonSchemaRefError');
-const JsonSchemaCompilationError = require('@dashevo/dpp/lib/errors/consensus/basic/JsonSchemaCompilationError');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
-const getPropertyDefinitionByPath = require('@dashevo/dpp/lib/dataContract/getPropertyDefinitionByPath');
-
-describe('validateDataContractFactory', function main() {
-  this.timeout(15000);
+const { default: loadWasmDpp } = require('../../../../dist');
 
+describe('validateDataContractFactory', () => {
   let dataContract;
-  let rawDataContract;
   let validateDataContract;
-  let RE2;
-  let validateProtocolVersionMock;
+
+  let DataContractValidator;
+  let ValidationResult;
+  let JsonSchemaCompilationError;
+  let IncompatibleRe2PatternError;
+  let DuplicateIndexError;
+  let UndefinedIndexPropertyError;
+  let UniqueIndicesLimitReachedError;
+  let SystemPropertyIndexAlreadyPresentError;
+  let InvalidIndexPropertyTypeError;
+  let InvalidCompoundIndexError;
+  let InvalidIndexedPropertyConstraintError;
+  let InvalidJsonSchemaRefError;
 
   before(async () => {
-    RE2 = await getRE2Class();
+    ({
+      DataContractValidator,
+      ValidationResult,
+      JsonSchemaCompilationError,
+      IncompatibleRe2PatternError,
+      DuplicateIndexError,
+      UndefinedIndexPropertyError,
+      UniqueIndicesLimitReachedError,
+      SystemPropertyIndexAlreadyPresentError,
+      InvalidIndexPropertyTypeError,
+      InvalidCompoundIndexError,
+      InvalidIndexedPropertyConstraintError,
+      InvalidJsonSchemaRefError,
+    } = await loadWasmDpp());
   });
 
-  beforeEach(async function beforeEach() {
+  beforeEach(async () => {
     dataContract = getDataContractFixture();
-    rawDataContract = dataContract.toObject();
-
-    const ajv = createAjv(RE2);
-    const jsonSchemaValidator = new JsonSchemaValidator(ajv);
 
-    const validateDataContractMaxDepth = validateDataContractMaxDepthFactory($RefParser);
+    const dataContractValidator = new DataContractValidator();
 
-    const validateDataContractPatterns = validateDataContractPatternsFactory(RE2);
-
-    validateProtocolVersionMock = this.sinonSandbox.stub().returns(new ValidationResult());
+    validateDataContract = (contract) => dataContractValidator.validate(contract);
+  });
 
-    validateDataContract = validateDataContractFactory(
-      jsonSchemaValidator,
-      validateDataContractMaxDepth,
-      enrichDataContractWithBaseSchema,
-      validateDataContractPatterns,
-      validateProtocolVersionMock,
-      getPropertyDefinitionByPath,
-    );
+  it('should pass validation if created from a fixture', () => {
+    const rawDataContract = dataContract.toObject();
+    const result = validateDataContract(rawDataContract);
+    expect(result.isValid()).to.be.true();
   });
 
   describe('protocolVersion', () => {
     it('should be present', async () => {
-      rawDataContract = {
-        documents: {
-          someDocument: {
-            type: 'object',
-          },
-        },
-      };
+      const rawDataContract = dataContract.toObject();
       delete rawDataContract.protocolVersion;
 
-      const result = await validateDataContract(rawDataContract);
+      const result = validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -90,11 +69,13 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be an integer', async () => {
+      const rawDataContract = dataContract.toObject();
+
       rawDataContract.protocolVersion = '1';
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -102,37 +83,28 @@ describe('validateDataContractFactory', function main() {
       expect(error.getKeyword()).to.equal('type');
     });
 
-    it('should be valid', async () => {
+    it('should be an unsigned integer', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.protocolVersion = -1;
 
-      const protocolVersionError = new SomeConsensusError('test');
-      const protocolVersionResult = new ValidationResult([
-        protocolVersionError,
-      ]);
-
-      validateProtocolVersionMock.returns(protocolVersionResult);
-
       const result = await validateDataContract(rawDataContract);
-
-      expectValidationError(result, SomeConsensusError);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error).to.equal(protocolVersionError);
-
-      expect(validateProtocolVersionMock).to.be.calledOnceWith(
-        rawDataContract.protocolVersion,
-      );
+      expect(error.getInstancePath()).to.equal('/protocolVersion');
+      expect(error.getKeyword()).to.equal('minimum');
     });
   });
 
   describe('$schema', () => {
     it('should be present', async () => {
+      const rawDataContract = dataContract.toObject();
       delete rawDataContract.$schema;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -142,24 +114,29 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be a string', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$schema = 1;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 2);
 
-      const [error] = result.getErrors();
+      const [typeError, constError] = result.getErrors();
 
-      expect(error.getInstancePath()).to.equal('/$schema');
-      expect(error.getKeyword()).to.equal('type');
+      expect(typeError.getInstancePath()).to.equal('/$schema');
+      expect(typeError.getKeyword()).to.equal('type');
+
+      expect(constError.getInstancePath()).to.equal('/$schema');
+      expect(constError.getKeyword()).to.equal('const');
     });
 
     it('should be a particular url', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$schema = 'wrong';
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -170,11 +147,12 @@ describe('validateDataContractFactory', function main() {
 
   describe('ownerId', () => {
     it('should be present', async () => {
+      const rawDataContract = dataContract.toObject();
       delete rawDataContract.ownerId;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -184,26 +162,26 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be a byte array', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.ownerId = new Array(32).fill('string');
 
-      const result = await validateDataContract(rawDataContract);
-
-      expectJsonSchemaError(result, 2);
-
-      const [error, byteArrayError] = result.getErrors();
-
-      expect(error.getInstancePath()).to.equal('/ownerId/0');
-      expect(error.getKeyword()).to.equal('type');
-
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
+      // We decided to keep protocol error because of failed parse rather than doing hacks
+      // too keep it until validator will refuse it
+      try {
+        await validateDataContract(rawDataContract);
+        expect.fail('Should throw an error');
+      } catch (e) {
+        expect(e).to.have.string('invalid type: string');
+      }
     });
 
     it('should be no less than 32 bytes', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.ownerId = Buffer.alloc(31);
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -212,11 +190,12 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be no longer than 32 bytes', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.ownerId = Buffer.alloc(33);
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -227,11 +206,12 @@ describe('validateDataContractFactory', function main() {
 
   describe('$id', () => {
     it('should be present', async () => {
+      const rawDataContract = dataContract.toObject();
       delete rawDataContract.$id;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -241,26 +221,26 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be a byte array', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$id = new Array(32).fill('string');
 
-      const result = await validateDataContract(rawDataContract);
-
-      expectJsonSchemaError(result, 2);
-
-      const [error, byteArrayError] = result.getErrors();
-
-      expect(error.getInstancePath()).to.equal('/$id/0');
-      expect(error.getKeyword()).to.equal('type');
-
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
+      // We decided to keep protocol error because of failed parse rather than doing hacks
+      // too keep it until validator will refuse it
+      try {
+        await validateDataContract(rawDataContract);
+        expect.fail('Should throw an error');
+      } catch (e) {
+        expect(e).to.have.string('invalid type: string');
+      }
     });
 
     it('should be no less than 32 bytes', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$id = Buffer.alloc(31);
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -269,11 +249,12 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be no longer than 32 bytes', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$id = Buffer.alloc(33);
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -284,6 +265,7 @@ describe('validateDataContractFactory', function main() {
 
   describe('$defs', () => {
     it('may not be present', async () => {
+      const rawDataContract = dataContract.toObject();
       delete rawDataContract.$defs;
       delete rawDataContract.documents.prettyDocument;
 
@@ -294,11 +276,12 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be an object', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$defs = 1;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -307,11 +290,12 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should not be empty', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$defs = {};
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -320,24 +304,39 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should have no non-alphanumeric properties', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$defs = {
         $subSchema: {},
       };
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result, 2);
-
-      const [patternError, propertyNamesError] = result.getErrors();
+      await expectJsonSchemaError(result);
 
-      expect(patternError.getInstancePath()).to.equal('/$defs');
-      expect(patternError.getKeyword()).to.equal('pattern');
+      const [propertyNamesError] = result.getErrors();
 
       expect(propertyNamesError.getInstancePath()).to.equal('/$defs');
       expect(propertyNamesError.getKeyword()).to.equal('propertyNames');
     });
 
+    it('should have valid properties\' values', async () => {
+      const rawDataContract = dataContract.toObject();
+      rawDataContract.$defs = {
+        yeet: '3a1u9a',
+      };
+
+      const result = await validateDataContract(rawDataContract);
+
+      await expectJsonSchemaError(result, 2);
+
+      const [valueTypeError] = result.getErrors();
+
+      expect(valueTypeError.getInstancePath()).to.equal('/$defs/yeet');
+      expect(valueTypeError.getKeyword()).to.equal('type');
+    });
+
     it('should have no more than 100 properties', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.$defs = {};
 
       Array(101).fill({ type: 'string' }).forEach((item, i) => {
@@ -346,7 +345,7 @@ describe('validateDataContractFactory', function main() {
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -361,20 +360,20 @@ describe('validateDataContractFactory', function main() {
 
       await Promise.all(
         validNames.map(async (name) => {
-          const clonedDataContract = lodashCloneDeep(rawDataContract);
+          const rawDataContract = dataContract.toObject();
 
-          clonedDataContract.$defs = {};
-          clonedDataContract.$defs[name] = {
+          rawDataContract.$defs = {};
+          rawDataContract.$defs[name] = {
             type: 'string',
           };
 
-          clonedDataContract.$defs[name] = {
+          rawDataContract.$defs[name] = {
             type: 'string',
           };
 
-          const result = await validateDataContract(clonedDataContract);
+          const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result, 0);
+          await expectJsonSchemaError(result, 0);
         }),
       );
     });
@@ -384,21 +383,21 @@ describe('validateDataContractFactory', function main() {
 
       await Promise.all(
         invalidNames.map(async (name) => {
-          const clonedDataContract = lodashCloneDeep(rawDataContract);
+          const rawDataContract = dataContract.toObject();
 
-          clonedDataContract.$defs = {};
-          clonedDataContract.$defs[name] = {
+          rawDataContract.$defs = {};
+          rawDataContract.$defs[name] = {
             type: 'string',
           };
 
-          const result = await validateDataContract(clonedDataContract);
+          const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result, 2);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
           expect(error.getInstancePath()).to.equal('/$defs');
-          expect(error.getKeyword()).to.equal('pattern');
+          expect(error.getKeyword()).to.equal('propertyNames');
         }),
       );
     });
@@ -406,11 +405,12 @@ describe('validateDataContractFactory', function main() {
 
   describe('documents', () => {
     it('should be present', async () => {
+      const rawDataContract = dataContract.toObject();
       delete rawDataContract.documents;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -420,11 +420,12 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should be an object', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents = 1;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -433,11 +434,12 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should not be empty', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents = {};
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -446,6 +448,7 @@ describe('validateDataContractFactory', function main() {
     });
 
     it('should have valid property names (document types)', async () => {
+      const rawDataContract = dataContract.toObject();
       const validNames = ['validName', 'valid_name', 'valid-name', 'abc', 'a123123bc', 'ab123c', 'ValidName', 'validName',
         'abcdefghigklmnopqrstuvwxyz01234567890abcdefghigklmnopqrstuvwxyz', 'abc_gbf_gdb', 'abc-gbf-gdb'];
 
@@ -457,12 +460,13 @@ describe('validateDataContractFactory', function main() {
 
           const result = await validateDataContract(clonedDataContract);
 
-          expectJsonSchemaError(result, 0);
+          await expectJsonSchemaError(result, 0);
         }),
       );
     });
 
     it('should return an invalid result if a property (document type) has invalid format', async () => {
+      const rawDataContract = dataContract.toObject();
       const invalidNames = ['*(*&^', '$test', '.', '.a'];
 
       await Promise.all(
@@ -473,17 +477,18 @@ describe('validateDataContractFactory', function main() {
 
           const result = await validateDataContract(clonedDataContract);
 
-          expectJsonSchemaError(result, 2);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
           expect(error.getInstancePath()).to.equal('/documents');
-          expect(error.getKeyword()).to.equal('pattern');
+          expect(error.getKeyword()).to.equal('propertyNames');
         }),
       );
     });
 
     it('should have no more than 100 properties', async () => {
+      const rawDataContract = dataContract.toObject();
       const niceDocumentDefinition = rawDataContract.documents.niceDocument;
 
       rawDataContract.documents = {};
@@ -494,7 +499,7 @@ describe('validateDataContractFactory', function main() {
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -504,46 +509,50 @@ describe('validateDataContractFactory', function main() {
 
     describe('Document schema', () => {
       it('should not be empty', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.niceDocument.properties = {};
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument/properties');
+        expect(error.getInstancePath()).to.equal('/documents/niceDocument/properties');
         expect(error.getKeyword()).to.equal('minProperties');
       });
 
       it('should have type "object"', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.niceDocument.type = 'string';
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument/type');
+        expect(error.getInstancePath()).to.equal('/documents/niceDocument/type');
         expect(error.getKeyword()).to.equal('const');
       });
 
       it('should have "properties"', async () => {
+        const rawDataContract = dataContract.toObject();
         delete rawDataContract.documents.niceDocument.properties;
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument');
+        expect(error.getInstancePath()).to.equal('/documents/niceDocument');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('properties');
       });
 
       it('should have nested "properties"', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.niceDocument.properties.object = {
           type: 'array',
           prefixItems: [
@@ -562,16 +571,17 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 3);
+        await expectJsonSchemaError(result, 8);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument/properties/object/prefixItems/0/properties/something');
+        expect(error.getInstancePath()).to.equal('/documents/niceDocument/properties/object/prefixItems/0/properties/something');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('properties');
       });
 
       it('should have valid property names', async () => {
+        const rawDataContract = dataContract.toObject();
         const validNames = ['validName', 'valid_name', 'valid-name', 'abc', 'a123bc', 'abc123', 'ValidName', 'validName',
           'abcdefghigklmnopqrstuvwxyz01234567890abcdefghigklmnopqrstuvwxyz', 'abc_gbf_gdb', 'abc-gbf-gdb'];
 
@@ -585,12 +595,13 @@ describe('validateDataContractFactory', function main() {
 
             const result = await validateDataContract(clonedDataContract);
 
-            expectJsonSchemaError(result, 0);
+            await expectJsonSchemaError(result, 0);
           }),
         );
       });
 
       it('should have valid nested property names', async () => {
+        const rawDataContract = dataContract.toObject();
         const validNames = ['validName', 'valid_name', 'valid-name', 'abc', 'a123bc', 'abc123', 'ValidName', 'validName',
           'abcdefghigklmnopqrstuvwxyz01234567890abcdefghigklmnopqrstuvwxyz', 'abc_gbf_gdb', 'abc-gbf-gdb'];
 
@@ -610,12 +621,13 @@ describe('validateDataContractFactory', function main() {
 
             const result = await validateDataContract(clonedDataContract);
 
-            expectJsonSchemaError(result, 0);
+            await expectJsonSchemaError(result, 0);
           }),
         );
       });
 
       it('should return an invalid result if a property has invalid format', async () => {
+        const rawDataContract = dataContract.toObject();
         const invalidNames = ['*(*&^', '$test', '.', '.a'];
 
         await Promise.all(
@@ -626,19 +638,18 @@ describe('validateDataContractFactory', function main() {
 
             const result = await validateDataContract(clonedDataContract);
 
-            expectJsonSchemaError(result, 3);
+            await expectJsonSchemaError(result, 2);
 
-            const errors = result.getErrors();
+            const [error] = result.getErrors();
 
-            expect(errors[0].instancePath).to.equal('/documents/niceDocument/properties');
-            expect(errors[0].keyword).to.equal('pattern');
-            expect(errors[1].instancePath).to.equal('/documents/niceDocument/properties');
-            expect(errors[1].keyword).to.equal('propertyNames');
+            expect(error.getInstancePath()).to.equal('/documents/niceDocument/properties');
+            expect(error.getKeyword()).to.equal('propertyNames');
           }),
         );
       });
 
       it('should return an invalid result if a nested property has invalid format', async () => {
+        const rawDataContract = dataContract.toObject();
         const invalidNames = ['*(*&^', '$test', '.', '.a'];
 
         rawDataContract.documents.niceDocument.properties.something = {
@@ -654,50 +665,49 @@ describe('validateDataContractFactory', function main() {
 
             const result = await validateDataContract(clonedDataContract);
 
-            expectJsonSchemaError(result, 4);
+            await expectJsonSchemaError(result, 4);
 
-            const errors = result.getErrors();
+            const [errors] = result.getErrors();
 
-            expect(errors[0].instancePath).to.equal(
-              '/documents/niceDocument/properties/something/properties',
-            );
-            expect(errors[0].keyword).to.equal('pattern');
-            expect(errors[1].instancePath).to.equal(
+            expect(errors.getInstancePath()).to.equal(
               '/documents/niceDocument/properties/something/properties',
             );
-            expect(errors[1].keyword).to.equal('propertyNames');
+            expect(errors.getKeyword()).to.equal('propertyNames');
           }),
         );
       });
 
       it('should have "additionalProperties" defined', async () => {
+        const rawDataContract = dataContract.toObject();
         delete rawDataContract.documents.niceDocument.additionalProperties;
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument');
+        expect(error.getInstancePath()).to.equal('/documents/niceDocument');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('additionalProperties');
       });
 
       it('should have "additionalProperties" defined to false', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.niceDocument.additionalProperties = true;
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument/additionalProperties');
+        expect(error.getInstancePath()).to.equal('/documents/niceDocument/additionalProperties');
         expect(error.getKeyword()).to.equal('const');
       });
 
       it('should have nested "additionalProperties" defined', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.niceDocument.properties.object = {
           type: 'array',
           prefixItems: [
@@ -715,30 +725,32 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument/properties/object/prefixItems/0');
+        expect(error.getInstancePath()).to.equal('/documents/niceDocument/properties/object/prefixItems/0');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('additionalProperties');
       });
 
       it('should return invalid result if there are additional properties', async () => {
-        rawDataContract.additionalProperty = { };
+        const rawDataContract = dataContract.toObject();
+        rawDataContract.additionalProperty = {};
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('');
+        expect(error.getInstancePath()).to.equal('');
         expect(error.getKeyword()).to.equal('additionalProperties');
       });
 
       it('should have no more than 100 properties', async () => {
-        const propertyDefinition = { };
+        const rawDataContract = dataContract.toObject();
+        const propertyDefinition = {};
 
         rawDataContract.documents.niceDocument.properties = {};
 
@@ -748,15 +760,16 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 406);
 
-        const [error] = result.getErrors();
+        const errors = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/niceDocument/properties');
-        expect(error.getKeyword()).to.equal('maxProperties');
+        expect(errors[405].getInstancePath()).to.equal('/documents/niceDocument/properties');
+        expect(errors[405].getKeyword()).to.equal('maxProperties');
       });
 
       it('should have defined items for arrays', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.new = {
           properties: {
             something: {
@@ -768,16 +781,17 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/new/properties/something');
+        expect(error.getInstancePath()).to.equal('/documents/new/properties/something');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('items');
       });
 
       it('should have sub schema in items for arrays', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.new = {
           properties: {
             something: {
@@ -797,16 +811,17 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 3);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/new/properties/something/items');
+        expect(error.getInstancePath()).to.equal('/documents/new/properties/something/items');
         expect(error.getKeyword()).to.equal('type');
         expect(error.getParams().type).to.equal('object');
       });
 
       it('should have items if prefixItems is used for arrays', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.new = {
           type: 'object',
           properties: {
@@ -828,16 +843,17 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 4);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/new/properties/something');
+        expect(error.getInstancePath()).to.equal('/documents/new/properties/something');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('items');
       });
 
       it('should not have items disabled if prefixItems is used for arrays', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.new = {
           properties: {
             something: {
@@ -858,44 +874,47 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/new/properties/something/items');
+        expect(error.getInstancePath()).to.equal('/documents/new/properties/something/items');
         expect(error.getKeyword()).to.equal('const');
         expect(error.getParams().allowedValue).to.equal(false);
       });
 
       it('should return invalid result if "default" keyword is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument.properties.firstName.default = '1';
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/properties/firstName');
-        expect(error.getKeyword()).to.equal('unevaluatedProperties');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/properties/firstName/default');
+        expect(error.getKeyword()).to.equal('falseSchema');
       });
 
-      it.skip('should return invalid result if remote `$ref` is used', async () => {
+      it('should return invalid result if remote `$ref` is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           $ref: 'http://remote.com/schema#',
         };
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/$ref');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/$ref');
         expect(error.getKeyword()).to.equal('pattern');
       });
 
       it('should not have `propertyNames`', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -911,16 +930,16 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument');
-        expect(error.getKeyword()).to.equal('unevaluatedProperties');
-        expect(error.getParams().unevaluatedProperty).to.equal('propertyNames');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/propertyNames');
+        expect(error.getKeyword()).to.equal('falseSchema');
       });
 
       it('should have `maxItems` if `uniqueItems` is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -934,16 +953,17 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 4);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/properties/something');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/properties/something');
         expect(error.getKeyword()).to.equal('required');
-        expect(error.getParams().missingProperty).to.equal('items');
+        expect(error.getParams().missingProperty).to.equal('maxItems');
       });
 
       it('should have `maxItems` no bigger than 100000 if `uniqueItems` is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -967,15 +987,16 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/properties/something/maxItems');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/properties/something/maxItems');
         expect(error.getKeyword()).to.equal('maximum');
       });
 
       it('should return invalid result if document JSON Schema is not valid', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -993,15 +1014,13 @@ describe('validateDataContractFactory', function main() {
         expectValidationError(result, JsonSchemaCompilationError);
 
         const [error] = result.getErrors();
-
-        expect(error.getCode()).to.equal(1004);
-
-        expect(error.message).to.be.a('string').and.satisfy((msg) => (
-          msg.startsWith('unknown format "lalala" ignored in schema')
-        ));
+        // TODO: should be a JsonSchemaCompilationerror instead of JsonSchemaError
+        expect(error.getCode()).to.equal(1005);
+        expect(error.getKeyword()).to.equal('format');
       });
 
       it('should have `maxLength` if `pattern` is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -1015,16 +1034,17 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/properties/something');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/properties/something');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('maxLength');
       });
 
       it('should have `maxLength` no bigger than 50000 if `pattern` is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -1039,15 +1059,16 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/properties/something/maxLength');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/properties/something/maxLength');
         expect(error.getKeyword()).to.equal('maximum');
       });
 
       it('should have `maxLength` if `format` is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -1061,16 +1082,17 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/properties/something');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/properties/something');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('maxLength');
       });
 
       it('should have `maxLength` no bigger than 50000 if `format` is used', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -1085,15 +1107,16 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/properties/something/maxLength');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/properties/something/maxLength');
         expect(error.getKeyword()).to.equal('maximum');
       });
 
       it('should not have incompatible patterns', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument = {
           type: 'object',
           properties: {
@@ -1115,52 +1138,55 @@ describe('validateDataContractFactory', function main() {
         expect(error.getCode()).to.equal(1009);
         expect(error.getPattern()).to.equal('^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$');
         expect(error.getPath()).to.equal('/documents/indexedDocument/properties/something');
-        expect(error.getPatternError()).to.be.instanceOf(Error);
       });
 
       describe('byteArray', () => {
         it('should be a boolean', async () => {
+          const rawDataContract = dataContract.toObject();
           rawDataContract.documents.withByteArrays.properties.byteArrayField.byteArray = 1;
 
           const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result, 2);
+          await expectJsonSchemaError(result, 4);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal('/documents/withByteArrays/properties/byteArrayField/byteArray');
+          expect(error.getInstancePath()).to.equal('/documents/withByteArrays/properties/byteArrayField/byteArray');
           expect(error.getKeyword()).to.equal('type');
           expect(error.getParams().type).to.equal('boolean');
         });
 
         it('should equal to true', async () => {
+          const rawDataContract = dataContract.toObject();
           rawDataContract.documents.withByteArrays.properties.byteArrayField.byteArray = false;
 
           const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result, 2);
+          await expectJsonSchemaError(result, 2);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal('/documents/withByteArrays/properties/byteArrayField/byteArray');
+          expect(error.getInstancePath()).to.equal('/documents/withByteArrays/properties/byteArrayField/byteArray');
           expect(error.getKeyword()).to.equal('const');
           expect(error.getParams().allowedValue).to.equal(true);
         });
 
         it('should be used with type `array`', async () => {
+          const rawDataContract = dataContract.toObject();
           rawDataContract.documents.withByteArrays.properties.byteArrayField.type = 'string';
 
           const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result, 2);
+          await expectJsonSchemaError(result, 2);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal('/documents/withByteArrays/properties/byteArrayField/type');
+          expect(error.getInstancePath()).to.equal('/documents/withByteArrays/properties/byteArrayField/type');
           expect(error.getKeyword()).to.equal('const');
         });
 
         it('should not be used with `items`', async () => {
+          const rawDataContract = dataContract.toObject();
           rawDataContract.documents.withByteArrays.properties.byteArrayField.items = {
             type: 'string',
           };
@@ -1172,48 +1198,50 @@ describe('validateDataContractFactory', function main() {
           const [error] = result.getErrors();
 
           expect(error.getCode()).to.equal(1004);
-          expect(error.message).to.equal("'byteArray' should not be used with 'items'");
         });
       });
 
       describe('contentMediaType', () => {
         describe('application/x.dash.dpp.identifier', () => {
           it('should be used with byte array only', async () => {
+            const rawDataContract = dataContract.toObject();
             delete rawDataContract.documents.withByteArrays.properties.identifierField.byteArray;
 
             const result = await validateDataContract(rawDataContract);
 
-            expectJsonSchemaError(result, 2);
+            await expectJsonSchemaError(result, 4);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/documents/withByteArrays/properties/identifierField');
+            expect(error.getInstancePath()).to.equal('/documents/withByteArrays/properties/identifierField');
             expect(error.getKeyword()).to.equal('required');
           });
 
           it('should be used with byte array not shorter than 32 bytes', async () => {
+            const rawDataContract = dataContract.toObject();
             rawDataContract.documents.withByteArrays.properties.identifierField.minItems = 31;
 
             const result = await validateDataContract(rawDataContract);
 
-            expectJsonSchemaError(result, 2);
+            await expectJsonSchemaError(result, 2);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/documents/withByteArrays/properties/identifierField/minItems');
+            expect(error.getInstancePath()).to.equal('/documents/withByteArrays/properties/identifierField/minItems');
             expect(error.getKeyword()).to.equal('const');
           });
 
           it('should be used with byte array not longer than 32 bytes', async () => {
+            const rawDataContract = dataContract.toObject();
             rawDataContract.documents.withByteArrays.properties.identifierField.maxItems = 31;
 
             const result = await validateDataContract(rawDataContract);
 
-            expectJsonSchemaError(result, 2);
+            await expectJsonSchemaError(result, 2);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal('/documents/withByteArrays/properties/identifierField/maxItems');
+            expect(error.getInstancePath()).to.equal('/documents/withByteArrays/properties/identifierField/maxItems');
             expect(error.getKeyword()).to.equal('const');
           });
         });
@@ -1223,32 +1251,35 @@ describe('validateDataContractFactory', function main() {
 
   describe('indices', () => {
     it('should be an array', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.indexedDocument.indices = 'definitely not an array';
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/documents/indexedDocument/indices');
+      expect(error.getInstancePath()).to.equal('/documents/indexedDocument/indices');
       expect(error.getKeyword()).to.equal('type');
     });
 
     it('should have at least one item', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.indexedDocument.indices = [];
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/documents/indexedDocument/indices');
+      expect(error.getInstancePath()).to.equal('/documents/indexedDocument/indices');
       expect(error.getKeyword()).to.equal('minItems');
     });
 
     it('should return invalid result if there are duplicated indices', async () => {
+      const rawDataContract = dataContract.toObject();
       const indexDefinition = {
         ...rawDataContract.documents.indexedDocument.indices[0],
         name: 'otherIndexName',
@@ -1263,11 +1294,12 @@ describe('validateDataContractFactory', function main() {
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(1008);
-      expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+      expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
       expect(error.getDocumentType()).to.deep.equal('indexedDocument');
     });
 
     it('should return invalid result if there are duplicated index names', async () => {
+      const rawDataContract = dataContract.toObject();
       const indexDefinition = {
         ...rawDataContract.documents.indexedDocument.indices[0],
       };
@@ -1287,66 +1319,71 @@ describe('validateDataContractFactory', function main() {
 
     describe('index', () => {
       it('should be an object', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument.indices = ['something else'];
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/indices/0');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/indices/0');
         expect(error.getKeyword()).to.equal('type');
       });
 
       it('should have properties definition', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument.indices = [{}];
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result, 2);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/indices/0');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/indices/0');
         expect(error.getParams().missingProperty).to.equal('properties');
         expect(error.getKeyword()).to.equal('required');
       });
 
       describe('properties definition', () => {
         it('should be an array', async () => {
+          const rawDataContract = dataContract.toObject();
           rawDataContract.documents.indexedDocument.indices[0]
             .properties = 'something else';
 
           const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal(
+          expect(error.getInstancePath()).to.equal(
             '/documents/indexedDocument/indices/0/properties',
           );
           expect(error.getKeyword()).to.equal('type');
         });
 
         it('should have at least one property defined', async () => {
+          const rawDataContract = dataContract.toObject();
           rawDataContract.documents.indexedDocument.indices[0]
             .properties = [];
 
           const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal(
+          expect(error.getInstancePath()).to.equal(
             '/documents/indexedDocument/indices/0/properties',
           );
           expect(error.getKeyword()).to.equal('minItems');
         });
 
         it('should have no more than 10 property $defs', async () => {
+          const rawDataContract = dataContract.toObject();
           for (let i = 0; i < 10; i++) {
             rawDataContract.documents.indexedDocument.indices[0]
               .properties.push({ [`field${i}`]: 'asc' });
@@ -1354,11 +1391,11 @@ describe('validateDataContractFactory', function main() {
 
           const result = await validateDataContract(rawDataContract);
 
-          expectJsonSchemaError(result);
+          await expectJsonSchemaError(result);
 
           const [error] = result.getErrors();
 
-          expect(error.instancePath).to.equal(
+          expect(error.getInstancePath()).to.equal(
             '/documents/indexedDocument/indices/0/properties',
           );
           expect(error.getKeyword()).to.equal('maxItems');
@@ -1366,38 +1403,41 @@ describe('validateDataContractFactory', function main() {
 
         describe('property definition', () => {
           it('should be an object', async () => {
+            const rawDataContract = dataContract.toObject();
             rawDataContract.documents.indexedDocument.indices[0]
               .properties[0] = 'something else';
 
             const result = await validateDataContract(rawDataContract);
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal(
+            expect(error.getInstancePath()).to.equal(
               '/documents/indexedDocument/indices/0/properties/0',
             );
             expect(error.getKeyword()).to.equal('type');
           });
 
           it('should have at least one property', async () => {
+            const rawDataContract = dataContract.toObject();
             rawDataContract.documents.indexedDocument.indices[0]
               .properties = [];
 
             const result = await validateDataContract(rawDataContract);
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal(
+            expect(error.getInstancePath()).to.equal(
               '/documents/indexedDocument/indices/0/properties',
             );
             expect(error.getKeyword()).to.equal('minItems');
           });
 
           it('should have no more than one property', async () => {
+            const rawDataContract = dataContract.toObject();
             const property = rawDataContract.documents.indexedDocument.indices[0]
               .properties[0];
 
@@ -1405,27 +1445,28 @@ describe('validateDataContractFactory', function main() {
 
             const result = await validateDataContract(rawDataContract);
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result, 2);
 
-            const [error] = result.getErrors();
+            const error = result.getErrors()[1];
 
-            expect(error.instancePath).to.equal(
+            expect(error.getInstancePath()).to.equal(
               '/documents/indexedDocument/indices/0/properties/0',
             );
             expect(error.getKeyword()).to.equal('maxProperties');
           });
 
           it('should have property values only "asc" or "desc"', async () => {
+            const rawDataContract = dataContract.toObject();
             rawDataContract.documents.indexedDocument.indices[0]
               .properties[0].$ownerId = 'wrong';
 
             const result = await validateDataContract(rawDataContract);
 
-            expectJsonSchemaError(result);
+            await expectJsonSchemaError(result);
 
             const [error] = result.getErrors();
 
-            expect(error.instancePath).to.equal(
+            expect(error.getInstancePath()).to.equal(
               '/documents/indexedDocument/indices/0/properties/0/$ownerId',
             );
             expect(error.getKeyword()).to.equal('enum');
@@ -1435,6 +1476,7 @@ describe('validateDataContractFactory', function main() {
 
       describe('property names', () => {
         it('should have valid property names (indices)', async () => {
+          const rawDataContract = dataContract.toObject();
           const validNames = ['validName', 'valid_name', 'valid-name', 'abc', 'a123123bc', 'ab123c', 'ValidName', 'validName',
             'abcdefghigklmnopqrstuvwxyz01234567890abcdefghigklmnopqrstuvwxyz', 'abc_gbf_gdb', 'abc-gbf-gdb'];
 
@@ -1448,12 +1490,13 @@ describe('validateDataContractFactory', function main() {
 
               const result = await validateDataContract(clonedDataContract);
 
-              expectJsonSchemaError(result, 0);
+              await expectJsonSchemaError(result, 0);
             }),
           );
         });
 
         it('should return an invalid result if a property (indices) has invalid format', async () => {
+          const rawDataContract = dataContract.toObject();
           const invalidNames = ['a.', '.a'];
 
           rawDataContract.documents.indexedDocument = {
@@ -1495,19 +1538,21 @@ describe('validateDataContractFactory', function main() {
       });
 
       it('should have "unique" flag to be of a boolean type', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedDocument.indices[0].unique = 12;
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/documents/indexedDocument/indices/0/unique');
+        expect(error.getInstancePath()).to.equal('/documents/indexedDocument/indices/0/unique');
         expect(error.getKeyword()).to.equal('type');
       });
 
       it('should have no more than 10 indices', async () => {
+        const rawDataContract = dataContract.toObject();
         for (let i = 0; i < 10; i++) {
           const propertyName = `field${i}`;
 
@@ -1520,17 +1565,18 @@ describe('validateDataContractFactory', function main() {
 
         const result = await validateDataContract(rawDataContract);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result, 11);
 
-        const [error] = result.getErrors();
+        const error = result.getErrors()[10];
 
-        expect(error.instancePath).to.equal(
+        expect(error.getInstancePath()).to.equal(
           '/documents/indexedDocument/indices',
         );
         expect(error.getKeyword()).to.equal('maxItems');
       });
 
       it('should have no more than 3 unique indices', async () => {
+        const rawDataContract = dataContract.toObject();
         for (let i = 0; i < 4; i++) {
           const propertyName = `field${i}`;
 
@@ -1557,6 +1603,7 @@ describe('validateDataContractFactory', function main() {
       });
 
       it('should return invalid result if $id is specified as an indexed property', async () => {
+        const rawDataContract = dataContract.toObject();
         const indexDefinition = {
           name: 'index_1',
           properties: [
@@ -1578,10 +1625,11 @@ describe('validateDataContractFactory', function main() {
         expect(error.getCode()).to.equal(1015);
         expect(error.getPropertyName()).to.equal('$id');
         expect(error.getDocumentType()).to.deep.equal('indexedDocument');
-        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
       });
 
       it('should return invalid result if indices has undefined property', async () => {
+        const rawDataContract = dataContract.toObject();
         const indexDefinition = rawDataContract.documents.indexedDocument.indices[0];
 
         indexDefinition.properties.push({
@@ -1597,10 +1645,11 @@ describe('validateDataContractFactory', function main() {
         expect(error.getCode()).to.equal(1016);
         expect(error.getPropertyName()).to.equal('missingProperty');
         expect(error.getDocumentType()).to.deep.equal('indexedDocument');
-        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
       });
 
       it('should return invalid result if index property is object', async () => {
+        const rawDataContract = dataContract.toObject();
         const indexedDocumentDefinition = rawDataContract.documents.indexedDocument;
 
         indexedDocumentDefinition.properties.objectProperty = {
@@ -1631,10 +1680,11 @@ describe('validateDataContractFactory', function main() {
         expect(error.getPropertyName()).to.equal('objectProperty');
         expect(error.getPropertyType()).to.equal('object');
         expect(error.getDocumentType()).to.deep.equal('indexedDocument');
-        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
       });
 
       it('should return invalid result if index property is an array', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.indexedArray = {
           type: 'object',
           indices: [
@@ -1674,167 +1724,177 @@ describe('validateDataContractFactory', function main() {
         expect(error.getPropertyName()).to.equal('mentions');
         expect(error.getPropertyType()).to.equal('array');
         expect(error.getDocumentType()).to.deep.equal('indexedArray');
-        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
+      });
+
+      it('should return invalid result if index property is array of objects', async () => {
+        const rawDataContract = dataContract.toObject();
+        const indexedDocumentDefinition = rawDataContract.documents.indexedDocument;
+
+        indexedDocumentDefinition.properties.arrayProperty = {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              something: {
+                type: 'string',
+              },
+            },
+            additionalProperties: false,
+          },
+        };
+
+        indexedDocumentDefinition.required.push('arrayProperty');
+
+        const indexDefinition = indexedDocumentDefinition.indices[0];
+
+        indexDefinition.properties.push({
+          arrayProperty: 'asc',
+        });
+
+        const result = await validateDataContract(rawDataContract);
+
+        expectValidationError(result, InvalidIndexPropertyTypeError);
+
+        const [error] = result.getErrors();
+
+        expect(error.getCode()).to.equal(1013);
+        expect(error.getPropertyName()).to.equal('arrayProperty');
+        expect(error.getPropertyType()).to.equal('array');
+        expect(error.getDocumentType()).to.deep.equal('indexedDocument');
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
       });
 
-      // it('should return invalid result if index property is array of objects', async () => {
-      //   const indexedDocumentDefinition = rawDataContract.documents.indexedDocument;
-      //
-      //   indexedDocumentDefinition.properties.arrayProperty = {
-      //     type: 'array',
-      //     items: {
-      //       type: 'object',
-      //       properties: {
-      //         something: {
-      //           type: 'string',
-      //         },
-      //       },
-      //       additionalProperties: false,
-      //     },
-      //   };
-      //
-      //   indexedDocumentDefinition.required.push('arrayProperty');
-      //
-      //   const indexDefinition = indexedDocumentDefinition.indices[0];
-      //
-      //   indexDefinition.properties.push({
-      //     arrayProperty: 'asc',
-      //   });
-      //
-      //   const result = await validateDataContract(rawDataContract);
-      //
-      //   expectValidationError(result, InvalidIndexPropertyTypeError);
-      //
-      //   const [error] = result.getErrors();
-      //
-      //   expect(error.getCode()).to.equal(1013);
-      //   expect(error.getPropertyName()).to.equal('arrayProperty');
-      //   expect(error.getPropertyType()).to.equal('array');
-      //   expect(error.getDocumentType()).to.deep.equal('indexedDocument');
-      //   expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
-      // });
-
-      // it('should return invalid result if index property is an array of different types',
-      // async () => {
-      //   const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
-      //
-      //   const indexDefinition = indexedDocumentDefinition.indices[0];
-      //
-      //   rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
-      //     {
-      //       type: 'string',
-      //     },
-      //     {
-      //       type: 'number',
-      //     },
-      //   ];
-      //
-      //   rawDataContract.documents.indexedArray.properties.mentions.minItems = 2;
-      //
-      //   const result = await validateDataContract(rawDataContract);
-      //   expectValidationError(result, InvalidIndexPropertyTypeError);
-      //
-      //   const error = result.getFirstError();
-      //
-      //   expect(error.getCode()).to.equal(1013);
-      //   expect(error.getPropertyName()).to.equal('mentions');
-      //   expect(error.getPropertyType()).to.equal('array');
-      //   expect(error.getDocumentType()).to.deep.equal('indexedArray');
-      //   expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
-      // });
-      //
-      // it('should return invalid result if index property contained prefixItems array of arrays',
-      // async () => {
-      //   const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
-      //
-      //   const indexDefinition = indexedDocumentDefinition.indices[0];
-      //
-      //   rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
-      //     {
-      //       type: 'array',
-      //       items: {
-      //         type: 'string',
-      //       },
-      //     },
-      //   ];
-      //
-      //   const result = await validateDataContract(rawDataContract);
-      //   expectValidationError(result, InvalidIndexPropertyTypeError);
-      //
-      //   const error = result.getFirstError();
-      //
-      //   expect(error.getCode()).to.equal(1013);
-      //   expect(error.getPropertyName()).to.equal('mentions');
-      //   expect(error.getPropertyType()).to.equal('array');
-      //   expect(error.getDocumentType()).to.deep.equal('indexedArray');
-      //   expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
-      // });
-
-      // it('should return invalid result if index property contained prefixItems array of objects',
-      // async () => {
-      //   const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
-      //
-      //   const indexDefinition = indexedDocumentDefinition.indices[0];
-      //
-      //   rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
-      //     {
-      //       type: 'object',
-      //       properties: {
-      //         something: {
-      //           type: 'string',
-      //         },
-      //       },
-      //       additionalProperties: false,
-      //     },
-      //   ];
-      //
-      //   const result = await validateDataContract(rawDataContract);
-      //   expectValidationError(result, InvalidIndexPropertyTypeError);
-      //
-      //   const error = result.getFirstError();
-      //
-      //   expect(error.getCode()).to.equal(1013);
-      //   expect(error.getPropertyName()).to.equal('mentions');
-      //   expect(error.getPropertyType()).to.equal('array');
-      //   expect(error.getDocumentType()).to.deep.equal('indexedArray');
-      //   expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
-      // });
-      //
-      // it('should return invalid result if index property is array of arrays', async () => {
-      //   const indexedDocumentDefinition = rawDataContract.documents.indexedDocument;
-      //
-      //   indexedDocumentDefinition.properties.arrayProperty = {
-      //     type: 'array',
-      //     items: {
-      //       type: 'array',
-      //       items: {
-      //         type: 'string',
-      //       },
-      //     },
-      //   };
-      //
-      //   indexedDocumentDefinition.required.push('arrayProperty');
-      //
-      //   const indexDefinition = indexedDocumentDefinition.indices[0];
-      //
-      //   indexDefinition.properties.push({
-      //     arrayProperty: 'asc',
-      //   });
-      //
-      //   const result = await validateDataContract(rawDataContract);
-      //
-      //   expectValidationError(result, InvalidIndexPropertyTypeError);
-      //
-      //   const [error] = result.getErrors();
-      //
-      //   expect(error.getCode()).to.equal(1013);
-      //   expect(error.getPropertyName()).to.equal('arrayProperty');
-      //   expect(error.getPropertyType()).to.equal('array');
-      //   expect(error.getDocumentType()).to.deep.equal('indexedDocument');
-      //   expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
-      // });
+      // TODO: support indexed arrays
+      it.skip('should return invalid result if index property is an array of different types',
+        async () => {
+          const rawDataContract = dataContract.toObject();
+
+          const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
+
+          const indexDefinition = indexedDocumentDefinition.indices[0];
+
+          rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
+            {
+              type: 'string',
+            },
+            {
+              type: 'number',
+            },
+          ];
+
+          rawDataContract.documents.indexedArray.properties.mentions.minItems = 2;
+
+          const result = await validateDataContract(rawDataContract);
+          expectValidationError(result, InvalidIndexPropertyTypeError);
+
+          const error = result.getFirstError();
+
+          expect(error.getCode()).to.equal(1013);
+          expect(error.getPropertyName()).to.equal('mentions');
+          expect(error.getPropertyType()).to.equal('array');
+          expect(error.getDocumentType()).to.deep.equal('indexedArray');
+          expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
+        });
+
+      // TODO: support indexed arrays
+      it.skip('should return invalid result if index property contained prefixItems array of arrays', async () => {
+        const rawDataContract = dataContract.toObject();
+
+        const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
+
+        const indexDefinition = indexedDocumentDefinition.indices[0];
+
+        rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
+          {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        ];
+
+        const result = await validateDataContract(rawDataContract);
+        expectValidationError(result, InvalidIndexPropertyTypeError);
+
+        const error = result.getFirstError();
+
+        expect(error.getCode()).to.equal(1013);
+        expect(error.getPropertyName()).to.equal('mentions');
+        expect(error.getPropertyType()).to.equal('array');
+        expect(error.getDocumentType()).to.deep.equal('indexedArray');
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
+      });
+
+      // TODO: support indexed arrays
+      it.skip('should return invalid result if index property contained prefixItems array of objects', async () => {
+        const rawDataContract = dataContract.toObject();
+
+        const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
+
+        const indexDefinition = indexedDocumentDefinition.indices[0];
+
+        rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
+          {
+            type: 'object',
+            properties: {
+              something: {
+                type: 'string',
+              },
+            },
+            additionalProperties: false,
+          },
+        ];
+
+        const result = await validateDataContract(rawDataContract);
+        expectValidationError(result, InvalidIndexPropertyTypeError);
+
+        const error = result.getFirstError();
+
+        expect(error.getCode()).to.equal(1013);
+        expect(error.getPropertyName()).to.equal('mentions');
+        expect(error.getPropertyType()).to.equal('array');
+        expect(error.getDocumentType()).to.deep.equal('indexedArray');
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
+      });
+
+      it('should return invalid result if index property is array of arrays', async () => {
+        const rawDataContract = dataContract.toObject();
+        const indexedDocumentDefinition = rawDataContract.documents.indexedDocument;
+
+        indexedDocumentDefinition.properties.arrayProperty = {
+          type: 'array',
+          items: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        };
+
+        indexedDocumentDefinition.required.push('arrayProperty');
+
+        const indexDefinition = indexedDocumentDefinition.indices[0];
+
+        indexDefinition.properties.push({
+          arrayProperty: 'asc',
+        });
+
+        const result = await validateDataContract(rawDataContract);
+
+        expectValidationError(result, InvalidIndexPropertyTypeError);
+
+        const [error] = result.getErrors();
+
+        expect(error.getCode()).to.equal(1013);
+        expect(error.getPropertyName()).to.equal('arrayProperty');
+        expect(error.getPropertyType()).to.equal('array');
+        expect(error.getDocumentType()).to.deep.equal('indexedDocument');
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
+      });
 
       it('should return invalid result if index property is array with different item definitions', async () => {
+        const rawDataContract = dataContract.toObject();
         const indexedDocumentDefinition = rawDataContract.documents.indexedDocument;
 
         indexedDocumentDefinition.properties.arrayProperty = {
@@ -1869,10 +1929,11 @@ describe('validateDataContractFactory', function main() {
         expect(error.getPropertyName()).to.equal('arrayProperty');
         expect(error.getPropertyType()).to.equal('array');
         expect(error.getDocumentType()).to.deep.equal('indexedDocument');
-        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(indexDefinition);
       });
 
       it('should return invalid result if unique compound index contains both required and optional properties', async () => {
+        const rawDataContract = dataContract.toObject();
         rawDataContract.documents.optionalUniqueIndexedDocument.required.splice(-1);
 
         const result = await validateDataContract(rawDataContract);
@@ -1882,7 +1943,7 @@ describe('validateDataContractFactory', function main() {
         const [error] = result.getErrors();
 
         expect(error.getCode()).to.equal(1010);
-        expect(error.getIndexDefinition()).to.deep.equal(
+        expect(error.getIndexDefinition().toObject()).to.deep.equal(
           rawDataContract.documents.optionalUniqueIndexedDocument.indices[1],
         );
         expect(error.getDocumentType()).to.equal('optionalUniqueIndexedDocument');
@@ -1892,34 +1953,37 @@ describe('validateDataContractFactory', function main() {
 
   describe('signatureSecurityLevelRequirement', () => {
     it('should be a number', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.indexedDocument.signatureSecurityLevelRequirement = 'definitely not a number';
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 2);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/documents/indexedDocument/signatureSecurityLevelRequirement');
+      expect(error.getInstancePath()).to.equal('/documents/indexedDocument/signatureSecurityLevelRequirement');
       expect(error.getKeyword()).to.equal('type');
     });
 
     it('should be one of the available values', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.indexedDocument.signatureSecurityLevelRequirement = 199;
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
-      expect(error.instancePath).to.equal('/documents/indexedDocument/signatureSecurityLevelRequirement');
+      expect(error.getInstancePath()).to.equal('/documents/indexedDocument/signatureSecurityLevelRequirement');
       expect(error.getKeyword()).to.equal('enum');
     });
   });
 
   describe('dependentSchemas', () => {
     it('should be an object', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.niceDocument = {
         type: 'object',
         properties: {
@@ -1933,18 +1997,18 @@ describe('validateDataContractFactory', function main() {
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
       expect(error.getKeyword()).to.equal('type');
-      expect(error.instancePath).to.equal('/documents/niceDocument/dependentSchemas');
-      expect(error.message).to.equal('must be object');
+      expect(error.getInstancePath()).to.equal('/documents/niceDocument/dependentSchemas');
     });
   });
 
   describe('dependentRequired', () => {
     it('should be an object', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.niceDocument = {
         type: 'object',
         properties: {
@@ -1958,16 +2022,16 @@ describe('validateDataContractFactory', function main() {
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
       expect(error.getKeyword()).to.equal('type');
-      expect(error.instancePath).to.equal('/documents/niceDocument/dependentRequired');
-      expect(error.message).to.equal('must be object');
+      expect(error.getInstancePath()).to.equal('/documents/niceDocument/dependentRequired');
     });
 
     it('should have an array value', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.niceDocument = {
         type: 'object',
         properties: {
@@ -1985,16 +2049,16 @@ describe('validateDataContractFactory', function main() {
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
       expect(error.getKeyword()).to.equal('type');
-      expect(error.instancePath).to.equal('/documents/niceDocument/dependentRequired/zxy');
-      expect(error.message).to.equal('must be array');
+      expect(error.getInstancePath()).to.equal('/documents/niceDocument/dependentRequired/zxy');
     });
 
     it('should have an array of strings', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.niceDocument = {
         type: 'object',
         properties: {
@@ -2010,16 +2074,16 @@ describe('validateDataContractFactory', function main() {
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
       expect(error.getKeyword()).to.equal('type');
-      expect(error.instancePath).to.equal('/documents/niceDocument/dependentRequired/zxy/0');
-      expect(error.message).to.equal('must be string');
+      expect(error.getInstancePath()).to.equal('/documents/niceDocument/dependentRequired/zxy/0');
     });
 
     it('should have an array of unique strings', async () => {
+      const rawDataContract = dataContract.toObject();
       rawDataContract.documents.niceDocument = {
         type: 'object',
         properties: {
@@ -2035,17 +2099,18 @@ describe('validateDataContractFactory', function main() {
 
       const result = await validateDataContract(rawDataContract);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
       expect(error.getKeyword()).to.equal('uniqueItems');
-      expect(error.instancePath).to.equal('/documents/niceDocument/dependentRequired/zxy');
-      expect(error.message).to.equal('must NOT have duplicate items (items ## 2 and 1 are identical)');
+      expect(error.getInstancePath()).to.equal('/documents/niceDocument/dependentRequired/zxy');
     });
   });
 
-  it.skip('should return invalid result with circular $ref pointer', async () => {
+  it('should return invalid result with circular $ref pointer', async () => {
+    const rawDataContract = dataContract.toObject();
+    rawDataContract.$defs = {};
     rawDataContract.$defs.object = { $ref: '#/$defs/object' };
 
     const result = await validateDataContract(rawDataContract);
@@ -2055,11 +2120,10 @@ describe('validateDataContractFactory', function main() {
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(1014);
-
-    expect(error.message).to.startsWith('Invalid JSON Schema $ref: Circular $ref pointer found');
   });
 
   it('should return invalid result if indexed string property missing maxLength constraint', async () => {
+    const rawDataContract = dataContract.toObject();
     delete rawDataContract.documents.indexedDocument.properties.firstName.maxLength;
 
     const result = await validateDataContract(rawDataContract);
@@ -2071,10 +2135,11 @@ describe('validateDataContractFactory', function main() {
     expect(error.getCode()).to.equal(1012);
     expect(error.getPropertyName()).to.equal('firstName');
     expect(error.getConstraintName()).to.equal('maxLength');
-    expect(error.getReason()).to.equal('should be less or equal 63');
+    expect(error.getReason()).to.equal('should be less or equal than 63');
   });
 
   it('should return invalid result if indexed string property have to big maxLength', async () => {
+    const rawDataContract = dataContract.toObject();
     rawDataContract.documents.indexedDocument.properties.firstName.maxLength = 2048;
 
     const result = await validateDataContract(rawDataContract);
@@ -2086,73 +2151,80 @@ describe('validateDataContractFactory', function main() {
     expect(error.getCode()).to.equal(1012);
     expect(error.getPropertyName()).to.equal('firstName');
     expect(error.getConstraintName()).to.equal('maxLength');
+    expect(error.getReason()).to.equal('should be less or equal than 63');
+  });
+
+  // TODO: support indexed arrays
+  it.skip('should return invalid result if indexed array property missing maxItems constraint',
+    async () => {
+      const rawDataContract = dataContract.toObject();
+      delete rawDataContract.documents.indexedArray.properties.mentions.maxItems;
+
+      const result = await validateDataContract(rawDataContract);
+
+      expectValidationError(result, InvalidIndexedPropertyConstraintError);
+
+      const [error] = result.getErrors();
+
+      expect(error.getCode()).to.equal(1012);
+      expect(error.getPropertyName()).to.equal('mentions');
+      expect(error.getConstraintName()).to.equal('maxItems');
+      expect(error.getReason()).to.equal('should be less or equal 63');
+    });
+
+  // TODO support indexed arrays
+  it.skip('should return invalid result if indexed array property have to big maxItems', async () => {
+    const rawDataContract = dataContract.toObject();
+    rawDataContract.documents.indexedArray.properties.mentions.maxItems = 2048;
+
+    const result = await validateDataContract(rawDataContract);
+
+    expectValidationError(result, InvalidIndexedPropertyConstraintError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1012);
+    expect(error.getPropertyName()).to.equal('mentions');
+    expect(error.getConstraintName()).to.equal('maxItems');
+    expect(error.getReason()).to.equal('should be less or equal 63');
+  });
+
+  // TODO support indexed arrays
+  it.skip('should return invalid result if indexed array property have string item without maxItems constraint', async () => {
+    const rawDataContract = dataContract.toObject();
+    delete rawDataContract.documents.indexedArray.properties.mentions.maxItems;
+
+    const result = await validateDataContract(rawDataContract);
+
+    expectValidationError(result, InvalidIndexedPropertyConstraintError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1012);
+    expect(error.getPropertyName()).to.equal('mentions');
+    expect(error.getConstraintName()).to.equal('maxItems');
     expect(error.getReason()).to.equal('should be less or equal 63');
   });
 
-  // it('should return invalid result if indexed array property missing maxItems constraint',
-  // async () => {
-  //   delete rawDataContract.documents.indexedArray.properties.mentions.maxItems;
-  //
-  //   const result = await validateDataContract(rawDataContract);
-  //
-  //   expectValidationError(result, InvalidIndexedPropertyConstraintError);
-  //
-  //   const [error] = result.getErrors();
-  //
-  //   expect(error.getCode()).to.equal(1012);
-  //   expect(error.getPropertyName()).to.equal('mentions');
-  //   expect(error.getConstraintName()).to.equal('maxItems');
-  //   expect(error.getReason()).to.equal('should be less or equal 63');
-  // });
-  //
-  // it('should return invalid result if indexed array property have to big maxItems', async () => {
-  //   rawDataContract.documents.indexedArray.properties.mentions.maxItems = 2048;
-  //
-  //   const result = await validateDataContract(rawDataContract);
-  //
-  //   expectValidationError(result, InvalidIndexedPropertyConstraintError);
-  //
-  //   const [error] = result.getErrors();
-  //
-  //   expect(error.getCode()).to.equal(1012);
-  //   expect(error.getPropertyName()).to.equal('mentions');
-  //   expect(error.getConstraintName()).to.equal('maxItems');
-  //   expect(error.getReason()).to.equal('should be less or equal 63');
-  // });
-  //
-  // it('should return invalid result if indexed array property
-  // have string item without maxItems constraint', async () => {
-  //   delete rawDataContract.documents.indexedArray.properties.mentions.maxItems;
-  //
-  //   const result = await validateDataContract(rawDataContract);
-  //
-  //   expectValidationError(result, InvalidIndexedPropertyConstraintError);
-  //
-  //   const [error] = result.getErrors();
-  //
-  //   expect(error.getCode()).to.equal(1012);
-  //   expect(error.getPropertyName()).to.equal('mentions');
-  //   expect(error.getConstraintName()).to.equal('maxItems');
-  //   expect(error.getReason()).to.equal('should be less or equal 63');
-  // });
-  //
-  // it('should return invalid result if indexed array property have
-  // string item with maxItems bigger than 1024', async () => {
-  //   rawDataContract.documents.indexedArray.properties.mentions.maxItems = 2048;
-  //
-  //   const result = await validateDataContract(rawDataContract);
-  //
-  //   expectValidationError(result, InvalidIndexedPropertyConstraintError);
-  //
-  //   const [error] = result.getErrors();
-  //
-  //   expect(error.getCode()).to.equal(1012);
-  //   expect(error.getPropertyName()).to.equal('mentions');
-  //   expect(error.getConstraintName()).to.equal('maxItems');
-  //   expect(error.getReason()).to.equal('should be less or equal 63');
-  // });
+  // TODO support indexed arrays
+  it.skip('should return invalid result if indexed array property have string item with maxItems bigger than 1024', async () => {
+    const rawDataContract = dataContract.toObject();
+    rawDataContract.documents.indexedArray.properties.mentions.maxItems = 2048;
+
+    const result = await validateDataContract(rawDataContract);
+
+    expectValidationError(result, InvalidIndexedPropertyConstraintError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1012);
+    expect(error.getPropertyName()).to.equal('mentions');
+    expect(error.getConstraintName()).to.equal('maxItems');
+    expect(error.getReason()).to.equal('should be less or equal 63');
+  });
 
   it('should return invalid result if indexed byte array property missing maxItems constraint', async () => {
+    const rawDataContract = dataContract.toObject();
     delete rawDataContract.documents.withByteArrays.properties.byteArrayField.maxItems;
 
     const result = await validateDataContract(rawDataContract);
@@ -2168,6 +2240,7 @@ describe('validateDataContractFactory', function main() {
   });
 
   it('should return invalid result if indexed byte array property have to big maxItems', async () => {
+    const rawDataContract = dataContract.toObject();
     rawDataContract.documents.withByteArrays.properties.byteArrayField.maxItems = 8192;
 
     const result = await validateDataContract(rawDataContract);
@@ -2183,6 +2256,7 @@ describe('validateDataContractFactory', function main() {
   });
 
   it('should return valid result if Data Contract is valid', async () => {
+    const rawDataContract = dataContract.toObject();
     const result = await validateDataContract(rawDataContract);
 
     expect(result).to.be.an.instanceOf(ValidationResult);