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

package/test/integration/identity/stateTransition/IdentityTopUpTransition/validation/basic/validateIdentityTopUpTransitionBasicFactory.spec.js

@@ -1,5 +1,5 @@
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const getIdentityTopUpTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixtureJs');
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
+const getIdentityTopUpTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
 
 const {
   expectJsonSchemaError,
@@ -7,7 +7,7 @@ const {
 } = require('../../../../../../../lib/test/expect/expectError');
 const { default: loadWasmDpp } = require('../../../../../../../dist');
 
-describe('validateIdentityTopUpTransitionBasicFactory', () => {
+describe.skip('validateIdentityTopUpTransitionBasicFactory', () => {
   let rawStateTransition;
   let stateTransition;
 
@@ -17,7 +17,6 @@ describe('validateIdentityTopUpTransitionBasicFactory', () => {
   let validateIdentityTopUpTransitionBasic;
 
   let StateTransitionExecutionContext;
-  let IdentityTopUpTransition;
   let IdentityPublicKey;
   let UnsupportedProtocolVersionError;
   let InvalidInstantAssetLockProofSignatureError;
@@ -26,7 +25,6 @@ describe('validateIdentityTopUpTransitionBasicFactory', () => {
   before(async () => {
     ({
       IdentityTopUpTransitionBasicValidator,
-      IdentityTopUpTransition,
       StateTransitionExecutionContext,
       IdentityPublicKey,
       UnsupportedProtocolVersionError,
@@ -47,8 +45,7 @@ describe('validateIdentityTopUpTransitionBasicFactory', () => {
       context,
     );
 
-    const stateTransitionJS = getIdentityTopUpTransitionFixture();
-    stateTransition = new IdentityTopUpTransition(stateTransitionJS.toObject());
+    stateTransition = await getIdentityTopUpTransitionFixture();
 
     const privateKey = '9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2';
 

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/basic/validateIdentityUpdateTransitionBasicFactory.spec.js

@@ -5,7 +5,7 @@ const { expectJsonSchemaError, expectValidationError } = require('../../../../..
 const { default: loadWasmDpp } = require('../../../../../../../dist');
 const getBlsAdapterMock = require('../../../../../../../lib/test/mocks/getBlsAdapterMock');
 
-describe('validateIdentityUpdateTransitionBasicFactory', () => {
+describe.skip('validateIdentityUpdateTransitionBasicFactory', () => {
   let validateIdentityUpdateTransitionBasic;
   let rawStateTransition;
   let stateTransition;

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validateIdentityUpdateTransitionStateFactory.spec.js

@@ -1,22 +1,19 @@
-const identitySchema = require('@dashevo/dpp/schema/identity/identity.json');
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
+const identitySchema = require('../../../../../../../../rs-dpp/src/schema/identity/v0/identity.json');
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
+const getIdentityFixture = require('../../../../../../../lib/test/fixtures/getIdentityFixture');
 const getIdentityUpdateTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityUpdateTransitionFixture');
 
-const { default: loadWasmDpp } = require('../../../../../../../dist');
+const { default: loadWasmDpp } = require('../../../../../../..');
 const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
 const generateRandomIdentifierAsync = require('../../../../../../../lib/test/utils/generateRandomIdentifierAsync');
 const getBlsAdapterMock = require('../../../../../../../lib/test/mocks/getBlsAdapterMock');
 
-describe('validateIdentityUpdateTransitionStateFactory', () => {
+describe.skip('validateIdentityUpdateTransitionStateFactory', () => {
   let validateIdentityUpdateTransitionState;
   let stateRepositoryMock;
   let stateTransition;
   let identity;
   let rawIdentity;
-  let validatePublicKeysMock;
   let blockTime;
   let executionContext;
 
@@ -49,7 +46,7 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
   });
 
   beforeEach(async function beforeEach() {
-    rawIdentity = getIdentityFixture().toObject();
+    rawIdentity = (await getIdentityFixture()).toObject();
     // Patch identity id to be acceptable by wasm-dpp
     rawIdentity.id = await generateRandomIdentifierAsync();
     identity = new Identity(rawIdentity);
@@ -248,21 +245,21 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
   // TODO: remove?
   // Skipped, because two tests above are seem to be enough
   it.skip('should validate resulting identity public keys', async () => {
-    const publicKeysError = new SomeConsensusError('test');
-
-    validatePublicKeysMock.returns(new ValidationResult([publicKeysError]));
-
-    const result = await validateIdentityUpdateTransitionState(stateTransition);
-
-    expectValidationError(result, SomeConsensusError);
-
-    expect(validatePublicKeysMock).to.be.calledOnce();
-
-    const publicKeys = [...identity.getPublicKeys(), ...stateTransition.getPublicKeysToAdd()];
-
-    expect(validatePublicKeysMock).to.be.calledWithExactly(
-      publicKeys.map((pk) => pk.toObject()),
-    );
+    // const publicKeysError = new SomeConsensusError('test');
+    //
+    // validatePublicKeysMock.returns(new ValidationResult([publicKeysError]));
+    //
+    // const result = await validateIdentityUpdateTransitionState(stateTransition);
+    //
+    // expectValidationError(result, SomeConsensusError);
+    //
+    // expect(validatePublicKeysMock).to.be.calledOnce();
+    //
+    // const publicKeys = [...identity.getPublicKeys(), ...stateTransition.getPublicKeysToAdd()];
+    //
+    // expect(validatePublicKeysMock).to.be.calledWithExactly(
+    //   publicKeys.map((pk) => pk.toObject()),
+    // );
   });
 
   it('should return valid result on dry run', async function () {

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validatePublicKeysState.spec.js

@@ -1,9 +1,9 @@
-const identitySchema = require('@dashevo/dpp/schema/identity/identity.json');
+const identitySchema = require('../../../../../../../../rs-dpp/src/schema/identity/v0/identity.json');
 const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
 
 const { default: loadWasmDpp } = require('../../../../../../../dist');
 
-describe('validatePublicKeysState', () => {
+describe.skip('validatePublicKeysState', () => {
   let IdentityUpdatePublicKeysValidator;
   let DuplicatedIdentityPublicKeyIdStateError;
   let DuplicatedIdentityPublicKeyStateError;

package/test/integration/identity/stateTransition/assetLockProof/chain/validateChainAssetLockProofStructureFactory.spec.js

@@ -1,14 +1,14 @@
 const { Transaction, Script, PrivateKey } = require('@dashevo/dashcore-lib');
 
-const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
 const { expect } = require('chai');
+const getChainAssetLockFixture = require('../../../../../../lib/test/fixtures/getChainAssetLockProofFixture');
+const createStateRepositoryMock = require('../../../../../../lib/test/mocks/createStateRepositoryMock');
+
 const { expectJsonSchemaError, expectValidationError } = require('../../../../../../lib/test/expect/expectError');
 
 const { default: loadWasmDpp } = require('../../../../../../dist');
 
-describe('validateChainAssetLockProofStructureFactory', () => {
+describe.skip('validateChainAssetLockProofStructureFactory', () => {
   let rawProof;
   let stateRepositoryMock;
   let publicKeyHash;

package/test/integration/identity/stateTransition/assetLockProof/fetchAssetLockTransactionOutputFactory.spec.js

@@ -1,17 +1,16 @@
 const { Transaction } = require('@dashevo/dashcore-lib');
 
-const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
-const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const getChainAssetLockFixture = require('../../../../../lib/test/fixtures/getChainAssetLockProofFixture');
+const getInstantAssetLockProofFixture = require('../../../../../lib/test/fixtures/getInstantAssetLockProofFixture');
+const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
 const { default: loadWasmDpp } = require('../../../../../dist');
 
-describe('fetchAssetLockTransactionOutputFactory', () => {
+describe.skip('fetchAssetLockTransactionOutputFactory', () => {
   let fetchAssetLockTransactionOutput;
   let stateRepositoryMock;
   let executionContext;
 
   let StateTransitionExecutionContext;
-  let InstantAssetLockProof;
   let ChainAssetLockProof;
   let AssetLockTransactionIsNotFoundError;
   let UnknownAssetLockProofTypeError;
@@ -22,7 +21,6 @@ describe('fetchAssetLockTransactionOutputFactory', () => {
     ({
       StateTransitionExecutionContext,
       fetchAssetLockTransactionOutput: fetchAssetLockTransactionOutputDPP,
-      InstantAssetLockProof,
       ChainAssetLockProof,
       AssetLockTransactionIsNotFoundError,
       UnknownAssetLockProofTypeError,
@@ -44,9 +42,8 @@ describe('fetchAssetLockTransactionOutputFactory', () => {
   describe('InstantAssetLockProof', () => {
     let assetLockProofFixture;
 
-    beforeEach(() => {
-      const assetLockProofFixtureJS = getInstantAssetLockProofFixture();
-      assetLockProofFixture = new InstantAssetLockProof(assetLockProofFixtureJS.toObject());
+    beforeEach(async () => {
+      assetLockProofFixture = await getInstantAssetLockProofFixture();
     });
 
     it('should return asset lock output', async () => {
@@ -122,7 +119,7 @@ describe('fetchAssetLockTransactionOutputFactory', () => {
       }
     });
 
-    it('should return mocked output on dry run', async function () {
+    it('should return mocked output on dry run', async function shouldReturn() {
       executionContext.enableDryRun();
 
       const result = await fetchAssetLockTransactionOutput(

package/test/integration/identity/stateTransition/assetLockProof/instant/validateInstantAssetLockProofStructureFactory.spec.js

@@ -1,14 +1,13 @@
 const DashCoreLib = require('@dashevo/dashcore-lib');
-
-const getInstantAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
 const { expect } = require('chai');
+
+const getInstantAssetLockFixture = require('../../../../../../lib/test/fixtures/js/getInstantAssetLockProofFixture');
+const createStateRepositoryMock = require('../../../../../../lib/test/mocks/createStateRepositoryMock');
 const { expectJsonSchemaError, expectValidationError } = require('../../../../../../lib/test/expect/expectError');
 
 const { default: loadWasmDpp } = require('../../../../../../dist');
 
-describe('validateInstantAssetLockProofStructureFactory', () => {
+describe.skip('validateInstantAssetLockProofStructureFactory', () => {
   let rawProof;
   let transaction;
   let stateRepositoryMock;

package/test/integration/identity/stateTransition/assetLockProof/validateAssetLockTransactionFactory.spec.js

@@ -1,12 +1,11 @@
 const { Transaction, PrivateKey, Script } = require('@dashevo/dashcore-lib');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
 const { expect } = require('chai');
+
+const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
 const { default: loadWasmDpp } = require('../../../../../dist');
 const { expectValidationError } = require('../../../../../lib/test/expect/expectError');
 
-describe('validateAssetLockTransactionFactory', () => {
+describe.skip('validateAssetLockTransactionFactory', () => {
   let stateRepositoryMock;
   let rawTransaction;
   let outputIndex;
@@ -133,7 +132,8 @@ describe('validateAssetLockTransactionFactory', () => {
     expect(error.getOutputIndex()).to.equal(outputIndex);
   });
 
-  it('should return IdentityAssetLockTransactionOutPointAlreadyExistsError if outPoint was already used', async function () {
+  it('should return IdentityAssetLockTransactionOutPointAlreadyExistsError if outPoint was'
+    + ' already used', async function shouldReturn() {
     stateRepositoryMock.isAssetLockTransactionOutPointAlreadyUsed.resolves(true);
 
     const result = await validateAssetLockTransaction(
@@ -162,7 +162,7 @@ describe('validateAssetLockTransactionFactory', () => {
       );
   });
 
-  it('should return valid result', async function () {
+  it('should return valid result', async function shouldReturn() {
     const result = await validateAssetLockTransaction(
       rawTransaction,
       outputIndex,

package/test/integration/identity/stateTransition/validatePublicKeySignaturesFactory.spec.js

@@ -2,21 +2,20 @@ const { PrivateKey, crypto: { Hash } } = require('@dashevo/dashcore-lib');
 
 const crypto = require('crypto');
 
-const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
 const BlsSignatures = require('@dashevo/dpp/lib/bls/bls');
 
 const { expect } = require('chai');
+const getIdentityCreateTransitionFixture = require('../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
 const { expectValidationError } = require('../../../../lib/test/expect/expectError');
 const getBlsAdapterMock = require('../../../../lib/test/mocks/getBlsAdapterMock');
 
 const { default: loadWasmDpp } = require('../../../../dist');
 
-describe('validatePublicKeySignaturesFactory', () => {
+describe.skip('validatePublicKeySignaturesFactory', () => {
   let identityCreateTransition;
   let rawIdentityCreateTransition;
   let validatePublicKeySignatures;
 
-  let IdentityCreateTransition;
   let IdentityPublicKey;
   let IdentityPublicKeyWithWitness;
   let InvalidIdentityKeySignatureError;
@@ -26,7 +25,6 @@ describe('validatePublicKeySignaturesFactory', () => {
 
   before(async () => {
     ({
-      IdentityCreateTransition,
       IdentityPublicKey,
       IdentityPublicKeyWithWitness,
       InvalidIdentityKeySignatureError,
@@ -36,9 +34,7 @@ describe('validatePublicKeySignaturesFactory', () => {
   });
 
   beforeEach(async () => {
-    identityCreateTransition = new IdentityCreateTransition(
-      getIdentityCreateTransitionFixture().toObject(),
-    );
+    identityCreateTransition = await getIdentityCreateTransitionFixture();
 
     const privateKey1 = new PrivateKey('17e0b1703e226204c557bce68b0871683ea409ae90c7a733b72a33f7c129c959');
     const publicKey1 = privateKey1.toPublicKey();

package/test/integration/identity/validation/validateIdentityFactory.spec.js

@@ -1,11 +1,11 @@
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
+const getIdentityFixture = require('../../../../lib/test/fixtures/getIdentityFixture');
 const { expectValidationError, expectJsonSchemaError } = require('../../../../lib/test/expect/expectError');
 
 const { default: loadWasmDpp } = require('../../../../dist');
 const getBlsAdapterMock = require('../../../../lib/test/mocks/getBlsAdapterMock');
 const generateRandomIdentifierAsync = require('../../../../lib/test/utils/generateRandomIdentifierAsync');
 
-describe('validateIdentityFactory', () => {
+describe.skip('validateIdentityFactory', () => {
   let rawIdentity;
   let validateIdentity;
   let identity;
@@ -18,16 +18,17 @@ describe('validateIdentityFactory', () => {
     ({ IdentityValidator, Identity, UnsupportedProtocolVersionError } = await loadWasmDpp());
   });
 
-  beforeEach(async () => {
+  beforeEach(async function beforeEach() {
+    this.timeout(20000);
     const blsAdapter = await getBlsAdapterMock();
 
     const validator = new IdentityValidator(blsAdapter);
 
     validateIdentity = (value) => validator.validate(value);
 
-    const identityObjectJS = getIdentityFixture().toObject();
-    identityObjectJS.id = await generateRandomIdentifierAsync();
-    identity = new Identity(identityObjectJS);
+    const identityObject = (await getIdentityFixture()).toObject();
+    identityObject.id = await generateRandomIdentifierAsync();
+    identity = new Identity(identityObject);
 
     rawIdentity = identity.toObject();
   });

package/test/integration/identity/validation/validatePublicKeysFactory.spec.js

@@ -1,8 +1,7 @@
 const crypto = require('crypto');
 
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
-
-const BlsSignatures = require('@dashevo/dpp/lib/bls/bls');
+const getIdentityFixture = require('../../../../lib/test/fixtures/getIdentityFixture');
+const getBlsMock = require('../../../../lib/test/mocks/getBlsAdapterMock');
 
 const {
   expectValidationError,
@@ -11,12 +10,11 @@ const {
 
 const { default: loadWasmDpp } = require('../../../../dist');
 
-describe('validatePublicKeysFactory', function main() {
+describe.skip('validatePublicKeysFactory', function main() {
   this.timeout(10000);
 
   let rawPublicKeys;
   let validatePublicKeys;
-  let bls;
   let publicKeysValidator;
 
   let PublicKeysValidator;
@@ -28,7 +26,7 @@ describe('validatePublicKeysFactory', function main() {
   let InvalidIdentityPublicKeySecurityLevelError;
 
   beforeEach(async () => {
-    ({ publicKeys: rawPublicKeys } = getIdentityFixture().toObject());
+    ({ publicKeys: rawPublicKeys } = (await getIdentityFixture()).toObject());
 
     ({
       PublicKeysValidator, IdentityPublicKey,
@@ -37,25 +35,7 @@ describe('validatePublicKeysFactory', function main() {
       InvalidIdentityPublicKeyDataError, InvalidIdentityPublicKeySecurityLevelError,
     } = await loadWasmDpp());
 
-    bls = await BlsSignatures.getInstance();
-
-    const blsAdapter = {
-      validatePublicKey(publicKeyBuffer) {
-        let pk;
-
-        try {
-          pk = bls.G1Element.fromBytes(publicKeyBuffer);
-        } catch (e) {
-          return false;
-        } finally {
-          if (pk) {
-            pk.delete();
-          }
-        }
-
-        return Boolean(pk);
-      },
-    };
+    const blsAdapter = await getBlsMock();
 
     publicKeysValidator = new PublicKeysValidator(blsAdapter);
 

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

@@ -1,16 +1,12 @@
 const { PrivateKey } = require('@dashevo/dashcore-lib');
 const crypto = require('crypto');
 
-const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
+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', () => {
@@ -25,63 +21,60 @@ 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 IdentityCreateTransition;
+  // 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,
-      IdentityCreateTransition,
+      // DocumentValidator,
+      // ProtocolVersionValidator,
       UnsupportedProtocolVersionError,
       InvalidStateTransitionSignatureError,
       DataContractAlreadyPresentError,
       BalanceIsNotEnoughError,
-      StateTransitionExecutionContext,
     } = await loadWasmDpp());
   });
 
   beforeEach(async function beforeEach() {
+    this.timeout(20000);
     const privateKeyModel = new PrivateKey();
     const privateKey = privateKeyModel.toBuffer();
     const publicKey = privateKeyModel.toPublicKey().toBuffer();
     const publicKeyId = 1;
 
-    executionContext = new StateTransitionExecutionContext();
+    // executionContext = new StateTransitionExecutionContext();
 
-    identityPublicKey = new IdentityPublicKey({
-      id: publicKeyId,
-      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-      data: publicKey,
-      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-      securityLevel: IdentityPublicKey.SECURITY_LEVELS.HIGH,
-      readOnly: false,
-    });
+    identityPublicKey = new IdentityPublicKey(1);
+
+    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,39 +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 identityObjectJS = getIdentityFixture().toObject();
-    identityObjectJS.id = await generateRandomIdentifierAsync();
-    identityObjectJS.balance = 10000000;
-    identity = new Identity(identityObjectJS);
+    identity = await getIdentityFixture();
+    identity.setId(await generateRandomIdentifierAsync());
+    identity.setBalance(10000000);
     identity.setPublicKeys([identityPublicKey]);
 
-    const blockTime = Date.now();
-
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    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(
@@ -137,7 +127,7 @@ describe('StateTransitionFacade', () => {
   });
 
   describe('createFromBuffer', () => {
-    it('should create State Transition from string', async () => {
+    it('should create Data Contract State Transition from buffer', async () => {
       const result = await dpp.stateTransition.createFromBuffer(
         dataContractCreateTransition.toBuffer(),
       );
@@ -148,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;
@@ -228,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,
@@ -239,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,
@@ -254,10 +244,7 @@ describe('StateTransitionFacade', () => {
         'af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837',
       );
 
-      const identityCreateTransitionJS = getIdentityCreateTransitionFixture(oneTimePrivateKey);
-      const identityCreateTransition = new IdentityCreateTransition(
-        identityCreateTransitionJS.toObject(),
-      );
+      const identityCreateTransition = await getIdentityCreateTransitionFixture(oneTimePrivateKey);
 
       await identityCreateTransition.signByPrivateKey(
         oneTimePrivateKey.toBuffer(),
@@ -273,7 +260,7 @@ describe('StateTransitionFacade', () => {
     });
   });
 
-  describe('validateFee', () => {
+  describe.skip('validateFee', () => {
     it('should validate State Transition', async () => {
       const result = await dpp.stateTransition.validateFee(
         dataContractCreateTransition,
@@ -285,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());
   });