@dashevo/dpns-contract 0.25.8 → 0.25.10

package/Cargo.toml

@@ -3,6 +3,7 @@ name = "dpns-contract"
 description = "DPNS data contract schema and tools"
 version = "0.25.0"
 edition = "2021"
+rust-version = "1.73"
 license = "MIT"
 
 [dependencies]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dpns-contract",
-  "version": "0.25.8",
+  "version": "0.25.10",
   "description": "A contract and helper scripts for DPNS DApp",
   "scripts": {
     "lint": "eslint .",
@@ -31,7 +31,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@dashevo/dpp": "0.25.8",
+    "@dashevo/wasm-dpp": "0.25.10",
     "chai": "^4.3.9",
     "dirty-chai": "^2.0.1",
     "eslint": "^7.32.0",

package/test/bootstrap.js

@@ -4,9 +4,14 @@ const sinonChai = require('sinon-chai');
 const { expect, use } = require('chai');
 const dirtyChai = require('dirty-chai');
 
+const {
+  default: loadWasmDpp,
+} = require('@dashevo/wasm-dpp');
+
 use(dirtyChai);
 use(sinonChai);
 
+before(loadWasmDpp);
 beforeEach(function beforeEach() {
   if (!this.sinon) {
     this.sinon = sinon.createSandbox();

package/test/unit/dpnsContract.spec.js

@@ -1,40 +1,40 @@
 const crypto = require('crypto');
 
-const DashPlatformProtocol = require('@dashevo/dpp');
-
-const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
+const {
+  DashPlatformProtocol, JsonSchemaError,
+} = require('@dashevo/wasm-dpp');
+const generateRandomIdentifier = require('@dashevo/wasm-dpp/lib/test/utils/generateRandomIdentifierAsync');
 
+const { expect } = require('chai');
 const dpnsContractDocumentsSchema = require('../../schema/dpns-contract-documents.json');
 
+const expectJsonSchemaError = (validationResult, errorCount = 1) => {
+  const errors = validationResult.getErrors();
+  expect(errors).to.have.length(errorCount);
+
+  const error = validationResult.getErrors()[0];
+  expect(error).to.be.instanceof(JsonSchemaError);
+
+  return error;
+};
+
 describe('DPNS Contract', () => {
   let dpp;
   let dataContract;
   let identityId;
 
-  beforeEach(async function beforeEach() {
-    const fetchContractStub = this.sinon.stub();
-
-    dpp = new DashPlatformProtocol({
-      stateRepository: {
-        fetchDataContract: fetchContractStub,
-      },
-    });
+  beforeEach(async () => {
+    dpp = new DashPlatformProtocol(
+      { generate: () => crypto.randomBytes(32) },
+    );
 
-    await dpp.initialize();
-
-    identityId = generateRandomIdentifier();
+    identityId = await generateRandomIdentifier();
 
     dataContract = dpp.dataContract.create(identityId, dpnsContractDocumentsSchema);
-
-    fetchContractStub.resolves(dataContract);
   });
 
-  it('should have a valid contract definition', async function shouldHaveValidContract() {
-    this.timeout(5000);
-
-    const validationResult = await dpp.dataContract.validate(dataContract);
-
-    expect(validationResult.isValid()).to.be.true();
+  it('should have a valid contract definition', async () => {
+    expect(() => dpp.dataContract.create(identityId, dpnsContractDocumentsSchema)).to.not.throw();
   });
 
   describe('documents', () => {
@@ -51,103 +51,63 @@ describe('DPNS Contract', () => {
         it('should be defined', async () => {
           delete rawPreorderDocument.saltedDomainHash;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('required');
-            expect(error.params.missingProperty).to.equal('saltedDomainHash');
-          }
+          expect(error.keyword).to.equal('required');
+          expect(error.params.missingProperty).to.equal('saltedDomainHash');
         });
 
         it('should not be empty', async () => {
           rawPreorderDocument.saltedDomainHash = Buffer.alloc(0);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
+          const document = dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('minItems');
-            expect(error.instancePath).to.equal('/saltedDomainHash');
-          }
+          expect(error.keyword).to.equal('minItems');
+          expect(error.instancePath).to.deep.equal('/saltedDomainHash');
         });
 
         it('should be not less than 32 bytes', async () => {
           rawPreorderDocument.saltedDomainHash = crypto.randomBytes(10);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
+          const document = dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('minItems');
-            expect(error.instancePath).to.equal('/saltedDomainHash');
-          }
+          expect(error.keyword).to.equal('minItems');
+          expect(error.instancePath).to.equal('/saltedDomainHash');
         });
 
         it('should be not longer than 32 bytes', async () => {
           rawPreorderDocument.saltedDomainHash = crypto.randomBytes(40);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('maxItems');
-            expect(error.instancePath).to.equal('/saltedDomainHash');
-          }
+          expect(error.keyword).to.equal('maxItems');
+          expect(error.instancePath).to.equal('/saltedDomainHash');
         });
       });
 
       it('should not have additional properties', async () => {
         rawPreorderDocument.someOtherProperty = 42;
 
-        try {
-          dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
-
-          expect.fail('should throw error');
-        } catch (e) {
-          expect(e.name).to.equal('InvalidDocumentError');
-          expect(e.getErrors()).to.have.a.lengthOf(1);
-
-          const [error] = e.getErrors();
+        const document = dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
+        const validationResult = document.validate(dpp.protocolVersion);
+        const error = expectJsonSchemaError(validationResult);
 
-          expect(error.name).to.equal('JsonSchemaError');
-          expect(error.keyword).to.equal('additionalProperties');
-          expect(error.params.additionalProperty).to.equal('someOtherProperty');
-        }
+        expect(error.keyword).to.equal('additionalProperties');
+        expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
       });
 
       it('should be valid', async () => {
         const preorder = dpp.document.create(dataContract, identityId, 'preorder', rawPreorderDocument);
 
-        const result = await dpp.document.validate(preorder);
+        const result = await preorder.validate(dpp.protocolVersion);
 
         expect(result.isValid()).to.be.true();
       });
@@ -156,14 +116,14 @@ describe('DPNS Contract', () => {
     describe('domain', () => {
       let rawDomainDocument;
 
-      beforeEach(() => {
+      beforeEach(async () => {
         rawDomainDocument = {
           label: 'Wallet',
           normalizedLabel: 'wa11et', // lower case and base58 chars only
           normalizedParentDomainName: 'dash',
           preorderSalt: crypto.randomBytes(32),
           records: {
-            dashUniqueIdentityId: generateRandomIdentifier(),
+            dashUniqueIdentityId: await generateRandomIdentifier(),
           },
           subdomainRules: {
             allowSubdomains: false,
@@ -175,77 +135,45 @@ describe('DPNS Contract', () => {
         it('should be present', async () => {
           delete rawDomainDocument.label;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('required');
-            expect(error.params.missingProperty).to.equal('label');
-          }
+          expect(error.keyword).to.equal('required');
+          expect(error.params.missingProperty).to.equal('label');
         });
 
         it('should follow pattern', async () => {
           rawDomainDocument.label = 'invalid label';
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('pattern');
-            expect(error.instancePath).to.equal('/label');
-          }
+          expect(error.keyword).to.equal('pattern');
+          expect(error.instancePath).to.equal('/label');
         });
 
         it('should be longer than 3 chars', async () => {
           rawDomainDocument.label = 'ab';
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('minLength');
-            expect(error.instancePath).to.equal('/label');
-          }
+          expect(error.keyword).to.equal('minLength');
+          expect(error.instancePath).to.equal('/label');
         });
 
         it('should be less than 63 chars', async () => {
           rawDomainDocument.label = 'a'.repeat(64);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult, 2);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('maxLength');
-            expect(error.instancePath).to.equal('/label');
-          }
+          expect(error.keyword).to.equal('pattern');
+          expect(error.instancePath).to.equal('/label');
         });
       });
 
@@ -253,58 +181,34 @@ describe('DPNS Contract', () => {
         it('should be defined', async () => {
           delete rawDomainDocument.normalizedLabel;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('required');
-            expect(error.params.missingProperty).to.equal('normalizedLabel');
-          }
+          expect(error.keyword).to.equal('required');
+          expect(error.params.missingProperty).to.equal('normalizedLabel');
         });
 
         it('should follow pattern', async () => {
           rawDomainDocument.normalizedLabel = 'InValiD label';
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('pattern');
-            expect(error.instancePath).to.equal('/normalizedLabel');
-          }
+          expect(error.keyword).to.equal('pattern');
+          expect(error.instancePath).to.equal('/normalizedLabel');
         });
 
         it('should be less than 63 chars', async () => {
           rawDomainDocument.normalizedLabel = 'a'.repeat(64);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult, 2);
 
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('maxLength');
-            expect(error.instancePath).to.equal('/normalizedLabel');
-          }
+          expect(error.keyword).to.equal('pattern');
+          expect(error.instancePath).to.equal('/normalizedLabel');
         });
       });
 
@@ -312,58 +216,34 @@ describe('DPNS Contract', () => {
         it('should be defined', async () => {
           delete rawDomainDocument.normalizedParentDomainName;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('required');
-            expect(error.params.missingProperty).to.equal('normalizedParentDomainName');
-          }
+          expect(error.keyword).to.equal('required');
+          expect(error.params.missingProperty).to.equal('normalizedParentDomainName');
         });
 
         it('should be less than 190 chars', async () => {
           rawDomainDocument.normalizedParentDomainName = 'a'.repeat(191);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult, 2);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('maxLength');
-            expect(error.instancePath).to.equal('/normalizedParentDomainName');
-          }
+          expect(error.keyword).to.equal('pattern');
+          expect(error.instancePath).to.equal('/normalizedParentDomainName');
         });
 
         it('should follow pattern', async () => {
           rawDomainDocument.normalizedParentDomainName = '&'.repeat(50);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('pattern');
-            expect(error.instancePath).to.equal('/normalizedParentDomainName');
-          }
+          expect(error.keyword).to.equal('pattern');
+          expect(error.instancePath).to.equal('/normalizedParentDomainName');
         });
       });
 
@@ -371,103 +251,65 @@ describe('DPNS Contract', () => {
         it('should be defined', async () => {
           delete rawDomainDocument.preorderSalt;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('required');
-            expect(error.params.missingProperty).to.equal('preorderSalt');
-          }
+          expect(error.keyword).to.equal('required');
+          expect(error.params.missingProperty).to.equal('preorderSalt');
         });
 
         it('should not be empty', async () => {
           rawDomainDocument.preorderSalt = Buffer.alloc(0);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
+          dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('minItems');
-            expect(error.instancePath).to.equal('/preorderSalt');
-          }
+          expect(error.keyword).to.equal('minItems');
+          expect(error.instancePath).to.deep.equal('/preorderSalt');
         });
 
         it('should be not less than 32 bytes', async () => {
           rawDomainDocument.preorderSalt = crypto.randomBytes(10);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('minItems');
-            expect(error.instancePath).to.equal('/preorderSalt');
-          }
+          expect(error.keyword).to.equal('minItems');
+          expect(error.instancePath).to.equal('/preorderSalt');
         });
 
         it('should be not longer than 32 bytes', async () => {
           rawDomainDocument.preorderSalt = crypto.randomBytes(40);
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('maxItems');
-            expect(error.instancePath).to.equal('/preorderSalt');
-          }
+          expect(error.keyword).to.equal('maxItems');
+          expect(error.instancePath).to.equal('/preorderSalt');
         });
       });
 
       it('should not have additional properties', async () => {
-        rawDomainDocument.someOtherProperty = 42;
+        rawDomainDocument.someOtherProperty = [];
 
-        try {
-          dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+        const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
 
-          expect.fail('should throw error');
-        } catch (e) {
-          expect(e.name).to.equal('InvalidDocumentError');
-          expect(e.getErrors()).to.have.a.lengthOf(1);
+        const validationResult = document.validate(dpp.protocolVersion);
+        const error = expectJsonSchemaError(validationResult);
 
-          const [error] = e.getErrors();
-
-          expect(error.name).to.equal('JsonSchemaError');
-          expect(error.keyword).to.equal('additionalProperties');
-          expect(error.params.additionalProperty).to.equal('someOtherProperty');
-        }
+        expect(error.keyword).to.equal('additionalProperties');
+        expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
       });
 
       it('should be valid', async () => {
         const domain = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
 
-        const result = await dpp.document.validate(domain);
+        const result = await domain.validate(dpp.protocolVersion);
 
         expect(result.isValid()).to.be.true();
       });
@@ -476,39 +318,23 @@ describe('DPNS Contract', () => {
         it('should be defined', async () => {
           delete rawDomainDocument.records;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('required');
-            expect(error.params.missingProperty).to.equal('records');
-          }
+          expect(error.keyword).to.equal('required');
+          expect(error.params.missingProperty).to.equal('records');
         });
 
         it('should not be empty', async () => {
           rawDomainDocument.records = {};
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('minProperties');
-            expect(error.instancePath).to.equal('/records');
-          }
+          expect(error.keyword).to.equal('minProperties');
+          expect(error.instancePath).to.deep.equal('/records');
         });
 
         it('should not have additional properties', async () => {
@@ -516,21 +342,13 @@ describe('DPNS Contract', () => {
             someOtherProperty: 42,
           };
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('additionalProperties');
-            expect(error.instancePath).to.equal('/records');
-            expect(error.params.additionalProperty).to.equal('someOtherProperty');
-          }
+          expect(error.keyword).to.equal('additionalProperties');
+          expect(error.instancePath).to.equal('/records');
+          expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
         });
 
         describe('Dash Identity', () => {
@@ -540,20 +358,12 @@ describe('DPNS Contract', () => {
               dashAliasIdentityId: identityId,
             };
 
-            try {
-              dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-              expect.fail('should throw error');
-            } catch (e) {
-              expect(e.name).to.equal('InvalidDocumentError');
-              expect(e.getErrors()).to.have.a.lengthOf(1);
+            const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+            const validationResult = document.validate(dpp.protocolVersion);
+            const error = expectJsonSchemaError(validationResult);
 
-              const [error] = e.getErrors();
-
-              expect(error.name).to.equal('JsonSchemaError');
-              expect(error.keyword).to.equal('maxProperties');
-              expect(error.instancePath).to.equal('/records');
-            }
+            expect(error.keyword).to.equal('maxProperties');
+            expect(error.instancePath).to.equal('/records');
           });
 
           describe('dashUniqueIdentityId', () => {
@@ -562,20 +372,9 @@ describe('DPNS Contract', () => {
                 dashUniqueIdentityId: crypto.randomBytes(30),
               };
 
-              try {
+              expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-                expect.fail('should throw error');
-              } catch (e) {
-                expect(e.name).to.equal('InvalidDocumentError');
-                expect(e.getErrors()).to.have.a.lengthOf(1);
-
-                const [error] = e.getErrors();
-
-                expect(error.name).to.equal('JsonSchemaError');
-                expect(error.keyword).to.equal('minItems');
-                expect(error.instancePath).to.equal('/records/dashUniqueIdentityId');
-              }
+              }).to.throw();
             });
 
             it('should no more than 32 bytes', async () => {
@@ -583,20 +382,9 @@ describe('DPNS Contract', () => {
                 dashUniqueIdentityId: crypto.randomBytes(64),
               };
 
-              try {
+              expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-                expect.fail('should throw error');
-              } catch (e) {
-                expect(e.name).to.equal('InvalidDocumentError');
-                expect(e.getErrors()).to.have.a.lengthOf(1);
-
-                const [error] = e.getErrors();
-
-                expect(error.name).to.equal('JsonSchemaError');
-                expect(error.keyword).to.equal('maxItems');
-                expect(error.instancePath).to.equal('/records/dashUniqueIdentityId');
-              }
+              }).to.throw();
             });
           });
 
@@ -606,20 +394,9 @@ describe('DPNS Contract', () => {
                 dashAliasIdentityId: crypto.randomBytes(30),
               };
 
-              try {
+              expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-                expect.fail('should throw error');
-              } catch (e) {
-                expect(e.name).to.equal('InvalidDocumentError');
-                expect(e.getErrors()).to.have.a.lengthOf(1);
-
-                const [error] = e.getErrors();
-
-                expect(error.name).to.equal('JsonSchemaError');
-                expect(error.keyword).to.equal('minItems');
-                expect(error.instancePath).to.equal('/records/dashAliasIdentityId');
-              }
+              }).to.throw();
             });
 
             it('should no more than 32 bytes', async () => {
@@ -627,20 +404,9 @@ describe('DPNS Contract', () => {
                 dashAliasIdentityId: crypto.randomBytes(64),
               };
 
-              try {
+              expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-                expect.fail('should throw error');
-              } catch (e) {
-                expect(e.name).to.equal('InvalidDocumentError');
-                expect(e.getErrors()).to.have.a.lengthOf(1);
-
-                const [error] = e.getErrors();
-
-                expect(error.name).to.equal('JsonSchemaError');
-                expect(error.keyword).to.equal('maxItems');
-                expect(error.instancePath).to.equal('/records/dashAliasIdentityId');
-              }
+              }).to.throw();
             });
           });
         });
@@ -650,59 +416,36 @@ describe('DPNS Contract', () => {
         it('should be defined', async () => {
           delete rawDomainDocument.subdomainRules;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('required');
-            expect(error.params.missingProperty).to.equal('subdomainRules');
-          }
+          expect(error.keyword).to.equal('required');
+          expect(error.params.missingProperty).to.equal('subdomainRules');
         });
 
         it('should not have additional properties', async () => {
           rawDomainDocument.subdomainRules.someOtherProperty = 42;
 
-          try {
-            dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+          const validationResult = document.validate(dpp.protocolVersion);
+          const error = expectJsonSchemaError(validationResult);
 
-            expect.fail('should throw error');
-          } catch (e) {
-            expect(e.name).to.equal('InvalidDocumentError');
-            expect(e.getErrors()).to.have.a.lengthOf(1);
-
-            const [error] = e.getErrors();
-
-            expect(error.name).to.equal('JsonSchemaError');
-            expect(error.keyword).to.equal('additionalProperties');
-            expect(error.instancePath).to.equal('/subdomainRules');
-          }
+          expect(error.keyword).to.equal('additionalProperties');
+          expect(error.instancePath).to.equal('/subdomainRules');
+          expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
         });
 
         describe('allowSubdomains', () => {
           it('should be boolean', async () => {
             rawDomainDocument.subdomainRules.allowSubdomains = 'data';
 
-            try {
-              dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-
-              expect.fail('should throw error');
-            } catch (e) {
-              expect(e.name).to.equal('InvalidDocumentError');
-              expect(e.getErrors()).to.have.a.lengthOf(1);
-
-              const [error] = e.getErrors();
+            const document = dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
+            const validationResult = document.validate(dpp.protocolVersion);
+            const error = expectJsonSchemaError(validationResult);
 
-              expect(error.name).to.equal('JsonSchemaError');
-              expect(error.keyword).to.equal('type');
-              expect(error.instancePath).to.equal('/subdomainRules/allowSubdomains');
-            }
+            expect(error.keyword).to.equal('type');
+            expect(error.instancePath).to.deep.equal('/subdomainRules/allowSubdomains');
           });
         });
       });