@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0

package/test/unit/DashPlatformProtocol.spec.js

@@ -1,46 +1,31 @@
 const crypto = require('crypto');
-const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const createStateRepositoryMock = require('../../lib/test/mocks/createStateRepositoryMock');
-const getBlsAdapterMock = require('../../lib/test/mocks/getBlsAdapterMock');
-let { DashPlatformProtocol } = require('../..');
+const { DashPlatformProtocol, getLatestProtocolVersion } = require('../..');
 const { default: loadWasmDpp } = require('../..');
 
 describe('DashPlatformProtocol', () => {
   let dpp;
-  let stateRepositoryMock;
 
-  beforeEach(async function beforeEach() {
-    ({ DashPlatformProtocol } = await loadWasmDpp());
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+  beforeEach(async () => {
+    await loadWasmDpp();
 
     dpp = new DashPlatformProtocol(
-      getBlsAdapterMock(),
-      stateRepositoryMock,
       { generate: () => crypto.randomBytes(32) },
-      protocolVersion.latestVersion,
+      getLatestProtocolVersion(),
     );
   });
 
-  describe('constructor', () => {
+  describe.skip('constructor', () => {
     it('should set default protocol version', () => {
       dpp = new DashPlatformProtocol();
 
-      expect(dpp.protocolVersion).to.equal(protocolVersion.latestVersion);
+      expect(dpp.protocolVersion).to.equal(getLatestProtocolVersion());
     });
   });
 
-  describe('getStateRepository', () => {
-    it('should return StateRepository', () => {
-      const result = dpp.getStateRepository();
-
-      expect(result).to.equal(stateRepositoryMock);
-    });
-  });
-
-  describe('setProtocolVersion', () => {
+  describe.skip('setProtocolVersion', () => {
     it('should set protocol version', () => {
-      expect(dpp.protocolVersion).to.equal(protocolVersion.latestVersion);
+      expect(dpp.protocolVersion).to.equal(getLatestProtocolVersion());
 
       dpp.setProtocolVersion(42);
 
@@ -48,9 +33,9 @@ describe('DashPlatformProtocol', () => {
     });
   });
 
-  describe('getProtocolVersion', () => {
+  describe.skip('getProtocolVersion', () => {
     it('should get protocol version', () => {
-      expect(dpp.protocolVersion).to.equal(protocolVersion.latestVersion);
+      expect(dpp.protocolVersion).to.equal(getLatestProtocolVersion());
 
       dpp.setProtocolVersion(42);
 

package/test/unit/dataContract/DataContract.spec.js

@@ -1,97 +1,80 @@
 const bs58 = require('bs58');
 
-const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
-const JsDataContract = require('@dashevo/dpp/lib/dataContract/DataContract');
+const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifierAsync');
 
 const { default: loadWasmDpp } = require('../../../dist');
 
 describe('DataContract', () => {
   let documentType;
   let documentSchema;
-  let documents;
-  let jsDataContract;
+  let documentSchemas;
   let ownerId;
   let entropy;
   let contractId;
   let dataContract;
-  let defs;
+  let schemaDefs;
 
   let DataContract;
-  let DataContractDefaults;
   let Identifier;
   let Metadata;
 
   before(async () => {
     ({
-      DataContract, DataContractDefaults, Identifier, Metadata,
+      DataContract, Identifier, Metadata,
     } = await loadWasmDpp());
   });
 
-  beforeEach(() => {
+  beforeEach(async () => {
     documentType = 'niceDocument';
 
     documentSchema = {
+      type: 'object',
       properties: {
         nice: {
           type: 'boolean',
         },
         aBinaryProperty: {
-          type: 'object',
+          type: 'array',
           byteArray: true,
         },
       },
+      additionalProperties: false,
     };
 
-    documents = {
+    documentSchemas = {
       [documentType]: documentSchema,
     };
 
-    ownerId = generateRandomIdentifier();
+    ownerId = (await generateRandomIdentifier()).toBuffer();
     entropy = Buffer.alloc(32, 420);
-    contractId = generateRandomIdentifier();
-
-    defs = { something: { type: 'string' } };
+    contractId = (await generateRandomIdentifier()).toBuffer();
 
-    jsDataContract = new JsDataContract({
-      $schema: JsDataContract.DEFAULTS.SCHEMA,
-      $id: contractId,
-      version: 1,
-      protocolVersion: 1,
-      ownerId,
-      documents,
-      $defs: defs,
-    });
+    schemaDefs = { something: { type: 'string' } };
 
     dataContract = new DataContract({
-      $schema: DataContractDefaults.SCHEMA,
-      $id: contractId,
+      $format_version: '0',
+      id: contractId,
       version: 1,
-      protocolVersion: 1,
       ownerId,
-      documents,
-      $defs: defs,
+      documentSchemas,
     });
   });
 
   describe('constructor', () => {
-    it('should create new DataContract', () => {
-      const id = generateRandomIdentifier();
-
+    it('should create new DataContract', async () => {
       dataContract = new DataContract({
-        $schema: DataContractDefaults.SCHEMA,
-        $id: id,
-        ownerId,
-        protocolVersion: 1,
+        $format_version: '0',
+        id: contractId,
         version: 1,
-        documents,
-        $defs: defs,
+        ownerId,
+        documentSchemas,
+        schemaDefs,
       });
 
-      expect(dataContract.getId().toBuffer()).to.deep.equal(id.toBuffer());
-      expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(ownerId.toBuffer());
-      expect(dataContract.getJsonMetaSchema()).to.deep.equal(DataContractDefaults.SCHEMA);
-      expect(dataContract.getDocuments()).to.deep.equal(documents);
-      expect(dataContract.getDefinitions()).to.deep.equal(defs);
+      expect(dataContract.getId().toBuffer()).to.deep.equal(contractId);
+      expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(ownerId);
+      expect(dataContract.getDocumentSchemas()).to.deep.equal(documentSchemas);
+      expect(dataContract.getSchemaDefs()).to.deep.equal(schemaDefs);
     });
   });
 
@@ -99,76 +82,54 @@ describe('DataContract', () => {
     it('should return DataContract Identifier', () => {
       const result = dataContract.getId();
 
-      expect(result.toBuffer()).to.deep.equal(contractId.toBuffer());
+      expect(result.toBuffer()).to.deep.equal(contractId);
       expect(result).to.be.instanceof(Identifier);
     });
   });
 
-  describe('#getJsonSchemaId', () => {
-    it('should return JSON Schema ID', () => {
-      const result = dataContract.getJsonSchemaId();
-
-      expect(result).to.equal(dataContract.getId().toString());
-    });
-  });
-
-  describe('#setJsonMetaSchema', () => {
-    it('should set meta schema', () => {
-      const metaSchema = 'http://test.com/schema';
-
-      dataContract.setJsonMetaSchema(metaSchema);
-
-      expect(dataContract.getJsonMetaSchema()).to.deep.equal(metaSchema);
-    });
-  });
-
-  describe('#getJsonMetaSchema', () => {
-    it('should return meta schema', () => {
-      const result = dataContract.getJsonMetaSchema();
-
-      expect(result).to.deep.equal(DataContractDefaults.SCHEMA);
-    });
-  });
-
-  describe('#getDocuments', () => {
+  describe('#getDocumentSchemas', () => {
     it('should get Documents definition', () => {
       const anotherDocuments = {
         anotherDocument: {
+          type: 'object',
           properties: {
             name: { type: 'string' },
           },
+          additionalProperties: false,
         },
       };
 
-      dataContract.setDocuments(anotherDocuments);
-      expect(dataContract.getDocuments()).to.deep.equal(anotherDocuments);
+      dataContract.setDocumentSchemas(anotherDocuments);
+      expect(dataContract.getDocumentSchemas()).to.deep.equal(anotherDocuments);
     });
   });
 
-  describe('#setDocuments', () => {
+  describe('#setDocumentSchemas', () => {
     it('should set Documents definition', () => {
       const anotherDocuments = {
         anotherDocument: {
+          type: 'object',
           properties: {
             name: { type: 'string' },
           },
+          additionalProperties: false,
         },
       };
 
-      dataContract.setDocuments(anotherDocuments);
-      expect(dataContract.getDocuments()).to.deep.equal(anotherDocuments);
+      dataContract.setDocumentSchemas(anotherDocuments);
+      expect(dataContract.getDocumentSchemas()).to.deep.equal(anotherDocuments);
     });
   });
 
-  describe('#isDocumentDefined', () => {
+  describe('#hasDocumentType', () => {
     it('should return true if Document schema is defined', () => {
-      const result = dataContract.isDocumentDefined('niceDocument');
+      const result = dataContract.hasDocumentType('niceDocument');
 
       expect(result).to.equal(true);
     });
 
     it('should return false if Document schema is not defined', () => {
-      const result = dataContract.isDocumentDefined('undefinedDocument');
+      const result = dataContract.hasDocumentType('undefinedDocument');
 
       expect(result).to.equal(false);
     });
@@ -178,18 +139,22 @@ describe('DataContract', () => {
     it('should set Document schema', () => {
       const anotherType = 'prettyDocument';
       const anotherDefinition = {
+        type: 'object',
         properties: {
-          name: { type: 'string' },
+          test: {
+            type: 'string',
+          },
         },
+        additionalProperties: false,
       };
 
       dataContract.setDocumentSchema(anotherType, anotherDefinition);
 
-      const anotherDocuments = dataContract.getDocuments();
+      const anotherDocuments = dataContract.getDocumentSchemas();
 
       expect(anotherDocuments).to.have.property(anotherType);
       expect(anotherDocuments[anotherType]).to.deep.equal(anotherDefinition);
-      expect(dataContract.isDocumentDefined(anotherType)).to.be.true();
+      expect(dataContract.hasDocumentType(anotherType)).to.be.true();
     });
   });
 
@@ -199,7 +164,7 @@ describe('DataContract', () => {
         dataContract.getDocumentSchema('undefinedObject');
         expect.fail('Error was not thrown');
       } catch (e) {
-        expect(e.getType()).to.equal('undefinedObject');
+        expect(e.getMessage()).to.equal('data contract error: document type not found: can not get document type from contract');
       }
     });
 
@@ -210,40 +175,31 @@ describe('DataContract', () => {
     });
   });
 
-  describe('#getDocumentSchemaRef', () => {
-    it('should throw error if Document is not defined', () => {
-      try {
-        dataContract.getDocumentSchemaRef('undefinedObject');
-        expect.fail('Error was not thrown');
-      } catch (e) {
-        expect(e.getType()).to.equal('undefinedObject');
-      }
-    });
-
-    it('should return schema ref', () => {
-      const result = dataContract.getDocumentSchemaRef(documentType);
-
-      expect(result).to.equal(`${dataContract.getJsonSchemaId()}#/documents/niceDocument`);
-    });
-  });
-
-  describe('#setDefinitions', () => {
+  describe('#setSchemaDefs', () => {
     it('should set $defs', () => {
       const $defs = {
-        subSchema: { type: 'object' },
+        subSchema: {
+          type: 'object',
+          properties: {
+            test: {
+              type: 'string',
+            },
+          },
+          additionalProperties: false,
+        },
       };
 
-      dataContract.setDefinitions($defs);
+      dataContract.setSchemaDefs($defs);
 
-      expect(dataContract.getDefinitions()).to.deep.equal($defs);
+      expect(dataContract.getSchemaDefs()).to.deep.equal($defs);
     });
   });
 
-  describe('#getDefinitions', () => {
+  describe('#getSchemaDefs', () => {
     it('should return $defs', () => {
-      const result = dataContract.getDefinitions();
+      const result = dataContract.getSchemaDefs();
 
-      expect(result).to.deep.equal(defs);
+      expect(result).to.be.null();
     });
   });
 
@@ -252,54 +208,72 @@ describe('DataContract', () => {
       const result = dataContract.toJSON();
 
       expect(result).to.deep.equal({
-        protocolVersion: dataContract.getProtocolVersion(),
-        $id: bs58.encode(contractId),
-        $schema: DataContractDefaults.SCHEMA,
+        $format_version: '0',
+        config: {
+          $format_version: '0',
+          canBeDeleted: false,
+          documentsKeepHistoryContractDefault: false,
+          documentsMutableContractDefault: true,
+          keepsHistory: false,
+          readonly: false,
+          requiresIdentityDecryptionBoundedKey: null,
+          requiresIdentityEncryptionBoundedKey: null,
+        },
+        id: bs58.encode(contractId),
         version: 1,
         ownerId: bs58.encode(ownerId),
-        documents,
-        $defs: defs,
+        schemaDefs: null,
+        documentSchemas,
       });
     });
 
     it('should return plain object with "$defs" if present', () => {
       const $defs = {
-        subSchema: { type: 'object' },
+        subSchema: { type: 'string' },
       };
 
-      dataContract.setDefinitions($defs);
+      dataContract.setSchemaDefs($defs);
 
       const result = dataContract.toJSON();
 
       expect(result).to.deep.equal({
-        protocolVersion: dataContract.getProtocolVersion(),
-        $schema: DataContractDefaults.SCHEMA,
-        $id: bs58.encode(contractId),
+        $format_version: '0',
+        config: {
+          $format_version: '0',
+          canBeDeleted: false,
+          documentsKeepHistoryContractDefault: false,
+          documentsMutableContractDefault: true,
+          keepsHistory: false,
+          readonly: false,
+          requiresIdentityDecryptionBoundedKey: null,
+          requiresIdentityEncryptionBoundedKey: null,
+        },
+        id: bs58.encode(contractId),
         version: 1,
         ownerId: bs58.encode(ownerId),
-        documents,
-        $defs,
+        documentSchemas,
+        schemaDefs: $defs,
       });
     });
   });
 
   describe('#toBuffer', () => {
     it('should return DataContract as a Buffer', () => {
-      expect(jsDataContract.getProtocolVersion()).to.deep.equal(dataContract.getProtocolVersion());
-
-      const jsResult = jsDataContract.toBuffer();
-      const wasmResult = dataContract.toBuffer();
-
-      expect(wasmResult).to.deep.equal(jsResult);
+      const result = dataContract.toBuffer();
+      expect(result).to.be.instanceOf(Buffer);
+      expect(result).to.have.lengthOf(211);
     });
   });
 
+  // TODO: can not compare to JS because rust
+  //  DataContract does not match JS anymore
   describe('#hash', () => {
     it('should return DataContract hash', () => {
-      const jsResult = jsDataContract.hash();
+      // const jsResult = jsDataContract.hash();
       const wasmResult = dataContract.hash();
-
-      expect(wasmResult).to.deep.equal(jsResult);
+      //
+      // expect(wasmResult).to.deep.equal(jsResult);
+      expect(wasmResult).to.be.instanceOf(Uint8Array);
     });
   });
 
@@ -311,27 +285,6 @@ describe('DataContract', () => {
     });
   });
 
-  describe('#getBinaryProperties', () => {
-    it('should return flat map of properties with `contentEncoding` keywords', () => {
-      const result = dataContract.getBinaryProperties(documentType);
-      expect(result).to.deep.equal({
-        aBinaryProperty: {
-          type: 'object',
-          byteArray: true,
-        },
-      });
-    });
-
-    it('should throw an error if document type is not found', () => {
-      try {
-        dataContract.getBinaryProperties('unknown');
-        expect.fail('Error was not thrown');
-      } catch (e) {
-        expect(e.getType()).to.equal('unknown');
-      }
-    });
-  });
-
   describe('#setMetadata', () => {
     it('should set metadata', () => {
       const otherMetadata = new Metadata({
@@ -347,4 +300,22 @@ describe('DataContract', () => {
       expect(dataContract.getMetadata().toObject()).to.deep.equal(otherMetadataToObject);
     });
   });
+
+  describe.skip('#setConfig', () => {
+    it('should set config', () => {
+      const config = {
+        allow: true,
+        readonly: true,
+        keepsHistory: true,
+        documentsKeepHistoryContractDefault: true,
+        documentsMutableContractDefault: true,
+      };
+
+      dataContract.setConfig(config);
+
+      const restoredConfig = dataContract.getConfig();
+
+      expect(config).to.deep.equal(restoredConfig);
+    });
+  });
 });

package/test/unit/dataContract/DataContractFactory.spec.js

@@ -1,19 +1,17 @@
-const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
 
-const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const { default: loadWasmDpp, UnsupportedProtocolVersionError } = require('../../..');
+const { getLatestProtocolVersion } = require('../../..');
 
-const { default: loadWasmDpp } = require('../../../dist');
-
-describe('DataContractFactory', () => {
+describe.skip('DataContractFactory', () => {
   let DataContractFactory;
   let DataContractValidator;
   let DataContract;
   let InvalidDataContractError;
-  let SerializedObjectParsingError;
   let JsonSchemaError;
 
   let factory;
-  let jsDataContract;
+  let dataContract;
   let rawDataContract;
   let dataContractValidator;
 
@@ -23,18 +21,13 @@ describe('DataContractFactory', () => {
       DataContractValidator,
       DataContract,
       InvalidDataContractError,
-      SerializedObjectParsingError,
       JsonSchemaError,
     } = await loadWasmDpp());
   });
 
-  beforeEach(() => {
-    jsDataContract = getDataContractFixture();
-
-    // For some reason fixture has empty $defs which violates meta schema
-    delete jsDataContract.$defs;
-
-    rawDataContract = jsDataContract.toObject();
+  beforeEach(async () => {
+    dataContract = await getDataContractFixture();
+    rawDataContract = dataContract.toObject();
 
     dataContractValidator = new DataContractValidator();
 
@@ -47,12 +40,32 @@ describe('DataContractFactory', () => {
   describe('create', () => {
     it('should return new Data Contract with specified name and documents definition', () => {
       const result = factory.create(
-        jsDataContract.ownerId.toBuffer(),
+        dataContract.getOwnerId(),
         rawDataContract.documents,
       ).toObject();
 
       expect(result).excluding('$id').to.deep.equal(rawDataContract);
     });
+
+    it('should pass config', () => {
+      const config = {
+        canBeDeleted: false,
+        readonly: false,
+        keepsHistory: true,
+        documentsKeepHistoryContractDefault: false,
+        documentsMutableContractDefault: true,
+      };
+      const contract = factory.create(
+        dataContract.getOwnerId(),
+        rawDataContract.documents,
+        config,
+      );
+
+      const result = contract.toObject();
+
+      expect(contract.getConfig()).to.be.deep.equal(config);
+      expect(result).excluding('$id').to.deep.equal(rawDataContract);
+    });
   });
 
   describe('createFromObject', () => {
@@ -62,8 +75,7 @@ describe('DataContractFactory', () => {
     });
 
     it('should return new Data Contract without validation if "skipValidation" option is passed', async () => {
-      const alteredContract = jsDataContract.toObject();
-      alteredContract.$defs = {}; // Empty defs are bad!
+      const alteredContract = dataContract.toObject();
 
       const resultSkipValidation = await factory.createFromObject(alteredContract, true);
 
@@ -71,8 +83,7 @@ describe('DataContractFactory', () => {
     });
 
     it('should throw an error if passed object is not valid', async () => {
-      const alteredContract = jsDataContract.toObject();
-      alteredContract.$defs = {}; // Empty defs are bad!
+      const alteredContract = dataContract.toObject();
 
       try {
         await factory.createFromObject(alteredContract);
@@ -91,24 +102,24 @@ describe('DataContractFactory', () => {
     let serializedDataContract;
 
     beforeEach(() => {
-      serializedDataContract = jsDataContract.toBuffer();
+      serializedDataContract = dataContract.toBuffer();
     });
 
     it('should return new Data Contract from serialized contract', async () => {
       const result = await factory.createFromBuffer(serializedDataContract);
 
-      expect(result.toObject()).to.deep.equal(jsDataContract.toObject());
+      expect(result.toObject()).to.deep.equal(dataContract.toObject());
     });
 
     it('should throw InvalidDataContractError if the decoding fails with consensus error', async () => {
       try {
         // Casually break serialized data contract:
-        serializedDataContract[5] += 1337;
+        serializedDataContract[0] = 3;
         await factory.createFromBuffer(serializedDataContract);
         expect.fail('should throw InvalidDataContractError');
       } catch (e) {
-        expect(e).to.be.an.instanceOf(SerializedObjectParsingError);
-        expect(e.getParsingError()).to.equals('Syntax(1)');
+        expect(e).to.be.an.instanceOf(InvalidDataContractError);
+        expect(e.getErrors()[0]).to.be.an.instanceOf(UnsupportedProtocolVersionError);
       }
     });
   });
@@ -116,14 +127,14 @@ describe('DataContractFactory', () => {
   describe('createDataContractCreateTransition', () => {
     it('should return new DataContractCreateTransition with passed DataContract', async () => {
       // Create wasm version of DataContract
-      const dataContract = new DataContract(rawDataContract);
-      dataContract.setEntropy(jsDataContract.getEntropy());
+      const newDataContract = new DataContract(rawDataContract);
+      newDataContract.setEntropy(dataContract.getEntropy());
 
-      const result = await factory.createDataContractCreateTransition(dataContract);
+      const result = await factory.createDataContractCreateTransition(newDataContract);
 
-      expect(result.getProtocolVersion()).to.equal(protocolVersion.latestVersion);
-      expect(result.getEntropy()).to.deep.equal(jsDataContract.getEntropy());
-      expect(result.getDataContract().toObject()).to.deep.equal(jsDataContract.toObject());
+      expect(result.getProtocolVersion()).to.equal(getLatestProtocolVersion());
+      expect(result.getEntropy()).to.deep.equal(dataContract.getEntropy());
+      expect(result.getDataContract().toObject()).to.deep.equal(dataContract.toObject());
     });
   });
 });