@dashevo/dashpay-contract 0.25.21 → 1.0.0-beta.1

package/.eslintrc

@@ -17,6 +17,7 @@
     "mocha": true
   },
   "globals": {
-    "expect": true
+    "expect": true,
+    "BigInt": true
   }
 }

package/Cargo.toml

@@ -1,11 +1,13 @@
 [package]
 name = "dashpay-contract"
 description = "DashPay data contract schema and tools"
-version = "0.25.21"
+version = "1.0.0-beta.1"
 edition = "2021"
-rust-version = "1.73"
+rust-version = "1.76"
 license = "MIT"
 
 [dependencies]
+platform-version = { path = "../rs-platform-version" }
+thiserror = "1.0.58"
 serde_json = { version = "1.0" }
 platform-value = { path = "../rs-platform-value" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dashpay-contract",
-  "version": "0.25.21",
+  "version": "1.0.0-beta.1",
   "description": "Reference contract of the DashPay DPA on Dash Evolution",
   "scripts": {
     "lint": "eslint .",
@@ -25,7 +25,7 @@
   },
   "homepage": "https://github.com/dashevo/dashpay-contract#readme",
   "devDependencies": {
-    "@dashevo/wasm-dpp": "0.25.21",
+    "@dashevo/wasm-dpp": "1.0.0-beta.1",
     "chai": "^4.3.10",
     "dirty-chai": "^2.0.1",
     "eslint": "^8.53.0",

package/schema/{dashpay.schema.json → v1/dashpay.schema.json}

@@ -27,6 +27,7 @@
       "avatarUrl": {
         "type": "string",
         "format": "uri",
+        "minLength": 1,
         "maxLength": 2048,
         "position": 0
       },
@@ -48,15 +49,23 @@
       },
       "publicMessage": {
         "type": "string",
+        "minLength": 1,
         "maxLength": 140,
         "position": 3
       },
       "displayName": {
         "type": "string",
+        "minLength": 1,
         "maxLength": 25,
         "position": 4
       }
     },
+    "minProperties": 1,
+    "dependentRequired": {
+      "avatarUrl": ["avatarHash", "avatarFingerprint"],
+      "avatarHash": ["avatarUrl", "avatarFingerprint"],
+      "avatarFingerprint": ["avatarUrl", "avatarHash"]
+    },
     "required": [
       "$createdAt",
       "$updatedAt"
@@ -131,6 +140,8 @@
     "additionalProperties": false
   },
   "contactRequest": {
+    "documentsMutable": false,
+    "canBeDeleted": false,
     "requiresIdentityEncryptionBoundedKey": 2,
     "requiresIdentityDecryptionBoundedKey": 2,
     "type": "object",
@@ -228,15 +239,11 @@
         "minItems": 38,
         "maxItems": 102,
         "position": 6
-      },
-      "coreHeightCreatedAt": {
-        "type": "integer",
-        "minimum": 1,
-        "position": 7
       }
     },
     "required": [
       "$createdAt",
+      "$createdAtCoreBlockHeight",
       "toUserId",
       "encryptedPublicKey",
       "senderKeyIndex",

package/src/error.rs

@@ -0,0 +1,17 @@
+use platform_version::version::FeatureVersion;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    /// Platform expected some specific versions
+    #[error("platform unknown version on {method}, received: {received}")]
+    UnknownVersionMismatch {
+        /// method
+        method: String,
+        /// the allowed versions for this method
+        known_versions: Vec<FeatureVersion>,
+        /// requested core height
+        received: FeatureVersion,
+    },
+    #[error("schema deserialize error: {0}")]
+    InvalidSchemaJson(#[from] serde_json::Error),
+}

package/src/lib.rs

@@ -1,5 +1,9 @@
+mod error;
+pub mod v1;
+
+pub use crate::error::Error;
 use platform_value::{Identifier, IdentifierBytes32};
-use serde_json::Error;
+use platform_version::version::PlatformVersion;
 use serde_json::Value;
 
 pub const ID_BYTES: [u8; 32] = [
@@ -12,21 +16,26 @@ pub const OWNER_ID_BYTES: [u8; 32] = [
     215, 90, 101, 229, 15, 115, 5, 44, 117, 182, 217,
 ];
 
-pub mod document_types {
-    pub mod contact_request {
-        pub const NAME: &str = "contactRequest";
-
-        pub mod properties {
-            pub const TO_USER_ID: &str = "toUserId";
-            pub const CORE_HEIGHT_CREATED_AT: &str = "coreHeightCreatedAt";
-            pub const CORE_CHAIN_LOCKED_HEIGHT: &str = "coreChainLockedHeight";
-        }
-    }
-}
-
 pub const ID: Identifier = Identifier(IdentifierBytes32(ID_BYTES));
 pub const OWNER_ID: Identifier = Identifier(IdentifierBytes32(OWNER_ID_BYTES));
 
-pub fn load_documents_schemas() -> Result<Value, Error> {
-    serde_json::from_str(include_str!("../schema/dashpay.schema.json"))
+pub fn load_definitions(platform_version: &PlatformVersion) -> Result<Option<Value>, Error> {
+    match platform_version.system_data_contracts.dashpay {
+        1 => Ok(None),
+        version => Err(Error::UnknownVersionMismatch {
+            method: "dashpay_contract::load_definitions".to_string(),
+            known_versions: vec![1],
+            received: version,
+        }),
+    }
+}
+pub fn load_documents_schemas(platform_version: &PlatformVersion) -> Result<Value, Error> {
+    match platform_version.system_data_contracts.dashpay {
+        1 => v1::load_documents_schemas(),
+        version => Err(Error::UnknownVersionMismatch {
+            method: "dashpay_contract::load_documents_schemas".to_string(),
+            known_versions: vec![1],
+            received: version,
+        }),
+    }
 }

package/src/v1/mod.rs

@@ -0,0 +1,17 @@
+use crate::error::Error;
+use serde_json::Value;
+
+pub mod document_types {
+    pub mod contact_request {
+        pub const NAME: &str = "contactRequest";
+
+        pub mod properties {
+            pub const TO_USER_ID: &str = "toUserId";
+        }
+    }
+}
+
+pub fn load_documents_schemas() -> Result<Value, Error> {
+    serde_json::from_str(include_str!("../../schema/v1/dashpay.schema.json"))
+        .map_err(Error::InvalidSchemaJson)
+}

package/test/unit/schema.spec.js

@@ -1,19 +1,28 @@
 const { expect } = require('chai');
 const crypto = require('crypto');
-const { DashPlatformProtocol, JsonSchemaError } = require('@dashevo/wasm-dpp');
+const {
+  DashPlatformProtocol,
+  JsonSchemaError,
+} = require('@dashevo/wasm-dpp');
 const generateRandomIdentifier = require('@dashevo/wasm-dpp/lib/test/utils/generateRandomIdentifierAsync');
-const schema = require('../../schema/dashpay.schema.json');
+const schema = require('../../schema/v1/dashpay.schema.json');
 
 const whitepaperMasternodeText = 'Full nodes are servers running on a P2P network that allow peers to use them to receive updates about the events on the network. These nodes utilize significant amounts of traffic and other resources that incur a substantial cost. As a result, a steady decrease in the amount of these nodes has been observed for some time on the Bitcoin network and as a result, block propagation times have been upwards of 40 seconds. Many solutions have been proposed such as a new reward scheme by Microsoft Research and the Bitnodes incentive program';
 const encoded32Chars = '4fafc98bbfe597f7ba2c9f767d52036d';
 const encoded64Chars = '4fafc98bbfe597f7ba2c9f767d52036d2226175960a908e355e5c575711eb166';
 
-const expectJsonSchemaError = (validationResult) => {
+const expectJsonSchemaError = (validationResult, count = 1, index = 0) => {
   const errors = validationResult.getErrors();
-  expect(errors).to.have.length(1);
+  expect(errors)
+    .to
+    .have
+    .length(count);
 
-  const error = validationResult.getErrors()[0];
-  expect(error).to.be.instanceof(JsonSchemaError);
+  const error = validationResult.getErrors()[index];
+  expect(error)
+    .to
+    .be
+    .instanceof(JsonSchemaError);
 
   return error;
 };
@@ -29,11 +38,14 @@ describe('Dashpay Contract', () => {
     );
 
     identityId = await generateRandomIdentifier();
-    contract = dpp.dataContract.create(identityId, schema);
+    contract = dpp.dataContract.create(identityId, BigInt(1), schema);
   });
 
   it('should have a valid contract definition', async () => {
-    expect(() => dpp.dataContract.create(identityId, schema)).to.not.throw();
+    expect(() => dpp.dataContract.create(identityId, BigInt(1), schema))
+      .to
+      .not
+      .throw();
   });
 
   describe('Documents', () => {
@@ -43,7 +55,6 @@ describe('Dashpay Contract', () => {
       beforeEach(() => {
         profileData = {
           displayName: 'Bob',
-          publicMessage: 'Hello Dashpay!',
         };
       });
 
@@ -55,8 +66,13 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxLength');
-          expect(error.instancePath).to.deep.equal('/displayName');
+          expect(error.keyword)
+            .to
+            .equal('maxLength');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/displayName');
         });
       });
 
@@ -68,113 +84,286 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxLength');
-          expect(error.instancePath).to.deep.equal('/publicMessage');
+          expect(error.keyword)
+            .to
+            .equal('maxLength');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/publicMessage');
         });
       });
 
       describe('avatarUrl', () => {
         it('should not be empty', async () => {
-          profileData.avatarUrl = '';
+          profileData = {
+            avatarUrl: '',
+            avatarHash: Buffer.alloc(32),
+            avatarFingerprint: Buffer.alloc(8),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
-          const error = expectJsonSchemaError(validationResult);
+          const error = expectJsonSchemaError(validationResult, 2);
 
-          expect(error.keyword).to.equal('format');
-          expect(error.instancePath).to.deep.equal('/avatarUrl');
+          expect(error.keyword)
+            .to
+            .equal('format');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarUrl');
         });
 
         it('should have less than 2048 chars length', async () => {
-          profileData.avatarUrl = `https://github.com/dashpay/dash/wiki/Whitepaper?text=${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}`;
+          profileData = {
+            avatarUrl: `https://github.com/dashpay/dash/wiki/Whitepaper?text=${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}${encodeURI(whitepaperMasternodeText)}`,
+            avatarHash: Buffer.alloc(32),
+            avatarFingerprint: Buffer.alloc(8),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxLength');
-          expect(error.instancePath).to.deep.equal('/avatarUrl');
+          expect(error.keyword)
+            .to
+            .equal('maxLength');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarUrl');
         });
 
         it('should be of type URL', async () => {
-          profileData.avatarUrl = 'notAUrl';
+          profileData = {
+            avatarUrl: 'notAUrl',
+            avatarHash: Buffer.alloc(32),
+            avatarFingerprint: Buffer.alloc(8),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('format');
-          expect(error.instancePath).to.deep.equal('/avatarUrl');
+          expect(error.keyword)
+            .to
+            .equal('format');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarUrl');
+        });
+
+        it('should be present if other avatar properties are present', async () => {
+          profileData = {
+            avatarHash: Buffer.alloc(32),
+            avatarFingerprint: Buffer.alloc(8),
+          };
+
+          const document = dpp.document.create(contract, identityId, 'profile', profileData);
+          const validationResult = document.validate(dpp.protocolVersion);
+          let error = expectJsonSchemaError(validationResult, 2, 0);
+
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params)
+            .to
+            .deep
+            .equal({ missingProperty: 'avatarUrl' });
+
+          error = expectJsonSchemaError(validationResult, 2, 1);
+
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params)
+            .to
+            .deep
+            .equal({ missingProperty: 'avatarUrl' });
         });
       });
 
       describe('avatarHash', () => {
         it('should have minimum length of 32', async () => {
-          profileData.avatarHash = Buffer.alloc(0);
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarHash: Buffer.alloc(0),
+            avatarFingerprint: Buffer.alloc(8),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minItems');
-          expect(error.instancePath).to.deep.equal('/avatarHash');
+          expect(error.keyword)
+            .to
+            .equal('minItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarHash');
         });
 
         it('should have maximum length of 32', async () => {
-          profileData.avatarHash = Buffer.alloc(33);
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarHash: Buffer.alloc(33),
+            avatarFingerprint: Buffer.alloc(8),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxItems');
-          expect(error.instancePath).to.deep.equal('/avatarHash');
+          expect(error.keyword)
+            .to
+            .equal('maxItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarHash');
         });
 
         it('should be of type array', async () => {
-          profileData.avatarHash = 'notAnArray';
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarHash: 'notAnArray',
+            avatarFingerprint: Buffer.alloc(8),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
-          const error = expectJsonSchemaError(validationResult);
+          const error = expectJsonSchemaError(validationResult, 2);
+
+          expect(error.keyword)
+            .to
+            .equal('type');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarHash');
+        });
+
+        it('should be present if other avatar properties are present', async () => {
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarFingerprint: Buffer.alloc(8),
+          };
+
+          const document = dpp.document.create(contract, identityId, 'profile', profileData);
+          const validationResult = document.validate(dpp.protocolVersion);
+          let error = expectJsonSchemaError(validationResult, 2, 0);
+
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params)
+            .to
+            .deep
+            .equal({ missingProperty: 'avatarHash' });
 
-          expect(error.keyword).to.equal('type');
-          expect(error.instancePath).to.deep.equal('/avatarHash');
+          error = expectJsonSchemaError(validationResult, 2, 1);
+
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params)
+            .to
+            .deep
+            .equal({ missingProperty: 'avatarHash' });
         });
       });
 
       describe('avatarFingerprint', () => {
         it('should have minimum length of 8', async () => {
-          profileData.avatarFingerprint = Buffer.alloc(0);
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarHash: Buffer.alloc(32),
+            avatarFingerprint: Buffer.alloc(0),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minItems');
-          expect(error.instancePath).to.deep.equal('/avatarFingerprint');
+          expect(error.keyword)
+            .to
+            .equal('minItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarFingerprint');
         });
 
         it('should have maximum length of 8', async () => {
-          profileData.avatarFingerprint = Buffer.alloc(33);
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarHash: Buffer.alloc(32),
+            avatarFingerprint: Buffer.alloc(33),
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxItems');
-          expect(error.instancePath).to.deep.equal('/avatarFingerprint');
+          expect(error.keyword)
+            .to
+            .equal('maxItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarFingerprint');
         });
 
         it('should be of type array', async () => {
-          profileData.avatarFingerprint = 'notAnArray';
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarHash: Buffer.alloc(32),
+            avatarFingerprint: 'notAnArray',
+          };
 
           const document = dpp.document.create(contract, identityId, 'profile', profileData);
           const validationResult = document.validate(dpp.protocolVersion);
-          const error = expectJsonSchemaError(validationResult);
+          const error = expectJsonSchemaError(validationResult, 2);
 
-          expect(error.keyword).to.equal('type');
-          expect(error.instancePath).to.deep.equal('/avatarFingerprint');
+          expect(error.keyword)
+            .to
+            .equal('type');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/avatarFingerprint');
+        });
+
+        it('should be present if other avatar properties are present', async () => {
+          profileData = {
+            avatarUrl: 'https://github.com/dashpay/dash.jpg',
+            avatarHash: Buffer.alloc(32),
+          };
+
+          const document = dpp.document.create(contract, identityId, 'profile', profileData);
+          const validationResult = document.validate(dpp.protocolVersion);
+          let error = expectJsonSchemaError(validationResult, 2, 0);
+
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params)
+            .to
+            .deep
+            .equal({ missingProperty: 'avatarFingerprint' });
+
+          error = expectJsonSchemaError(validationResult, 2, 1);
+
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params)
+            .to
+            .deep
+            .equal({ missingProperty: 'avatarFingerprint' });
         });
       });
 
@@ -185,8 +374,25 @@ describe('Dashpay Contract', () => {
         const validationResult = document.validate(dpp.protocolVersion);
         const error = expectJsonSchemaError(validationResult);
 
-        expect(error.keyword).to.equal('additionalProperties');
-        expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
+        expect(error.keyword)
+          .to
+          .equal('additionalProperties');
+        expect(error.params.additionalProperties)
+          .to
+          .deep
+          .equal(['someOtherProperty']);
+      });
+
+      it('at least one of avatarUrl, publicMessage or displayName should be present', async () => {
+        const profile = dpp.document.create(contract, identityId, 'profile', { });
+
+        const result = profile.validate(dpp.protocolVersion);
+
+        const error = expectJsonSchemaError(result);
+
+        expect(error.keyword)
+          .to
+          .equal('minProperties');
       });
 
       it('should be valid', async () => {
@@ -194,7 +400,10 @@ describe('Dashpay Contract', () => {
 
         const result = profile.validate(dpp.protocolVersion);
 
-        expect(result.isValid()).to.be.true();
+        expect(result.isValid())
+          .to
+          .be
+          .true();
       });
     });
 
@@ -218,8 +427,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('encToUserId');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('encToUserId');
         });
 
         it('should have exactly 32 chars length', async () => {
@@ -229,8 +442,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxItems');
-          expect(error.instancePath).to.equal('/encToUserId');
+          expect(error.keyword)
+            .to
+            .equal('maxItems');
+          expect(error.instancePath)
+            .to
+            .equal('/encToUserId');
         });
 
         it('should have more or 32 chars length', async () => {
@@ -240,8 +457,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minItems');
-          expect(error.instancePath).to.equal('/encToUserId');
+          expect(error.keyword)
+            .to
+            .equal('minItems');
+          expect(error.instancePath)
+            .to
+            .equal('/encToUserId');
         });
       });
 
@@ -253,8 +474,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('rootEncryptionKeyIndex');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('rootEncryptionKeyIndex');
         });
 
         it('should not be less than 0', async () => {
@@ -264,8 +489,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minimum');
-          expect(error.instancePath).to.equal('/rootEncryptionKeyIndex');
+          expect(error.keyword)
+            .to
+            .equal('minimum');
+          expect(error.instancePath)
+            .to
+            .equal('/rootEncryptionKeyIndex');
         });
       });
 
@@ -277,8 +506,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('privateData');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('privateData');
         });
       });
 
@@ -289,8 +522,13 @@ describe('Dashpay Contract', () => {
         const validationResult = document.validate(dpp.protocolVersion);
         const error = expectJsonSchemaError(validationResult);
 
-        expect(error.keyword).to.equal('additionalProperties');
-        expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
+        expect(error.keyword)
+          .to
+          .equal('additionalProperties');
+        expect(error.params.additionalProperties)
+          .to
+          .deep
+          .equal(['someOtherProperty']);
       });
     });
 
@@ -315,8 +553,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('toUserId');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('toUserId');
         });
       });
 
@@ -328,8 +570,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('encryptedPublicKey');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('encryptedPublicKey');
         });
       });
 
@@ -341,8 +587,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('senderKeyIndex');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('senderKeyIndex');
         });
 
         it('should not be less than 0', async () => {
@@ -352,8 +602,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minimum');
-          expect(error.instancePath).to.equal('/senderKeyIndex');
+          expect(error.keyword)
+            .to
+            .equal('minimum');
+          expect(error.instancePath)
+            .to
+            .equal('/senderKeyIndex');
         });
       });
 
@@ -365,8 +619,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('recipientKeyIndex');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('recipientKeyIndex');
         });
 
         it('should not be less than 0', async () => {
@@ -376,8 +634,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minimum');
-          expect(error.instancePath).to.equal('/recipientKeyIndex');
+          expect(error.keyword)
+            .to
+            .equal('minimum');
+          expect(error.instancePath)
+            .to
+            .equal('/recipientKeyIndex');
         });
       });
 
@@ -389,8 +651,13 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minItems');
-          expect(error.instancePath).to.deep.equal('/encryptedAccountLabel');
+          expect(error.keyword)
+            .to
+            .equal('minItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/encryptedAccountLabel');
         });
 
         it('should have maximum length of 80', async () => {
@@ -400,8 +667,13 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxItems');
-          expect(error.instancePath).to.deep.equal('/encryptedAccountLabel');
+          expect(error.keyword)
+            .to
+            .equal('maxItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/encryptedAccountLabel');
         });
 
         it('should be of type array', async () => {
@@ -409,10 +681,15 @@ describe('Dashpay Contract', () => {
 
           const document = dpp.document.create(contract, identityId, 'contactRequest', contactRequestData);
           const validationResult = document.validate(dpp.protocolVersion);
-          const error = expectJsonSchemaError(validationResult);
+          const error = expectJsonSchemaError(validationResult, 2);
 
-          expect(error.keyword).to.equal('type');
-          expect(error.instancePath).to.deep.equal('/encryptedAccountLabel');
+          expect(error.keyword)
+            .to
+            .equal('type');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/encryptedAccountLabel');
         });
       });
 
@@ -424,8 +701,13 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minItems');
-          expect(error.instancePath).to.deep.equal('/autoAcceptProof');
+          expect(error.keyword)
+            .to
+            .equal('minItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/autoAcceptProof');
         });
 
         it('should have maximum length of 102', async () => {
@@ -435,8 +717,13 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxItems');
-          expect(error.instancePath).to.deep.equal('/autoAcceptProof');
+          expect(error.keyword)
+            .to
+            .equal('maxItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/autoAcceptProof');
         });
 
         it('should be of type array', async () => {
@@ -444,10 +731,15 @@ describe('Dashpay Contract', () => {
 
           const document = dpp.document.create(contract, identityId, 'contactRequest', contactRequestData);
           const validationResult = document.validate(dpp.protocolVersion);
-          const error = expectJsonSchemaError(validationResult);
+          const error = expectJsonSchemaError(validationResult, 2);
 
-          expect(error.keyword).to.equal('type');
-          expect(error.instancePath).to.deep.equal('/autoAcceptProof');
+          expect(error.keyword)
+            .to
+            .equal('type');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/autoAcceptProof');
         });
       });
 
@@ -459,8 +751,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('required');
-          expect(error.params.missingProperty).to.equal('accountReference');
+          expect(error.keyword)
+            .to
+            .equal('required');
+          expect(error.params.missingProperty)
+            .to
+            .equal('accountReference');
         });
 
         it('should not be less than 0', async () => {
@@ -470,21 +766,12 @@ describe('Dashpay Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minimum');
-          expect(error.instancePath).to.equal('/accountReference');
-        });
-      });
-
-      describe('coreHeightCreatedAt', () => {
-        it('should not be less than 1', async () => {
-          contactRequestData.coreHeightCreatedAt = -1;
-
-          const document = dpp.document.create(contract, identityId, 'contactRequest', contactRequestData);
-          const validationResult = document.validate(dpp.protocolVersion);
-          const error = expectJsonSchemaError(validationResult);
-
-          expect(error.keyword).to.equal('minimum');
-          expect(error.instancePath).to.equal('/coreHeightCreatedAt');
+          expect(error.keyword)
+            .to
+            .equal('minimum');
+          expect(error.instancePath)
+            .to
+            .equal('/accountReference');
         });
       });
 
@@ -495,8 +782,13 @@ describe('Dashpay Contract', () => {
         const validationResult = document.validate(dpp.protocolVersion);
         const error = expectJsonSchemaError(validationResult);
 
-        expect(error.keyword).to.equal('additionalProperties');
-        expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
+        expect(error.keyword)
+          .to
+          .equal('additionalProperties');
+        expect(error.params.additionalProperties)
+          .to
+          .deep
+          .equal(['someOtherProperty']);
       });
     });
   });