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

package/test/unit/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition.spec.js

@@ -1,48 +1,25 @@
 const getIdentityCreateTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
-const getChainAssetLockProofFixture = require('../../../../../lib/test/fixtures/getChainAssetLockProofFixture');
 
-const { default: loadWasmDpp } = require('../../../../..');
-const { getLatestProtocolVersion, StateTransitionTypes } = require('../../../../..');
+const {
+  IdentityPublicKeyWithWitness,
+  InstantAssetLockProof, Identifier,
+  StateTransitionTypes,
+} = require('../../../../..');
 
 describe('IdentityCreateTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
-  let IdentityCreateTransition;
-  let InstantAssetLockProof;
-  let KeyType;
-  let KeyPurpose;
-  let KeySecurityLevel;
-  let Identifier;
-  let IdentityPublicKeyWithWitness;
-
-  const mockRawPublicKey = (params = {}) => ({
-    id: 0,
-    type: KeyType.ECDSA_SECP256K1,
-    data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
-    purpose: KeyPurpose.AUTHENTICATION,
-    securityLevel: KeySecurityLevel.MASTER,
-    signature: Buffer.alloc(32).fill(1),
-    readOnly: false,
-    ...params,
-  });
-
-  before(async () => {
-    ({
-      IdentityCreateTransition,
-      IdentityPublicKeyWithWitness,
-      KeyType,
-      KeyPurpose,
-      KeySecurityLevel,
-      InstantAssetLockProof, Identifier,
-    } = await loadWasmDpp());
-  });
+  const mockPublicKey = (id) => {
+    const key = new IdentityPublicKeyWithWitness(1);
+    key.setData(Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'));
+    key.setId(id);
+    return key;
+  };
 
   beforeEach(async () => {
-    rawStateTransition = (await getIdentityCreateTransitionFixture()).toObject();
-    stateTransition = new IdentityCreateTransition(
-      rawStateTransition,
-    );
+    stateTransition = await getIdentityCreateTransitionFixture();
+    rawStateTransition = stateTransition.toObject();
   });
 
   describe('#constructor', () => {
@@ -52,17 +29,9 @@ describe('IdentityCreateTransition', () => {
       );
 
       expect(stateTransition.publicKeys.map((key) => key.toObject())).to.deep.equal([
-        new IdentityPublicKeyWithWitness(rawStateTransition.publicKeys[0]).toObject(),
+        rawStateTransition.publicKeys[0],
       ]);
     });
-
-    it('should create instance with chain asset lock proof', () => {
-      const stObject = stateTransition.toObject();
-      stObject.assetLockProof = getChainAssetLockProofFixture().toObject();
-      stateTransition = new IdentityCreateTransition(stObject);
-      expect(stateTransition.getAssetLockProof().toObject())
-        .to.deep.equal(stObject.assetLockProof);
-    });
   });
 
   describe('#getType', () => {
@@ -103,8 +72,8 @@ describe('IdentityCreateTransition', () => {
   describe('#setPublicKeys', () => {
     it('should set public keys', () => {
       const publicKeys = [
-        new IdentityPublicKeyWithWitness(mockRawPublicKey({ id: 0 })),
-        new IdentityPublicKeyWithWitness(mockRawPublicKey({ id: 1 })),
+        mockPublicKey({ id: 0 }),
+        mockPublicKey({ id: 1 }),
       ];
 
       stateTransition.setPublicKeys(publicKeys);
@@ -117,8 +86,7 @@ describe('IdentityCreateTransition', () => {
   describe('#getPublicKeys', () => {
     it('should return set public keys', () => {
       expect(stateTransition.getPublicKeys().map((key) => key.toObject())).to.deep.equal(
-        rawStateTransition.publicKeys
-          .map((rawPublicKey) => new IdentityPublicKeyWithWitness(rawPublicKey).toObject()),
+        rawStateTransition.publicKeys,
       );
     });
   });
@@ -126,8 +94,8 @@ describe('IdentityCreateTransition', () => {
   describe('#addPublicKeys', () => {
     it('should add more public keys', () => {
       const publicKeys = [
-        new IdentityPublicKeyWithWitness(mockRawPublicKey({ id: 0 })),
-        new IdentityPublicKeyWithWitness(mockRawPublicKey({ id: 1 })),
+        mockPublicKey({ id: 0 }),
+        mockPublicKey({ id: 1 }),
       ];
 
       stateTransition.setPublicKeys([]);
@@ -158,7 +126,7 @@ describe('IdentityCreateTransition', () => {
       rawStateTransition = stateTransition.toObject();
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityCreate,
         assetLockProof: rawStateTransition.assetLockProof,
         publicKeys: rawStateTransition.publicKeys,
@@ -170,7 +138,7 @@ describe('IdentityCreateTransition', () => {
       rawStateTransition = stateTransition.toObject({ skipSignature: true });
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityCreate,
         assetLockProof: rawStateTransition.assetLockProof,
         publicKeys: rawStateTransition.publicKeys,
@@ -183,7 +151,7 @@ describe('IdentityCreateTransition', () => {
       const jsonStateTransition = stateTransition.toJSON();
 
       expect(jsonStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityCreate,
         assetLockProof: stateTransition.getAssetLockProof().toJSON(),
         publicKeys: stateTransition.getPublicKeys().map((k) => k.toJSON()),
@@ -201,7 +169,7 @@ describe('IdentityCreateTransition', () => {
 
       expect(identityId).to.be.an.instanceOf(Identifier);
       expect(identityId.toBuffer()).to.be.deep.equal(
-        new IdentityCreateTransition(rawStateTransition).getIdentityId().toBuffer(),
+        stateTransition.getAssetLockProof().createIdentifier(),
       );
     });
   });

package/test/unit/identity/stateTransition/IdentityCreateTransition/applyIdentityCreateTransitionFactory.spec.js

@@ -6,7 +6,7 @@ const createStateRepositoryMock = require('../../../../../lib/test/mocks/createS
 const { default: loadWasmDpp } = require('../../../../..');
 const { getLatestProtocolVersion } = require('../../../../..');
 
-describe('applyIdentityCreateTransitionFactory', () => {
+describe.skip('applyIdentityCreateTransitionFactory', () => {
   let stateTransition;
   let applyIdentityCreateTransition;
   let stateRepositoryMock;
@@ -45,7 +45,7 @@ describe('applyIdentityCreateTransitionFactory', () => {
     );
   });
 
-  it('should store identity created from state transition', async function () {
+  it('should store identity created from state transition', async function beforeEach() {
     await applyIdentityCreateTransition(stateTransition);
 
     const balance = convertSatoshiToCredits(

package/test/unit/identity/stateTransition/IdentityCreateTransition/validation/state/validateIdentityCreateTransitionStateFactory.spec.js

@@ -5,7 +5,7 @@ const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/c
 const { default: loadWasmDpp } = require('../../../../../../../dist');
 const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
 
-describe('validateIdentityCreateTransitionStateFactory', () => {
+describe.skip('validateIdentityCreateTransitionStateFactory', () => {
   let validateIdentityCreateTransitionState;
   let stateTransition;
   let stateRepositoryMock;
@@ -25,7 +25,7 @@ describe('validateIdentityCreateTransitionStateFactory', () => {
     } = await loadWasmDpp());
   });
 
-  beforeEach(async function () {
+  beforeEach(async function beforeEach() {
     executionContext = new StateTransitionExecutionContext();
     const privateKey = Buffer.from('af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837', 'hex');
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);

package/test/unit/identity/stateTransition/IdentityTopUpTransition/IdentityTopUpTransition.spec.js

@@ -1,29 +1,15 @@
 const getIdentityTopUpTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
-const getChainAssetLockProofFixture = require('../../../../../lib/test/fixtures/getChainAssetLockProofFixture');
 
-const { default: loadWasmDpp } = require('../../../../..');
-const { getLatestProtocolVersion, StateTransitionTypes } = require('../../../../..');
+const { InstantAssetLockProof, Identifier } = require('../../../../..');
+const { StateTransitionTypes } = require('../../../../..');
 
 describe('IdentityTopUpTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
-  let IdentityTopUpTransition;
-  let InstantAssetLockProof;
-  let Identifier;
-
-  before(async () => {
-    ({
-      IdentityTopUpTransition, InstantAssetLockProof, Identifier,
-    } = await loadWasmDpp());
-  });
-
   beforeEach(async () => {
-    rawStateTransition = (await getIdentityTopUpTransitionFixture()).toObject();
-
-    stateTransition = new IdentityTopUpTransition(
-      rawStateTransition,
-    );
+    stateTransition = await getIdentityTopUpTransitionFixture();
+    rawStateTransition = stateTransition.toObject();
   });
 
   describe('#constructor', () => {
@@ -35,13 +21,6 @@ describe('IdentityTopUpTransition', () => {
         rawStateTransition.identityId,
       );
     });
-
-    it('should create instance with chain asset lock proof', () => {
-      rawStateTransition.assetLockProof = getChainAssetLockProofFixture().toObject();
-      stateTransition = new IdentityTopUpTransition(rawStateTransition);
-      expect(stateTransition.getAssetLockProof().toObject())
-        .to.deep.equal(rawStateTransition.assetLockProof);
-    });
   });
 
   describe('#getType', () => {
@@ -90,7 +69,7 @@ describe('IdentityTopUpTransition', () => {
       rawStateTransition = stateTransition.toObject();
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityTopUp,
         assetLockProof: rawStateTransition.assetLockProof,
         identityId: rawStateTransition.identityId,
@@ -102,7 +81,7 @@ describe('IdentityTopUpTransition', () => {
       rawStateTransition = stateTransition.toObject({ skipSignature: true });
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityTopUp,
         assetLockProof: rawStateTransition.assetLockProof,
         identityId: rawStateTransition.identityId,
@@ -115,7 +94,7 @@ describe('IdentityTopUpTransition', () => {
       const jsonStateTransition = stateTransition.toJSON();
 
       expect(jsonStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityTopUp,
         assetLockProof: stateTransition.getAssetLockProof().toJSON(),
         identityId: new Identifier(rawStateTransition.identityId).toString(),

package/test/unit/identity/stateTransition/IdentityTopUpTransition/applyIdentityTopUpTransitionFactory.spec.js

@@ -6,7 +6,7 @@ const createStateRepositoryMock = require('../../../../../lib/test/mocks/createS
 
 const { default: loadWasmDpp } = require('../../../../..');
 
-describe('applyIdentityTopUpTransitionFactory', () => {
+describe.skip('applyIdentityTopUpTransitionFactory', () => {
   let stateTransition;
   let applyIdentityTopUpTransition;
   let stateRepositoryMock;
@@ -48,7 +48,7 @@ describe('applyIdentityTopUpTransitionFactory', () => {
     );
   });
 
-  it('should add topup amount to identity balance', async function () {
+  it('should add topup amount to identity balance', async function shouldAdd() {
     const balanceToTopUp = convertSatoshiToCredits(
       stateTransition.getAssetLockProof().getOutput().satoshis,
     );
@@ -77,7 +77,7 @@ describe('applyIdentityTopUpTransitionFactory', () => {
       );
   });
 
-  it('should ignore balance debt for system credits', async function () {
+  it('should ignore balance debt for system credits', async function shouldIgnore() {
     stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(-5);
 
     const balanceToTopUp = convertSatoshiToCredits(
@@ -108,7 +108,7 @@ describe('applyIdentityTopUpTransitionFactory', () => {
       );
   });
 
-  it('should add topup amount to identity balance on dry run', async function () {
+  it('should add topup amount to identity balance on dry run', async function shouldAddTopup() {
     const { match } = this.sinonSandbox;
 
     const balanceToTopUp = convertSatoshiToCredits(

package/test/unit/identity/stateTransition/IdentityTopUpTransition/validation/state/validateIdentityTopUpTransitionStateFactory.spec.js

@@ -3,7 +3,7 @@ const getIdentityTopUpTransitionFixture = require('../../../../../../../lib/test
 const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
 const { default: loadWasmDpp } = require('../../../../../../../dist');
 
-describe('validateIdentityTopUpTransitionStateFactory', () => {
+describe.skip('validateIdentityTopUpTransitionStateFactory', () => {
   let validateIdentityTopUpTransitionState;
   let stateTransition;
   let stateRepositoryMock;
@@ -19,7 +19,7 @@ describe('validateIdentityTopUpTransitionStateFactory', () => {
     } = await loadWasmDpp());
   });
 
-  beforeEach(async function () {
+  beforeEach(async function beforeEach() {
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
     stateTransition = await getIdentityTopUpTransitionFixture();

package/test/unit/identity/stateTransition/IdentityUpdateTransition/IdentityUpdateTransition.spec.js

@@ -1,25 +1,13 @@
 const getIdentityUpdateTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityUpdateTransitionFixture');
 
-const { default: loadWasmDpp } = require('../../../../..');
-const { getLatestProtocolVersion, StateTransitionTypes } = require('../../../../..');
+const { IdentityPublicKey, Identifier, IdentityPublicKeyWithWitness } = require('../../../../..');
+const { StateTransitionTypes } = require('../../../../..');
 const generateRandomIdentifierAsync = require('../../../../../lib/test/utils/generateRandomIdentifierAsync');
 
 describe('IdentityUpdateTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
-  let IdentityPublicKey;
-  let Identifier;
-  let IdentityPublicKeyWithWitness;
-
-  before(async () => {
-    ({
-      IdentityPublicKey,
-      Identifier,
-      IdentityPublicKeyWithWitness,
-    } = await loadWasmDpp());
-  });
-
   beforeEach(async () => {
     stateTransition = await getIdentityUpdateTransitionFixture();
     rawStateTransition = stateTransition.toObject();
@@ -75,28 +63,23 @@ describe('IdentityUpdateTransition', () => {
     it('should return public keys to add', () => {
       expect(stateTransition.getPublicKeysToAdd().map((key) => key.toObject()))
         .to.deep.equal(
-          rawStateTransition.addPublicKeys
-            .map((rawPublicKey) => new IdentityPublicKeyWithWitness(rawPublicKey).toObject()),
+          rawStateTransition.addPublicKeys,
         );
     });
   });
 
   describe('#setPublicKeysToAdd', () => {
     it('should set public keys to add', () => {
-      const publicKeys = [new IdentityPublicKeyWithWitness({
-        id: 0,
-        type: IdentityPublicKey.TYPES.BLS12_381,
-        purpose: 0,
-        securityLevel: 0,
-        readOnly: true,
-        signature: Buffer.alloc(0),
-        data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
-      })];
+      const key = new IdentityPublicKeyWithWitness(1);
+      key.setType(IdentityPublicKey.TYPES.BLS12_381);
+      key.setData(Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'));
+
+      const publicKeys = [key];
 
       stateTransition.setPublicKeysToAdd(publicKeys);
 
-      expect(stateTransition.addPublicKeys.map((key) => key.toObject()))
-        .to.have.deep.members(publicKeys.map((key) => key.toObject()));
+      expect(stateTransition.addPublicKeys.map((k) => k.toObject()))
+        .to.have.deep.members(publicKeys.map((k) => k.toObject()));
     });
   });
 
@@ -119,7 +102,7 @@ describe('IdentityUpdateTransition', () => {
   describe('#getPublicKeysDisabledAt', () => {
     it('should return time to disable public keys', () => {
       expect(stateTransition.getPublicKeysDisabledAt())
-        .to.deep.equal(new Date(rawStateTransition.publicKeysDisabledAt));
+        .to.deep.equal(rawStateTransition.publicKeysDisabledAt);
     });
   });
 
@@ -138,7 +121,7 @@ describe('IdentityUpdateTransition', () => {
       rawStateTransition = stateTransition.toObject();
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityUpdate,
         signature: undefined,
         identityId: rawStateTransition.identityId,
@@ -146,7 +129,7 @@ describe('IdentityUpdateTransition', () => {
         publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt,
         addPublicKeys: rawStateTransition.addPublicKeys,
         disablePublicKeys: rawStateTransition.disablePublicKeys,
-        signaturePublicKeyId: undefined,
+        signaturePublicKeyId: 0,
       });
     });
 
@@ -154,7 +137,7 @@ describe('IdentityUpdateTransition', () => {
       rawStateTransition = stateTransition.toObject({ skipSignature: true });
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityUpdate,
         identityId: rawStateTransition.identityId,
         revision: rawStateTransition.revision,
@@ -172,12 +155,12 @@ describe('IdentityUpdateTransition', () => {
       rawStateTransition = stateTransition.toObject();
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityUpdate,
         signature: undefined,
         identityId: rawStateTransition.identityId,
         revision: rawStateTransition.revision,
-        signaturePublicKeyId: undefined,
+        signaturePublicKeyId: 0,
       });
     });
   });
@@ -187,15 +170,15 @@ describe('IdentityUpdateTransition', () => {
       const jsonStateTransition = stateTransition.toJSON();
 
       expect(jsonStateTransition).to.deep.equal({
-        protocolVersion: getLatestProtocolVersion(),
+        $version: '0',
         type: StateTransitionTypes.IdentityUpdate,
         signature: undefined,
         identityId: stateTransition.getIdentityId().toString(),
         revision: rawStateTransition.revision,
-        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt,
+        publicKeysDisabledAt: rawStateTransition.publicKeysDisabledAt.getTime(),
         addPublicKeys: stateTransition.getPublicKeysToAdd().map((k) => k.toJSON()),
         disablePublicKeys: rawStateTransition.disablePublicKeys,
-        signaturePublicKeyId: undefined,
+        signaturePublicKeyId: 0,
       });
     });
   });

package/test/unit/identity/stateTransition/IdentityUpdateTransition/applyIdentityUpdateTransitionFactory.spec.js

@@ -3,7 +3,7 @@ const getIdentityUpdateTransitionFixture = require('../../../../../lib/test/fixt
 
 const { default: loadWasmDpp } = require('../../../../../dist');
 
-describe('applyIdentityUpdateTransition', () => {
+describe.skip('applyIdentityUpdateTransition', () => {
   let applyIdentityUpdateTransition;
   let stateRepositoryMock;
   let stateTransition;
@@ -38,7 +38,7 @@ describe('applyIdentityUpdateTransition', () => {
     );
   });
 
-  it('should add and disable public keys', async function () {
+  it('should add and disable public keys', async function shouldAdd() {
     await applyIdentityUpdateTransition(stateTransition);
 
     const { match } = this.sinonSandbox;
@@ -66,7 +66,7 @@ describe('applyIdentityUpdateTransition', () => {
     );
   });
 
-  it('should add and disable public keys on dry run', async function () {
+  it('should add and disable public keys on dry run', async function shouldDisable() {
     const { match } = this.sinonSandbox;
 
     executionContext.enableDryRun();

package/test/unit/identity/stateTransition/assetLockProof/fetchAssetLockPublicKeyHashFactory.spec.js

@@ -5,7 +5,7 @@ const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 const { default: loadWasmpDpp } = require('../../../../../dist');
 
-describe('fetchAssetLockPublicKeyHashFactory', () => {
+describe.skip('fetchAssetLockPublicKeyHashFactory', () => {
   let fetchAssetLockPublicKeyHash;
   let stateRepositoryMock;
   let executionContext;

package/test/unit/identity/stateTransition/identityCreditTransferTransition/identityCreditTransferTransition.spec.js

@@ -0,0 +1,130 @@
+const getIdentityCreditTransferTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityCreditTransferTransitionFixture');
+
+const {
+  Identifier, StateTransitionTypes,
+} = require('../../../../..');
+
+describe('IdentityCreditTransferTransition', () => {
+  let rawStateTransition;
+  let stateTransition;
+
+  beforeEach(async () => {
+    stateTransition = await getIdentityCreditTransferTransitionFixture();
+    rawStateTransition = stateTransition.toObject();
+  });
+
+  describe('#constructor', () => {
+    it('should create an instance with specified data from specified raw transition', () => {
+      expect(stateTransition.getIdentityId().toBuffer()).to.be.deep.equal(
+        rawStateTransition.identityId,
+      );
+
+      expect(stateTransition.getRecipientId().toBuffer()).to.be.deep.equal(
+        rawStateTransition.recipientId,
+      );
+
+      expect(stateTransition.getAmount()).to.be.equal(
+        rawStateTransition.amount,
+      );
+    });
+  });
+
+  describe('#getType', () => {
+    it('should return IDENTITY_CREDIT_TRANSFER type', () => {
+      expect(stateTransition.getType()).to.equal(StateTransitionTypes.IdentityCreditTransfer);
+    });
+  });
+
+  describe('#getIdentityId', () => {
+    it('should return identity id', () => {
+      expect(stateTransition.getIdentityId().toBuffer()).to.deep.equal(
+        rawStateTransition.identityId,
+      );
+    });
+  });
+
+  describe('#getRecipientId', () => {
+    it('should return recipient id', () => {
+      expect(stateTransition.getRecipientId().toBuffer()).to.deep.equal(
+        rawStateTransition.recipientId,
+      );
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject();
+
+      expect(rawStateTransition).to.deep.equal({
+        $version: '0',
+        type: StateTransitionTypes.IdentityCreditTransfer,
+        identityId: rawStateTransition.identityId,
+        recipientId: rawStateTransition.recipientId,
+        amount: rawStateTransition.amount,
+        signature: undefined,
+        signaturePublicKeyId: undefined,
+      });
+    });
+
+    it('should return raw state transition', () => {
+      rawStateTransition = stateTransition.toObject({ skipSignature: true });
+
+      expect(rawStateTransition).to.deep.equal({
+        $version: '0',
+        type: StateTransitionTypes.IdentityCreditTransfer,
+        identityId: rawStateTransition.identityId,
+        recipientId: rawStateTransition.recipientId,
+        amount: rawStateTransition.amount,
+      });
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return JSON representation of state transition', () => {
+      const jsonStateTransition = stateTransition.toJSON();
+
+      expect(jsonStateTransition).to.deep.equal({
+        $version: '0',
+        type: StateTransitionTypes.IdentityCreditTransfer,
+        identityId: new Identifier(rawStateTransition.identityId).toString(),
+        recipientId: new Identifier(rawStateTransition.recipientId).toString(),
+        amount: rawStateTransition.amount,
+        signature: undefined,
+        signaturePublicKeyId: undefined,
+      });
+    });
+  });
+
+  describe('#getModifiedDataIds', () => {
+    it('should return ids of topped up identity', () => {
+      const result = stateTransition.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(2);
+      const [identityId, recipientId] = result;
+
+      expect(identityId).to.be.an.instanceOf(Identifier);
+      expect(identityId.toBuffer()).to.be.deep.equal(rawStateTransition.identityId);
+
+      expect(recipientId).to.be.an.instanceOf(Identifier);
+      expect(recipientId.toBuffer()).to.be.deep.equal(rawStateTransition.recipientId);
+    });
+  });
+
+  describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDocumentStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDocumentStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransition.isIdentityStateTransition()).to.be.true();
+    });
+  });
+});

package/test/unit/stateTransition/StateTransitionExecutionContext.spec.js

@@ -1,7 +1,7 @@
 const { expect } = require('chai');
 const { default: loadWasmDpp } = require('../../../dist');
 
-describe('StateTransitionExecutionContext', () => {
+describe.skip('StateTransitionExecutionContext', () => {
   let ReadOperation;
   let PreCalculatedOperation;
   let SignatureVerificationOperation;