@dashevo/dpns-contract 1.0.0-dev.4 → 1.0.0-dev.6

package/.eslintrc

@@ -1,15 +1,18 @@
 {
-    "extends": "airbnb-base",
-    "rules": {
-        "no-plusplus": 0,
-        "eol-last": [
-            "error",
-            "always"
-        ],
-        "class-methods-use-this": "off",
-        "curly": [
-            "error",
-            "all"
-        ]
-    }
-}
+  "extends": "airbnb-base",
+  "rules": {
+    "no-plusplus": 0,
+    "eol-last": [
+      "error",
+      "always"
+    ],
+    "class-methods-use-this": "off",
+    "curly": [
+      "error",
+      "all"
+    ]
+  },
+  "globals": {
+    "BigInt": true
+  }
+}

package/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "dpns-contract"
 description = "DPNS data contract schema and tools"
-version = "1.0.0-dev.4"
+version = "1.0.0-dev.6"
 edition = "2021"
-rust-version = "1.73"
+rust-version = "1.76"
 license = "MIT"
 
 [dependencies]

package/package.json

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

package/test/unit/dpnsContract.spec.js

@@ -1,7 +1,8 @@
 const crypto = require('crypto');
 
 const {
-  DashPlatformProtocol, JsonSchemaError,
+  DashPlatformProtocol,
+  JsonSchemaError,
 } = require('@dashevo/wasm-dpp');
 const generateRandomIdentifier = require('@dashevo/wasm-dpp/lib/test/utils/generateRandomIdentifierAsync');
 
@@ -10,10 +11,16 @@ const dpnsContractDocumentsSchema = require('../../schema/v1/dpns-contract-docum
 
 const expectJsonSchemaError = (validationResult, errorCount = 1) => {
   const errors = validationResult.getErrors();
-  expect(errors).to.have.length(errorCount);
+  expect(errors)
+    .to
+    .have
+    .length(errorCount);
 
   const error = validationResult.getErrors()[0];
-  expect(error).to.be.instanceof(JsonSchemaError);
+  expect(error)
+    .to
+    .be
+    .instanceof(JsonSchemaError);
 
   return error;
 };
@@ -30,11 +37,14 @@ describe('DPNS Contract', () => {
 
     identityId = await generateRandomIdentifier();
 
-    dataContract = dpp.dataContract.create(identityId, dpnsContractDocumentsSchema);
+    dataContract = dpp.dataContract.create(identityId, BigInt(1), dpnsContractDocumentsSchema);
   });
 
   it('should have a valid contract definition', async () => {
-    expect(() => dpp.dataContract.create(identityId, dpnsContractDocumentsSchema)).to.not.throw();
+    expect(() => dpp.dataContract.create(identityId, BigInt(1), dpnsContractDocumentsSchema))
+      .to
+      .not
+      .throw();
   });
 
   describe('documents', () => {
@@ -55,8 +65,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -66,8 +80,13 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minItems');
-          expect(error.instancePath).to.deep.equal('/saltedDomainHash');
+          expect(error.keyword)
+            .to
+            .equal('minItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/saltedDomainHash');
         });
 
         it('should be not less than 32 bytes', async () => {
@@ -77,8 +96,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -88,8 +111,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxItems');
-          expect(error.instancePath).to.equal('/saltedDomainHash');
+          expect(error.keyword)
+            .to
+            .equal('maxItems');
+          expect(error.instancePath)
+            .to
+            .equal('/saltedDomainHash');
         });
       });
 
@@ -100,8 +127,13 @@ describe('DPNS 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('should be valid', async () => {
@@ -109,7 +141,10 @@ describe('DPNS Contract', () => {
 
         const result = await preorder.validate(dpp.protocolVersion);
 
-        expect(result.isValid()).to.be.true();
+        expect(result.isValid())
+          .to
+          .be
+          .true();
       });
     });
 
@@ -139,8 +174,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -150,8 +189,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -161,8 +204,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -172,8 +219,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult, 2);
 
-          expect(error.keyword).to.equal('pattern');
-          expect(error.instancePath).to.equal('/label');
+          expect(error.keyword)
+            .to
+            .equal('pattern');
+          expect(error.instancePath)
+            .to
+            .equal('/label');
         });
       });
 
@@ -185,8 +236,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -196,8 +251,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -207,8 +266,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult, 2);
 
-          expect(error.keyword).to.equal('pattern');
-          expect(error.instancePath).to.equal('/normalizedLabel');
+          expect(error.keyword)
+            .to
+            .equal('pattern');
+          expect(error.instancePath)
+            .to
+            .equal('/normalizedLabel');
         });
       });
 
@@ -220,8 +283,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -231,8 +298,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult, 2);
 
-          expect(error.keyword).to.equal('pattern');
-          expect(error.instancePath).to.equal('/normalizedParentDomainName');
+          expect(error.keyword)
+            .to
+            .equal('pattern');
+          expect(error.instancePath)
+            .to
+            .equal('/normalizedParentDomainName');
         });
 
         it('should follow pattern', async () => {
@@ -242,8 +313,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('pattern');
-          expect(error.instancePath).to.equal('/normalizedParentDomainName');
+          expect(error.keyword)
+            .to
+            .equal('pattern');
+          expect(error.instancePath)
+            .to
+            .equal('/normalizedParentDomainName');
         });
       });
 
@@ -255,8 +330,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -267,8 +346,13 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minItems');
-          expect(error.instancePath).to.deep.equal('/preorderSalt');
+          expect(error.keyword)
+            .to
+            .equal('minItems');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/preorderSalt');
         });
 
         it('should be not less than 32 bytes', async () => {
@@ -278,8 +362,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -289,8 +377,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('maxItems');
-          expect(error.instancePath).to.equal('/preorderSalt');
+          expect(error.keyword)
+            .to
+            .equal('maxItems');
+          expect(error.instancePath)
+            .to
+            .equal('/preorderSalt');
         });
       });
 
@@ -302,8 +394,13 @@ describe('DPNS 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('should be valid', async () => {
@@ -311,7 +408,10 @@ describe('DPNS Contract', () => {
 
         const result = await domain.validate(dpp.protocolVersion);
 
-        expect(result.isValid()).to.be.true();
+        expect(result.isValid())
+          .to
+          .be
+          .true();
       });
 
       describe('Records', () => {
@@ -322,8 +422,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -333,8 +437,13 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('minProperties');
-          expect(error.instancePath).to.deep.equal('/records');
+          expect(error.keyword)
+            .to
+            .equal('minProperties');
+          expect(error.instancePath)
+            .to
+            .deep
+            .equal('/records');
         });
 
         it('should not have additional properties', async () => {
@@ -346,9 +455,16 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('additionalProperties');
-          expect(error.instancePath).to.equal('/records');
-          expect(error.params.additionalProperties).to.deep.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', () => {
@@ -362,8 +478,12 @@ describe('DPNS Contract', () => {
             const validationResult = document.validate(dpp.protocolVersion);
             const error = expectJsonSchemaError(validationResult);
 
-            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', () => {
@@ -374,7 +494,9 @@ describe('DPNS Contract', () => {
 
               expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-              }).to.throw();
+              })
+                .to
+                .throw();
             });
 
             it('should no more than 32 bytes', async () => {
@@ -384,7 +506,9 @@ describe('DPNS Contract', () => {
 
               expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-              }).to.throw();
+              })
+                .to
+                .throw();
             });
           });
 
@@ -396,7 +520,9 @@ describe('DPNS Contract', () => {
 
               expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-              }).to.throw();
+              })
+                .to
+                .throw();
             });
 
             it('should no more than 32 bytes', async () => {
@@ -406,7 +532,9 @@ describe('DPNS Contract', () => {
 
               expect(() => {
                 dpp.document.create(dataContract, identityId, 'domain', rawDomainDocument);
-              }).to.throw();
+              })
+                .to
+                .throw();
             });
           });
         });
@@ -420,8 +548,12 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          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 () => {
@@ -431,9 +563,16 @@ describe('DPNS Contract', () => {
           const validationResult = document.validate(dpp.protocolVersion);
           const error = expectJsonSchemaError(validationResult);
 
-          expect(error.keyword).to.equal('additionalProperties');
-          expect(error.instancePath).to.equal('/subdomainRules');
-          expect(error.params.additionalProperties).to.deep.equal(['someOtherProperty']);
+          expect(error.keyword)
+            .to
+            .equal('additionalProperties');
+          expect(error.instancePath)
+            .to
+            .equal('/subdomainRules');
+          expect(error.params.additionalProperties)
+            .to
+            .deep
+            .equal(['someOtherProperty']);
         });
 
         describe('allowSubdomains', () => {
@@ -444,8 +583,13 @@ describe('DPNS Contract', () => {
             const validationResult = document.validate(dpp.protocolVersion);
             const error = expectJsonSchemaError(validationResult);
 
-            expect(error.keyword).to.equal('type');
-            expect(error.instancePath).to.deep.equal('/subdomainRules/allowSubdomains');
+            expect(error.keyword)
+              .to
+              .equal('type');
+            expect(error.instancePath)
+              .to
+              .deep
+              .equal('/subdomainRules/allowSubdomains');
           });
         });
       });