@dashevo/wasm-dpp 0.23.0-dev.14 → 0.24.0-dev.10

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

@@ -1,178 +1,122 @@
-const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const protocolVersion = require('../../../lib/version/protocolVersion');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const DataContractCreateTransition = require('../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-
-const ValidationResult = require('../../../lib/validation/ValidationResult');
-
-const InvalidDataContractError = require('../../../lib/dataContract/errors/InvalidDataContractError');
-const SerializedObjectParsingError = require('../../../lib/errors/consensus/basic/decode/SerializedObjectParsingError');
-const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
-const SomeConsensusError = require('../../../lib/test/mocks/SomeConsensusError');
-
-const DataContractFactory = require('../../../lib/dataContract/DataContractFactory');
-const entropyGenerator = require('../../../lib/util/entropyGenerator');
+const { default: loadWasmDpp } = require('../../../dist');
 
 describe('DataContractFactory', () => {
-  let decodeProtocolEntityMock;
-  let validateDataContractMock;
+  let DataContractFactory;
+  let DataContractValidator;
+  let DataContract;
+  let InvalidDataContractError;
+
   let factory;
-  let dataContract;
+  let jsDataContract;
   let rawDataContract;
-  let generateEntropyMock;
-  let dppMock;
+  let dataContractValidator;
+
+  before(async () => {
+    ({
+      DataContractFactory, DataContractValidator, DataContract, InvalidDataContractError,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
-    dppMock = createDPPMock();
+  beforeEach(() => {
+    jsDataContract = getDataContractFixture();
 
-    rawDataContract = dataContract.toObject();
+    // For some reason fixture has empty $defs which violates meta schema
+    delete jsDataContract.$defs;
 
-    decodeProtocolEntityMock = this.sinonSandbox.stub();
-    validateDataContractMock = this.sinonSandbox.stub();
-    generateEntropyMock = this.sinonSandbox.stub(entropyGenerator, 'generate');
+    rawDataContract = jsDataContract.toObject();
+
+    dataContractValidator = new DataContractValidator();
 
     factory = new DataContractFactory(
-      dppMock,
-      validateDataContractMock,
-      decodeProtocolEntityMock,
+      1,
+      dataContractValidator,
     );
   });
 
-  afterEach(() => {
-    generateEntropyMock.restore();
-  });
-
   describe('create', () => {
     it('should return new Data Contract with specified name and documents definition', () => {
-      generateEntropyMock.returns(dataContract.getEntropy());
       const result = factory.create(
-        dataContract.ownerId.toBuffer(),
+        jsDataContract.ownerId.toBuffer(),
         rawDataContract.documents,
-      );
+      ).toObject();
 
-      expect(result).excluding('$defs').to.deep.equal(dataContract);
+      expect(result).excluding('$id').to.deep.equal(rawDataContract);
     });
   });
 
   describe('createFromObject', () => {
     it('should return new Data Contract with data from passed object', async () => {
-      validateDataContractMock.returns(new ValidationResult());
-
       const result = await factory.createFromObject(rawDataContract);
-
       expect(result.toObject()).excluding('entropy').to.deep.equal(rawDataContract);
-
-      expect(validateDataContractMock).to.have.been.calledOnceWith(rawDataContract);
     });
 
     it('should return new Data Contract without validation if "skipValidation" option is passed', async () => {
-      const result = await factory.createFromObject(rawDataContract, { skipValidation: true });
+      const alteredContract = jsDataContract.toObject();
+      alteredContract.$defs = {}; // Empty defs are bad!
 
-      expect(result.toObject()).excluding('entropy').to.deep.equal(rawDataContract);
+      const resultSkipValidation = await factory.createFromObject(alteredContract, true);
 
-      expect(validateDataContractMock).to.have.not.been.called();
+      expect(resultSkipValidation.toObject()).excluding('entropy').to.deep.equal(alteredContract);
     });
 
     it('should throw an error if passed object is not valid', async () => {
-      const validationError = new SomeConsensusError('test');
-
-      validateDataContractMock.returns(new ValidationResult([validationError]));
+      const alteredContract = jsDataContract.toObject();
+      alteredContract.$defs = {}; // Empty defs are bad!
 
-      let error;
       try {
-        await factory.createFromObject(rawDataContract);
+        await factory.createFromObject(alteredContract);
       } catch (e) {
-        error = e;
+        expect(e).to.be.an.instanceOf(InvalidDataContractError);
+        expect(e.getRawDataContract()).to.deep.equal(alteredContract);
+        expect(e.getErrors()).to.have.length(1);
+        // TODO JsonSchemaError binding type required
+        // const [consensusError] = error.getErrors();
       }
-
-      expect(error).to.be.an.instanceOf(InvalidDataContractError);
-      expect(error.getRawDataContract()).to.equal(rawDataContract);
-
-      expect(error.getErrors()).to.have.length(1);
-
-      const [consensusError] = error.getErrors();
-
-      expect(consensusError).to.equal(validationError);
-
-      expect(validateDataContractMock).to.have.been.calledOnceWith(rawDataContract);
     });
   });
 
   describe('createFromBuffer', () => {
     let serializedDataContract;
 
-    beforeEach(function beforeEach() {
-      this.sinonSandbox.stub(factory, 'createFromObject');
-
-      serializedDataContract = dataContract.toBuffer();
-    });
-
-    afterEach(() => {
-      factory.createFromObject.restore();
+    beforeEach(() => {
+      serializedDataContract = jsDataContract.toBuffer();
     });
 
     it('should return new Data Contract from serialized contract', async () => {
-      decodeProtocolEntityMock.returns([rawDataContract.protocolVersion, rawDataContract]);
-
-      factory.createFromObject.returns(dataContract);
-
       const result = await factory.createFromBuffer(serializedDataContract);
 
-      expect(result).to.equal(dataContract);
-
-      expect(factory.createFromObject).to.have.been.calledOnceWith(rawDataContract);
-
-      expect(decodeProtocolEntityMock).to.have.been.calledOnceWithExactly(
-        serializedDataContract,
-      );
+      expect(result.toObject()).to.deep.equal(jsDataContract.toObject());
     });
 
     it('should throw InvalidDataContractError if the decoding fails with consensus error', async () => {
-      const parsingError = new SerializedObjectParsingError(
-        serializedDataContract,
-        new Error(),
-      );
-
-      decodeProtocolEntityMock.throws(parsingError);
-
       try {
+        // Casually break serialized data contract:
+        serializedDataContract[5] += 1337;
         await factory.createFromBuffer(serializedDataContract);
-
         expect.fail('should throw InvalidDataContractError');
       } catch (e) {
-        expect(e).to.be.an.instanceOf(InvalidDataContractError);
-
-        const [innerError] = e.getErrors();
-        expect(innerError).to.equal(parsingError);
-      }
-    });
-
-    it('should throw an error if decoding fails with any other error', async () => {
-      const parsingError = new Error('Something failed during parsing');
-
-      decodeProtocolEntityMock.throws(parsingError);
-
-      try {
-        await factory.createFromBuffer(serializedDataContract);
-
-        expect.fail('should throw an error');
-      } catch (e) {
-        expect(e).to.equal(parsingError);
+        // TODO SerializedObjectParsingError binding type required
+        // expect(e).to.be.an.instanceOf(SerializedObjectPasingError);
+        expect(e).to.match(/Parsing of serialized object failed/);
       }
     });
   });
 
   describe('createDataContractCreateTransition', () => {
-    it('should return new DataContractCreateTransition with passed DataContract', () => {
-      const result = factory.createDataContractCreateTransition(dataContract);
+    it('should return new DataContractCreateTransition with passed DataContract', async () => {
+      // Create wasm version of DataContract
+      const dataContract = new DataContract(rawDataContract);
+      dataContract.setEntropy(jsDataContract.getEntropy());
 
-      expect(result).to.be.an.instanceOf(DataContractCreateTransition);
+      const result = await factory.createDataContractCreateTransition(dataContract);
 
       expect(result.getProtocolVersion()).to.equal(protocolVersion.latestVersion);
-      expect(result.getEntropy()).to.deep.equal(dataContract.getEntropy());
-      expect(result.getDataContract().toObject()).to.deep.equal(dataContract.toObject());
+      expect(result.getEntropy()).to.deep.equal(jsDataContract.getEntropy());
+      expect(result.getDataContract().toObject()).to.deep.equal(jsDataContract.toObject());
     });
   });
 });

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

@@ -1,15 +1,25 @@
-const DataContract = require('../../../lib/dataContract/DataContract');
+const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
 
-const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+const { default: loadWasmDpp } = require('../../../dist');
 
 describe('createDataContract', () => {
   let rawDataContract;
+  let DataContract;
+
+  before(async () => {
+    ({
+      DataContract,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(() => {
     rawDataContract = {
       $id: generateRandomIdentifier().toBuffer(),
       ownerId: generateRandomIdentifier().toBuffer(),
       contractId: generateRandomIdentifier().toBuffer(),
+      protocolVersion: 4,
+      version: 20,
+      $schema: 'http://test.com/schema',
       documents: {
         niceDocument: {
           name: { type: 'string' },
@@ -23,12 +33,12 @@ describe('createDataContract', () => {
 
     expect(dataContract).to.be.an.instanceOf(DataContract);
 
-    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
-    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+    expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.deep.equal(rawDataContract.documents);
   });
 
   it('should return new DataContract with "$schema" if present', () => {
-    rawDataContract.$schema = 'http://test.com/schema';
+    rawDataContract.$schema = 'http://test.com/otherschema';
 
     const dataContract = new DataContract(rawDataContract);
 
@@ -36,8 +46,8 @@ describe('createDataContract', () => {
 
     expect(dataContract.getJsonMetaSchema()).to.equal(rawDataContract.$schema);
 
-    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
-    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+    expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.deep.equal(rawDataContract.documents);
   });
 
   it('should return new DataContract with "$defs" if present', () => {
@@ -49,9 +59,9 @@ describe('createDataContract', () => {
 
     expect(dataContract).to.be.an.instanceOf(DataContract);
 
-    expect(dataContract.getDefinitions()).to.equal(rawDataContract.$defs);
+    expect(dataContract.getDefinitions()).to.deep.equal(rawDataContract.$defs);
 
-    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
-    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+    expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.deep.equal(rawDataContract.documents);
   });
 });

package/test/unit/dataContract/errors/InvalidDataContractError.spec.js

@@ -1,5 +1,5 @@
-const InvalidDataContractError = require('../../../../lib/dataContract/errors/InvalidDataContractError');
-const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+const InvalidDataContractError = require('@dashevo/dpp/lib/dataContract/errors/InvalidDataContractError');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
 describe('InvalidDataContractError', () => {
   let rawDataContract;

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

@@ -1,19 +1,36 @@
 const bs58 = require('bs58');
-const generateDataContractId = require('../../../lib/dataContract/generateDataContractId');
+
+const { default: loadWasmDpp } = require('../../../dist');
 
 describe('generateDataContractId', () => {
   let ownerId;
   let entropy;
+  let DataContractFactory;
+  let DataContractValidator;
+
+  before(async () => {
+    ({
+      DataContractFactory, DataContractValidator,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(() => {
-    ownerId = bs58.decode('23wdhodag');
-    entropy = bs58.decode('5dz916pTe1');
+    ownerId = bs58.decode('4Sr8EZ9BjQpMpBX5PLPxfvv5crTERSWBnRJXxUmCcrCQ');
+    entropy = bs58.decode('85NSrhBXYJAwzj8rDXuYhPQZPyg67diKSNcfhfnVhKnT');
   });
 
   it('should generate bs58 id based on ', () => {
-    const id = bs58.decode('CnS7cz4z1qoPsNfEgpgyVnKdtH2u7bgzZXHLcCQt24US');
-    const generatedId = generateDataContractId(ownerId, entropy);
+    const id = bs58.decode('8W4qubpTaFKEWHqr9vAFSNGFULnz2TbgbG4eUik7yWx2');
+
+    const entropyGenerator = {
+      generate() {
+        return entropy;
+      },
+    };
+
+    const factory = new DataContractFactory(1337, new DataContractValidator(), entropyGenerator);
+    const dataContract = factory.create(ownerId, {});
 
-    expect(Buffer.compare(id, generatedId)).to.equal(0);
+    expect(Buffer.compare(id, dataContract.getId().toBuffer())).to.equal(0);
   });
 });

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

@@ -1,5 +1,5 @@
 const { getBinaryPropertiesFromSchema } = require(
-  '../../../lib/dataContract/getBinaryPropertiesFromSchema',
+  '@dashevo/dpp/lib/dataContract/getBinaryPropertiesFromSchema',
 );
 
 describe('getBinaryPropertiesFromSchema', () => {

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

@@ -1,5 +1,5 @@
 const getPropertyDefinitionByPath = require(
-  '../../../lib/dataContract/getPropertyDefinitionByPath',
+  '@dashevo/dpp/lib/dataContract/getPropertyDefinitionByPath',
 );
 
 describe('getPropertyDefinitionByPath', () => {

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition.spec.js

@@ -1,11 +1,11 @@
-const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
-const stateTransitionTypes = require('../../../../../lib/stateTransition/stateTransitionTypes');
-
-const Identifier = require('../../../../../lib/identifier/Identifier');
-const protocolVersion = require('../../../../../lib/version/protocolVersion');
-const DataContractCreateTransition = require('../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-const hash = require('../../../../../lib/util/hash');
-const serializer = require('../../../../../lib/util/serializer');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
+
+const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const hash = require('@dashevo/dpp/lib/util/hash');
+const serializer = require('@dashevo/dpp/lib/util/serializer');
 
 describe('DataContractCreateTransition', () => {
   let stateTransition;

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/applyDataContractCreateTransitionFactory.spec.js

@@ -1,15 +1,15 @@
 const DataContractCreateTransition = require(
-  '../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition',
+  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition',
 );
 
-const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
 const applyDataContractCreateTransitionFactory = require(
-  '../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/applyDataContractCreateTransitionFactory',
+  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/applyDataContractCreateTransitionFactory',
 );
 
-const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
-const StateTransitionExecutionContext = require('../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
 
 describe('applyDataContractCreateTransitionFactory', () => {
   let stateTransition;
@@ -40,7 +40,7 @@ describe('applyDataContractCreateTransitionFactory', () => {
   it('should store a data contract from state transition in the repository', async () => {
     await applyDataContractCreateTransition(stateTransition);
 
-    expect(stateRepositoryMock.storeDataContract).to.have.been.calledOnceWithExactly(
+    expect(stateRepositoryMock.createDataContract).to.have.been.calledOnceWithExactly(
       stateTransition.getDataContract(),
       executionContext,
     );

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory.spec.js

@@ -1,15 +1,15 @@
-const validateDataContractCreateTransitionStateFactory = require('../../../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory');
-const DataContractCreateTransition = require('../../../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const validateDataContractCreateTransitionStateFactory = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory');
+const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
 
-const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
-const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
 
-const ValidationResult = require('../../../../../../../lib/validation/ValidationResult');
+const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
 
-const DataContractAlreadyPresentError = require('../../../../../../../lib/errors/consensus/state/dataContract/DataContractAlreadyPresentError');
-const StateTransitionExecutionContext = require('../../../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const DataContractAlreadyPresentError = require('@dashevo/dpp/lib/errors/consensus/state/dataContract/DataContractAlreadyPresentError');
+const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
 
 describe('validateDataContractCreateTransitionStateFactory', () => {
   let validateDataContractCreateTransitionState;

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition.spec.js

@@ -1,11 +1,11 @@
-const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
-const stateTransitionTypes = require('../../../../../lib/stateTransition/stateTransitionTypes');
-
-const Identifier = require('../../../../../lib/identifier/Identifier');
-const protocolVersion = require('../../../../../lib/version/protocolVersion');
-const DataContractUpdateTransition = require('../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
-const hash = require('../../../../../lib/util/hash');
-const serializer = require('../../../../../lib/util/serializer');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
+
+const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const DataContractUpdateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
+const hash = require('@dashevo/dpp/lib/util/hash');
+const serializer = require('@dashevo/dpp/lib/util/serializer');
 
 describe('DataContractUpdateTransition', () => {
   let stateTransition;

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/applyDataContractUpdateTransitionFactory.spec.js

@@ -1,15 +1,15 @@
 const DataContractUpdateTransition = require(
-  '../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition',
+  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition',
 );
 
-const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
 const applyDataContractUpdateTransitionFactory = require(
-  '../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/applyDataContractUpdateTransitionFactory',
+  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/applyDataContractUpdateTransitionFactory',
 );
 
-const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
-const StateTransitionExecutionContext = require('../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
 
 describe('applyDataContractUpdateTransitionFactory', () => {
   let stateTransition;
@@ -39,7 +39,7 @@ describe('applyDataContractUpdateTransitionFactory', () => {
   it('should store a data contract from state transition in the repository', async () => {
     await applyDataContractUpdateTransition(stateTransition);
 
-    expect(stateRepositoryMock.storeDataContract).to.have.been.calledOnceWithExactly(
+    expect(stateRepositoryMock.updateDataContract).to.have.been.calledOnceWithExactly(
       stateTransition.getDataContract(),
       executionContext,
     );

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateIndicesAreBackwardCompatible.spec.js

@@ -1,9 +1,9 @@
-const validateIndicesAreBackwardCompatible = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateIndicesAreBackwardCompatible');
-const DataContractHaveNewIndexWithOldPropertiesError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
-const DataContractHaveNewUniqueIndexError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractHaveNewUniqueIndexError');
-const DataContractIndicesChangedError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractUniqueIndicesChangedError');
-const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
-const DataContractInvalidIndexDefinitionUpdateError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
+const validateIndicesAreBackwardCompatible = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateIndicesAreBackwardCompatible');
+const DataContractHaveNewIndexWithOldPropertiesError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
+const DataContractHaveNewUniqueIndexError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractHaveNewUniqueIndexError');
+const DataContractIndicesChangedError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractUniqueIndicesChangedError');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const DataContractInvalidIndexDefinitionUpdateError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
 
 describe('validateIndicesAreBackwardCompatible', () => {
   let oldDocumentsSchema;

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/validation/state/validateDataContractUpdateTransitionStateFactory.spec.js

@@ -1,16 +1,16 @@
-const validateDataContractUpdateTransitionStateFactory = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/validation/state/validateDataContractUpdateTransitionStateFactory');
-const DataContractUpdateTransition = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
+const validateDataContractUpdateTransitionStateFactory = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/validation/state/validateDataContractUpdateTransitionStateFactory');
+const DataContractUpdateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
 
-const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
-const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
 
-const ValidationResult = require('../../../../../../../lib/validation/ValidationResult');
+const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
 
-const DataContractNotPresentError = require('../../../../../../../lib/errors/consensus/basic/document/DataContractNotPresentError');
-const InvalidDataContractVersionError = require('../../../../../../../lib/errors/consensus/basic/dataContract/InvalidDataContractVersionError');
-const StateTransitionExecutionContext = require('../../../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const DataContractNotPresentError = require('@dashevo/dpp/lib/errors/consensus/basic/document/DataContractNotPresentError');
+const InvalidDataContractVersionError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/InvalidDataContractVersionError');
+const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
 
 describe('validateDataContractUpdateTransitionStateFactory', () => {
   let validateDataContractUpdateTransitionState;

package/test/unit/dataContract/validation/validateDataContractMaxDepthFactory.spec.js

@@ -1,9 +1,9 @@
-const validateDataContractMaxDepthFactory = require('../../../../lib/dataContract/validation/validateDataContractMaxDepthFactory');
-const ValidationResult = require('../../../../lib/validation/ValidationResult');
-const { expectValidationError } = require('../../../../lib/test/expect/expectError');
-const DataContractMaxDepthExceedError = require('../../../../lib/errors/consensus/basic/dataContract/DataContractMaxDepthExceedError');
-const generateDeepJson = require('../../../../lib/test/utils/generateDeepJson');
-const InvalidJsonSchemaRefError = require('../../../../lib/errors/consensus/basic/dataContract/InvalidJsonSchemaRefError');
+const validateDataContractMaxDepthFactory = require('@dashevo/dpp/lib/dataContract/validation/validateDataContractMaxDepthFactory');
+const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
+const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
+const DataContractMaxDepthExceedError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractMaxDepthExceedError');
+const generateDeepJson = require('@dashevo/dpp/lib/test/utils/generateDeepJson');
+const InvalidJsonSchemaRefError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/InvalidJsonSchemaRefError');
 
 describe('validateDataContractMaxDepthFactory', () => {
   let refParserMock;

package/test/unit/dataContract/validation/validateDataContractPatternsFactory.spec.js

@@ -1,10 +1,10 @@
 const { getRE2Class } = require('@dashevo/wasm-re2');
 
-const validateDataContractPatternsFactory = require('../../../../lib/dataContract/validation/validateDataContractPatternsFactory');
+const validateDataContractPatternsFactory = require('@dashevo/dpp/lib/dataContract/validation/validateDataContractPatternsFactory');
 const { expectValidationError } = require(
-  '../../../../lib/test/expect/expectError',
+  '@dashevo/dpp/lib/test/expect/expectError',
 );
-const IncompatibleRe2PatternError = require('../../../../lib/errors/consensus/basic/dataContract/IncompatibleRe2PatternError');
+const IncompatibleRe2PatternError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/IncompatibleRe2PatternError');
 
 describe('validateDataContractPatternsFactory', () => {
   let validateDataContractPatterns;

package/test/unit/dataTrigger/DataTrigger.spec.js

@@ -1,12 +1,12 @@
 const bs58 = require('bs58');
-const AbstractDocumentTransition = require('../../../lib/document/stateTransition/DocumentsBatchTransition/documentTransition/AbstractDocumentTransition');
-const DataTrigger = require('../../../lib/dataTrigger/DataTrigger');
-const DataTriggerExecutionContext = require('../../../lib/dataTrigger/DataTriggerExecutionContext');
-const getDpnsContractFixture = require('../../../lib/test/fixtures/getDpnsContractFixture');
-const DataTriggerExecutionResult = require('../../../lib/dataTrigger/DataTriggerExecutionResult');
-const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
-const DataTriggerExecutionError = require('../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerExecutionError');
-const DataTriggerInvalidResultError = require('../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerInvalidResultError');
+const AbstractDocumentTransition = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/documentTransition/AbstractDocumentTransition');
+const DataTrigger = require('@dashevo/dpp/lib/dataTrigger/DataTrigger');
+const DataTriggerExecutionContext = require('@dashevo/dpp/lib/dataTrigger/DataTriggerExecutionContext');
+const getDpnsContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDpnsContractFixture');
+const DataTriggerExecutionResult = require('@dashevo/dpp/lib/dataTrigger/DataTriggerExecutionResult');
+const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
+const DataTriggerExecutionError = require('@dashevo/dpp/lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerExecutionError');
+const DataTriggerInvalidResultError = require('@dashevo/dpp/lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerInvalidResultError');
 
 describe('DataTrigger', () => {
   let dataContractMock;

package/test/unit/dataTrigger/DataTriggerExecutionContext.spec.js

@@ -1,8 +1,8 @@
 const bs58 = require('bs58');
-const DataTriggerExecutionContext = require('../../../lib/dataTrigger/DataTriggerExecutionContext');
-const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
-const getDpnsContractFixture = require('../../../lib/test/fixtures/getDpnsContractFixture');
-const StateTransitionExecutionContext = require('../../../lib/stateTransition/StateTransitionExecutionContext');
+const DataTriggerExecutionContext = require('@dashevo/dpp/lib/dataTrigger/DataTriggerExecutionContext');
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const getDpnsContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDpnsContractFixture');
+const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
 
 describe('DataTriggerExecutionContext', () => {
   let dataContractMock;