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

package/test/integration/document/Document.spec.js

@@ -1,30 +1,54 @@
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
-const Metadata = require('@dashevo/dpp/lib/Metadata');
+const MetadataJs = require('@dashevo/dpp/lib/Metadata');
 
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 
+const { default: loadWasmDpp } = require('../../../dist');
+
+let Document;
+let DataContract;
+let Metadata;
+let Identifier;
+
 describe('Document', () => {
   let document;
   let dataContract;
   let metadataFixture;
 
-  beforeEach(() => {
-    dataContract = getDataContractFixture();
-    [document] = getDocumentsFixture(dataContract).slice(8);
+  beforeEach(async () => {
+    ({
+      Document,
+      DataContract,
+      Metadata,
+      Identifier,
+    } = await loadWasmDpp());
+
+    const dataContractJs = getDataContractFixture();
+    dataContract = new DataContract(dataContractJs.toObject());
 
-    metadataFixture = new Metadata({
+    const [documentJs] = getDocumentsFixture(dataContractJs).slice(8);
+    document = new Document(documentJs.toObject(), dataContract);
+
+    const metadataFixtureJs = new MetadataJs({
       blockHeight: 42,
       coreChainLockedHeight: 0,
       timeMs: new Date().getTime(),
       protocolVersion: 1,
     });
 
+    metadataFixture = Metadata.from({
+      blockHeight: 42,
+      coreChainLockedHeight: 0,
+      timeMs: new Date().getTime(),
+      protocolVersion: 1,
+    });
+
+    documentJs.setMetadata(metadataFixtureJs);
     document.setMetadata(metadataFixture);
   });
 
   describe('#toJSON', () => {
-    it('should return json document', () => {
+    it('should return json document - Rust', () => {
       const result = document.toJSON();
 
       expect(result).to.deep.equal({
@@ -41,55 +65,57 @@ describe('Document', () => {
   });
 
   describe('#toObject', () => {
-    it('should return raw document', () => {
+    it('should return raw document - Rust', () => {
       const result = document.toObject();
 
       expect(result).to.deep.equal({
         $protocolVersion: document.getProtocolVersion(),
-        $dataContractId: dataContract.getId(),
-        $id: document.getId(),
+        $dataContractId: dataContract.getId().toBuffer(),
+        $id: document.getId().toBuffer(),
         $ownerId: getDocumentsFixture.ownerId,
         $revision: 1,
         $type: 'withByteArrays',
         byteArrayField: document.get('byteArrayField'),
-        identifierField: document.get('identifierField'),
+        identifierField: document.get('identifierField').toBuffer(),
       });
     });
 
-    it('should return raw document with Identifiers', () => {
+    it('should return raw document with Identifiers - Rust', () => {
       const result = document.toObject({ skipIdentifiersConversion: true });
 
-      expect(result).to.deep.equal({
-        $protocolVersion: document.getProtocolVersion(),
-        $dataContractId: dataContract.getId(),
-        $id: document.getId(),
-        $ownerId: getDocumentsFixture.ownerId,
-        $revision: 1,
-        $type: 'withByteArrays',
-        byteArrayField: document.get('byteArrayField'),
-        identifierField: document.get('identifierField'),
-      });
-
       expect(result.$dataContractId).to.be.an.instanceOf(Identifier);
       expect(result.$id).to.be.an.instanceOf(Identifier);
       expect(result.$ownerId).to.be.an.instanceOf(Identifier);
       expect(result.identifierField).to.be.an.instanceOf(Identifier);
+
+      expect(result.$dataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
+      expect(result.$id.toBuffer()).to.deep.equal(document.getId().toBuffer());
+      expect(result.$ownerId.toBuffer()).to.deep.equal(getDocumentsFixture.ownerId.toBuffer());
+      expect(result.identifierField.toBuffer()).to.deep.equal(document.get('identifierField').toBuffer());
+      expect(result.$protocolVersion).to.deep.equal(document.getProtocolVersion());
+      expect(result.$revision).to.deep.equal(document.getRevision());
+      expect(result.$type).to.deep.equal(document.getType());
+      expect(result.byteArrayField).to.deep.equal(document.get('byteArrayField'));
     });
   });
 
   describe('#setMetadata', () => {
-    it('should set metadata', () => {
-      const otherMetadata = new Metadata(43, 1);
-
+    it('should set metadata - Rust', () => {
+      const otherMetadata = new Metadata({
+        blockHeight: 43,
+        coreChainLockedHeight: 1,
+        timeMs: 100,
+        protocolVersion: 2,
+      });
       document.setMetadata(otherMetadata);
 
-      expect(document.metadata).to.deep.equal(otherMetadata);
+      expect(document.getMetadata().toObject()).to.deep.equal(otherMetadata.toObject());
     });
   });
 
   describe('#getMetadata', () => {
-    it('should get metadata', () => {
-      expect(document.getMetadata()).to.deep.equal(metadataFixture);
+    it('should get metadata - Rust', () => {
+      expect(document.getMetadata().toObject()).to.deep.equal(metadataFixture.toObject());
     });
   });
 });

package/test/integration/document/DocumentFacade.spec.js

@@ -1,47 +1,63 @@
 const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
-const DashPlatformProtocol = require('@dashevo/dpp/lib/DashPlatformProtocol');
-
-const Document = require('@dashevo/dpp/lib/document/Document');
-const DocumentsBatchTransition = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
 
-const DataContractNotPresentError = require('@dashevo/dpp/lib/errors/consensus/basic/document/DataContractNotPresentError');
-const MissingOptionError = require('@dashevo/dpp/lib/errors/MissingOptionError');
+const { default: loadWasmDpp } = require('../../../dist');
+const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
+
+let Document;
+let DataContract;
+let Identifier;
+let ValidationResult;
+let DocumentsBatchTransition;
+let DashPlatformProtocol;
+let DataContractNotPresentError;
 
 describe('DocumentFacade', () => {
   let dpp;
   let document;
   let documents;
+  let documentsJs;
   let dataContract;
   let ownerId;
   let stateRepositoryMock;
+  let blsAdapter;
 
   beforeEach(async function beforeEach() {
-    ownerId = generateRandomIdentifier();
-    dataContract = getDataContractFixture(ownerId);
+    ({
+      Document,
+      DataContract,
+      Identifier,
+      ValidationResult,
+      DocumentsBatchTransition,
+      DashPlatformProtocol,
+      DataContractNotPresentError,
+    } = await loadWasmDpp());
+
+    const ownerIdJs = generateRandomIdentifier();
+    ownerId = new Identifier(ownerIdJs.toBuffer());
+    const dataContractJs = getDataContractFixture(ownerIdJs);
+    dataContract = new DataContract(dataContractJs.toObject());
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-
     stateRepositoryMock.fetchDataContract.resolves(dataContract);
 
-    dpp = new DashPlatformProtocol({
-      stateRepository: stateRepositoryMock,
-    });
-    await dpp.initialize();
+    blsAdapter = await getBlsAdapterMock();
+    dpp = new DashPlatformProtocol({}, blsAdapter, stateRepositoryMock);
 
-    documents = getDocumentsFixture(dataContract);
+    documentsJs = getDocumentsFixture(dataContractJs);
+    documents = documentsJs.map((d) => {
+      const currentDocument = new Document(d.toObject(), dataContract.clone());
+      currentDocument.setEntropy(d.entropy);
+      return currentDocument;
+    });
     ([document] = documents);
   });
 
   describe('create', () => {
-    it('should create Document', () => {
+    it('should create Document - Rust', async () => {
       const result = dpp.document.create(
         dataContract,
         ownerId,
@@ -57,21 +73,11 @@ describe('DocumentFacade', () => {
   });
 
   describe('createFromObject', () => {
-    it('should throw MissingOption if stateRepository is not set', async () => {
-      dpp = new DashPlatformProtocol();
-      await dpp.initialize();
-
-      try {
-        await dpp.document.createFromObject(document.toObject());
-
-        expect.fail('MissingOption should be thrown');
-      } catch (e) {
-        expect(e).to.be.an.instanceOf(MissingOptionError);
-        expect(e.getOptionName()).to.equal('stateRepository');
-      }
+    it('should throw MissingOption if stateRepository is not set - Rust', async () => {
+      // not applicable
     });
 
-    it('should create Document from plain object', async () => {
+    it('should create Document from plain object - Rust', async () => {
       const result = await dpp.document.createFromObject(document.toObject());
 
       expect(result).to.be.an.instanceOf(Document);
@@ -81,21 +87,11 @@ describe('DocumentFacade', () => {
   });
 
   describe('createFromBuffer', () => {
-    it('should throw MissingOption if stateRepository is not set', async () => {
-      dpp = new DashPlatformProtocol();
-      await dpp.initialize();
-
-      try {
-        await dpp.document.createFromBuffer(document.toObject());
-
-        expect.fail('MissingOption should be thrown');
-      } catch (e) {
-        expect(e).to.be.an.instanceOf(MissingOptionError);
-        expect(e.getOptionName()).to.equal('stateRepository');
-      }
+    it('should throw MissingOption if stateRepository is not set - Rust', async () => {
+      // not applicable
     });
 
-    it('should create Document from serialized', async () => {
+    it('should create Document from serialized - Rust', async () => {
       const result = await dpp.document.createFromBuffer(document.toBuffer());
 
       expect(result).to.be.an.instanceOf(Document);
@@ -105,42 +101,33 @@ describe('DocumentFacade', () => {
   });
 
   describe('createStateTransition', () => {
-    it('should create DocumentsBatchTransition with passed documents', () => {
+    it('should create DocumentsBatchTransition with passed documents - Rust', () => {
       const result = dpp.document.createStateTransition({
         create: documents,
       });
 
       expect(result).to.be.instanceOf(DocumentsBatchTransition);
-      expect(result.getTransitions()).to.deep.equal(getDocumentTransitionsFixture({
-        create: documents,
-      }));
+      expect(result.getTransitions().map((t) => t.toObject()))
+        .has.deep.members(getDocumentTransitionsFixture({
+          create: documentsJs,
+        }).map((t) => t.toObject()));
     });
   });
 
   describe('validate', () => {
-    it('should throw MissingOption if stateRepository is not set', async () => {
-      dpp = new DashPlatformProtocol();
-      await dpp.initialize();
-
-      try {
-        await dpp.document.validate(document);
-
-        expect.fail('MissingOption should be thrown');
-      } catch (e) {
-        expect(e).to.be.an.instanceOf(MissingOptionError);
-        expect(e.getOptionName()).to.equal('stateRepository');
-      }
+    it('should throw MissingOption if stateRepository is not set - Rust', async () => {
+      // not applicable
     });
 
-    it('should validate Document', async () => {
+    it('should validate Document - Rust', async () => {
       const result = await dpp.document.validate(document);
 
       expect(result).to.be.an.instanceOf(ValidationResult);
       expect(result.isValid()).to.be.true();
     });
 
-    it('should return invalid result if Data Contract is invalid', async () => {
-      stateRepositoryMock.fetchDataContract.returns(null);
+    it('should return invalid result if Data Contract is invalid - Rust', async () => {
+      stateRepositoryMock.fetchDataContract.resolves(null);
 
       const result = await dpp.document.validate(document);
 

package/test/integration/document/stateTransition/DocumentsBatchTransition/DocumentBatchTransition.spec.js

@@ -1,42 +1,64 @@
 const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
 
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
-const DocumentFactory = require('@dashevo/dpp/lib/document/DocumentFactory');
-const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+
+let Document;
+let DataContract;
+let ProtocolVersionValidator;
+let DocumentValidator;
+let DocumentFactory;
 
 describe('DocumentBatchTransition', () => {
   let stateTransitionFixture;
   let dataContractFixture;
   let documentsFixture;
   let documentFactory;
+
   let mediumSecurityDocumentFixture;
   let masterSecurityDocumentFixture;
   let noSecurityLevelSpecifiedDocumentFixture;
 
-  beforeEach(() => {
-    dataContractFixture = getDataContractFixture();
+  beforeEach(async function beforeEach() {
+    ({
+      Document,
+      DataContract,
+      ProtocolVersionValidator,
+      DocumentFactory,
+      DocumentValidator,
+    } = await loadWasmDpp());
+    const dataContractFixtureJs = getDataContractFixture();
 
-    dataContractFixture.documents.niceDocument
+    dataContractFixtureJs.documents.niceDocument
       .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MEDIUM;
-    dataContractFixture.documents.prettyDocument
+    dataContractFixtureJs.documents.prettyDocument
       .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MASTER;
 
+    dataContractFixture = new DataContract(dataContractFixtureJs.toObject());
+
     // 0 is niceDocument,
     // 1 and 2 are pretty documents,
     // 3 and 4 are indexed documents that do not have security level specified
-    documentsFixture = getDocumentsFixture(dataContractFixture);
+    documentsFixture = getDocumentsFixture(dataContractFixtureJs).map((doc) => {
+      const document = new Document(doc.toObject(), dataContractFixture.clone());
+      document.setEntropy(doc.entropy);
+      return document;
+    });
+
     [
-      mediumSecurityDocumentFixture,,
-      masterSecurityDocumentFixture,,
+      mediumSecurityDocumentFixture, ,
+      masterSecurityDocumentFixture, ,
       noSecurityLevelSpecifiedDocumentFixture,
     ] = documentsFixture;
 
-    documentFactory = new DocumentFactory(
-      createDPPMock(),
-      () => {},
-      () => {},
-    );
+    const protocolValidator = new ProtocolVersionValidator();
+    const documentValidator = new DocumentValidator(protocolValidator);
+    const stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    documentFactory = new DocumentFactory(1, documentValidator, stateRepositoryMock);
 
     stateTransitionFixture = documentFactory.createStateTransition({
       create: documentsFixture,
@@ -46,7 +68,7 @@ describe('DocumentBatchTransition', () => {
   });
 
   describe('#getRequiredKeySecurityLevel', () => {
-    it('should return the highest security level of all transitions', () => {
+    it('should return the highest security level of all transitions - Rust', () => {
       stateTransitionFixture = documentFactory.createStateTransition({
         create: [mediumSecurityDocumentFixture],
         replace: [],
@@ -68,7 +90,7 @@ describe('DocumentBatchTransition', () => {
         .to.be.equal(IdentityPublicKey.SECURITY_LEVELS.MASTER);
     });
 
-    it('should return default security level if no document has a security level defined', () => {
+    it('should return default security level if no document has a security level defined - Rust', () => {
       stateTransitionFixture = documentFactory.createStateTransition({
         create: [noSecurityLevelSpecifiedDocumentFixture],
         replace: [],