@dashevo/wasm-dpp 0.25.0-dev.15 → 0.25.0-dev.17

package/test/integration/stateTransition/StateTransitionFacade.spec.js

@@ -1,15 +1,12 @@
 const { PrivateKey } = require('@dashevo/dashcore-lib');
 const crypto = require('crypto');
 
-const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
-
 const getIdentityFixture = require('../../../lib/test/fixtures/getIdentityFixture');
 const getIdentityCreateTransitionFixture = require('../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
 const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
 const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
 
 const { default: loadWasmDpp } = require('../../../dist');
-const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
 const generateRandomIdentifierAsync = require('../../../lib/test/utils/generateRandomIdentifierAsync');
 
 describe('StateTransitionFacade', () => {
@@ -24,37 +21,35 @@ describe('StateTransitionFacade', () => {
 
   let DashPlatformProtocol;
   let DataContractFactory;
-  let DataContractValidator;
+  // let DataContractValidator;
   let DataContractCreateTransition;
-  let Identity;
+  // let Identity;
   let ValidationResult;
   let IdentityPublicKey;
   let DocumentFactory;
-  let DocumentValidator;
-  let ProtocolVersionValidator;
+  // let DocumentValidator;
+  // let ProtocolVersionValidator;
   let UnsupportedProtocolVersionError;
   let InvalidStateTransitionSignatureError;
   let DataContractAlreadyPresentError;
   let BalanceIsNotEnoughError;
-  let StateTransitionExecutionContext;
+  // let StateTransitionExecutionContext;
 
   before(async () => {
     ({
       DashPlatformProtocol,
       ValidationResult,
       DataContractCreateTransition,
-      Identity,
-      DataContractValidator,
+      // Identity,
       DataContractFactory,
       IdentityPublicKey,
       DocumentFactory,
-      DocumentValidator,
-      ProtocolVersionValidator,
+      // DocumentValidator,
+      // ProtocolVersionValidator,
       UnsupportedProtocolVersionError,
       InvalidStateTransitionSignatureError,
       DataContractAlreadyPresentError,
       BalanceIsNotEnoughError,
-      StateTransitionExecutionContext,
     } = await loadWasmDpp());
   });
 
@@ -65,23 +60,21 @@ describe('StateTransitionFacade', () => {
     const publicKey = privateKeyModel.toPublicKey().toBuffer();
     const publicKeyId = 1;
 
-    executionContext = new StateTransitionExecutionContext();
+    // executionContext = new StateTransitionExecutionContext();
 
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    identityPublicKey = new IdentityPublicKey(1);
 
-    identityPublicKey = new IdentityPublicKey({
-      id: publicKeyId,
-      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-      data: publicKey,
-      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-      securityLevel: IdentityPublicKey.SECURITY_LEVELS.HIGH,
-      readOnly: false,
-    });
+    identityPublicKey.setId(publicKeyId);
+    identityPublicKey.setType(IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+    identityPublicKey.setData(publicKey);
+    identityPublicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.CRITICAL);
+    identityPublicKey.setPurpose(IdentityPublicKey.PURPOSES.AUTHENTICATION);
+    identityPublicKey.setReadOnly(false);
 
     dataContract = await getDataContractFixture();
 
-    const dataContractValidator = new DataContractValidator();
-    const dataContractFactory = new DataContractFactory(1, dataContractValidator);
+    // const dataContractValidator = new DataContractValidator();
+    const dataContractFactory = new DataContractFactory(1);
 
     dataContractCreateTransition = await dataContractFactory.createDataContractCreateTransition(
       dataContract,
@@ -91,38 +84,36 @@ describe('StateTransitionFacade', () => {
       privateKey,
     );
 
-    const documentValidator = new DocumentValidator(new ProtocolVersionValidator());
-    const documentFactory = new DocumentFactory(1, documentValidator, stateRepositoryMock);
+    // const documentValidator = new DocumentValidator(new ProtocolVersionValidator());
+    // documentValidator, stateRepositoryMock
+    const documentFactory = new DocumentFactory(1);
+
+    identityPublicKey = new IdentityPublicKey(1);
+
+    identityPublicKey.setId(publicKeyId);
+    identityPublicKey.setType(IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+    identityPublicKey.setData(publicKey);
+    identityPublicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.HIGH);
+    identityPublicKey.setPurpose(IdentityPublicKey.PURPOSES.AUTHENTICATION);
+    identityPublicKey.setReadOnly(false);
 
     documentsBatchTransition = documentFactory.createStateTransition({
       create: await getDocumentsFixture(dataContract),
     });
     await documentsBatchTransition.sign(identityPublicKey, privateKey);
 
-    const identityObject = (await getIdentityFixture()).toObject();
-    identityObject.id = await generateRandomIdentifierAsync();
-    identityObject.balance = 10000000;
-    identity = new Identity(identityObject);
+    identity = await getIdentityFixture();
+    identity.setId(await generateRandomIdentifierAsync());
+    identity.setBalance(10000000);
     identity.setPublicKeys([identityPublicKey]);
 
-    const blockTime = Date.now();
-
-    stateRepositoryMock.fetchIdentity.resolves(identity);
-    stateRepositoryMock.fetchIdentityBalance.resolves(identity.getBalance());
-    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
-    stateRepositoryMock.fetchDataContract.resolves(null);
-
-    const blsAdapter = await getBlsAdapterMock();
-
     dpp = new DashPlatformProtocol(
-      blsAdapter,
-      stateRepositoryMock,
       { generate: () => crypto.randomBytes(32) },
       1,
     );
   });
 
-  describe('createFromObject', () => {
+  describe.skip('createFromObject', () => {
     it('should create State Transition from plain object', async () => {
       const object = dataContractCreateTransition.toObject();
       const result = await dpp.stateTransition.createFromObject(
@@ -147,7 +138,7 @@ describe('StateTransitionFacade', () => {
     });
   });
 
-  describe('validate', () => {
+  describe.skip('validate', () => {
     it('should return invalid result if State Transition structure is invalid', async () => {
       const rawStateTransition = dataContractCreateTransition.toObject();
       rawStateTransition.protocolVersion = 100;
@@ -227,7 +218,7 @@ describe('StateTransitionFacade', () => {
     });
   });
 
-  describe('validateBasic', () => {
+  describe.skip('validateBasic', () => {
     it('should validate State Transition', async () => {
       const result = await dpp.stateTransition.validateBasic(
         dataContractCreateTransition.toObject(), executionContext,
@@ -238,7 +229,7 @@ describe('StateTransitionFacade', () => {
     });
   });
 
-  describe('validateSignature', () => {
+  describe.skip('validateSignature', () => {
     it('should validate identity signed State Transition', async () => {
       const result = await dpp.stateTransition.validateSignature(
         dataContractCreateTransition, executionContext,
@@ -269,7 +260,7 @@ describe('StateTransitionFacade', () => {
     });
   });
 
-  describe('validateFee', () => {
+  describe.skip('validateFee', () => {
     it('should validate State Transition', async () => {
       const result = await dpp.stateTransition.validateFee(
         dataContractCreateTransition,
@@ -281,7 +272,7 @@ describe('StateTransitionFacade', () => {
     });
   });
 
-  describe('validateState', () => {
+  describe.skip('validateState', () => {
     it('should validate State Transition', async () => {
       const result = await dpp.stateTransition.validateState(
         dataContractCreateTransition,

package/test/integration/util/generateTemporaryEcdsaPrivateKey.spec.js

@@ -3,7 +3,7 @@ const { default: loadWasmDpp } = require('../../..');
 
 let { generateTemporaryEcdsaPrivateKey } = require('../../..');
 
-describe('generateTemporaryEcdsaPrivateKey', () => {
+describe.skip('generateTemporaryEcdsaPrivateKey', () => {
   beforeEach(async () => {
     ({ generateTemporaryEcdsaPrivateKey } = await loadWasmDpp());
   });

package/test/unit/DashPlatformProtocol.spec.js

@@ -1,27 +1,21 @@
 const crypto = require('crypto');
 
-const createStateRepositoryMock = require('../../lib/test/mocks/createStateRepositoryMock');
-const getBlsAdapterMock = require('../../lib/test/mocks/getBlsAdapterMock');
 const { DashPlatformProtocol, getLatestProtocolVersion } = require('../..');
 const { default: loadWasmDpp } = require('../..');
 
 describe('DashPlatformProtocol', () => {
   let dpp;
-  let stateRepositoryMock;
 
-  beforeEach(async function beforeEach() {
+  beforeEach(async () => {
     await loadWasmDpp();
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
     dpp = new DashPlatformProtocol(
-      getBlsAdapterMock(),
-      stateRepositoryMock,
       { generate: () => crypto.randomBytes(32) },
       getLatestProtocolVersion(),
     );
   });
 
-  describe('constructor', () => {
+  describe.skip('constructor', () => {
     it('should set default protocol version', () => {
       dpp = new DashPlatformProtocol();
 
@@ -29,15 +23,7 @@ describe('DashPlatformProtocol', () => {
     });
   });
 
-  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(getLatestProtocolVersion());
 
@@ -47,7 +33,7 @@ describe('DashPlatformProtocol', () => {
     });
   });
 
-  describe('getProtocolVersion', () => {
+  describe.skip('getProtocolVersion', () => {
     it('should get protocol version', () => {
       expect(dpp.protocolVersion).to.equal(getLatestProtocolVersion());
 

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

@@ -7,21 +7,20 @@ const { default: loadWasmDpp } = require('../../../dist');
 describe('DataContract', () => {
   let documentType;
   let documentSchema;
-  let documents;
+  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());
   });
 
@@ -29,18 +28,20 @@ describe('DataContract', () => {
     documentType = 'niceDocument';
 
     documentSchema = {
+      type: 'object',
       properties: {
         nice: {
           type: 'boolean',
         },
         aBinaryProperty: {
-          type: 'object',
+          type: 'array',
           byteArray: true,
         },
       },
+      additionalProperties: false,
     };
 
-    documents = {
+    documentSchemas = {
       [documentType]: documentSchema,
     };
 
@@ -48,38 +49,32 @@ describe('DataContract', () => {
     entropy = Buffer.alloc(32, 420);
     contractId = (await generateRandomIdentifier()).toBuffer();
 
-    defs = { something: { type: 'string' } };
+    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', async () => {
-      const id = (await generateRandomIdentifier()).toBuffer();
-
       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);
+      expect(dataContract.getId().toBuffer()).to.deep.equal(contractId);
       expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(ownerId);
-      expect(dataContract.getJsonMetaSchema()).to.deep.equal(DataContractDefaults.SCHEMA);
-      expect(dataContract.getDocuments()).to.deep.equal(documents);
-      expect(dataContract.getDefinitions()).to.deep.equal(defs);
+      expect(dataContract.getDocumentSchemas()).to.deep.equal(documentSchemas);
+      expect(dataContract.getSchemaDefs()).to.deep.equal(schemaDefs);
     });
   });
 
@@ -92,71 +87,49 @@ describe('DataContract', () => {
     });
   });
 
-  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);
     });
@@ -166,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();
     });
   });
 
@@ -187,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');
       }
     });
 
@@ -198,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();
     });
   });
 
@@ -240,33 +208,47 @@ 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,
+        },
+        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,
+        },
+        id: bs58.encode(contractId),
         version: 1,
         ownerId: bs58.encode(ownerId),
-        documents,
-        $defs,
+        documentSchemas,
+        schemaDefs: $defs,
       });
     });
   });
@@ -275,7 +257,7 @@ describe('DataContract', () => {
     it('should return DataContract as a Buffer', () => {
       const result = dataContract.toBuffer();
       expect(result).to.be.instanceOf(Buffer);
-      expect(result).to.have.lengthOf(251);
+      expect(result).to.have.lengthOf(209);
     });
   });
 
@@ -299,27 +281,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({
@@ -335,4 +296,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

@@ -3,7 +3,7 @@ const getDataContractFixture = require('../../../lib/test/fixtures/getDataContra
 const { default: loadWasmDpp, UnsupportedProtocolVersionError } = require('../../..');
 const { getLatestProtocolVersion } = require('../../..');
 
-describe('DataContractFactory', () => {
+describe.skip('DataContractFactory', () => {
   let DataContractFactory;
   let DataContractValidator;
   let DataContract;
@@ -46,6 +46,26 @@ describe('DataContractFactory', () => {
 
       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', () => {