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

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

@@ -1,64 +1,73 @@
-const { expectValidationError } = require(
-  '@dashevo/dpp/lib/test/expect/expectError',
-);
-
-const validateIdentityCreateTransitionStateFactory = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityCreateTransition/validation/state/validateIdentityCreateTransitionStateFactory',
-);
-
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
 
-const IdentityAlreadyExistsError = require(
-  '@dashevo/dpp/lib/errors/consensus/state/identity/IdentityAlreadyExistsError',
-);
-
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
+
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
 
 describe('validateIdentityCreateTransitionStateFactory', () => {
   let validateIdentityCreateTransitionState;
   let stateTransition;
   let stateRepositoryMock;
 
-  beforeEach(async function beforeEach() {
-    const privateKey = 'af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837';
+  let IdentityCreateTransition;
+  let IdentityPublicKey;
+  let IdentityAlreadyExistsError;
+  let IdentityCreateTransitionStateValidator;
+
+  before(async () => {
+    ({
+      IdentityCreateTransition,
+      IdentityAlreadyExistsError,
+      IdentityPublicKey,
+      IdentityCreateTransitionStateValidator,
+    } = await loadWasmDpp());
+  });
+
+  beforeEach(async function () {
+    const privateKey = Buffer.from('af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837', 'hex');
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    validateIdentityCreateTransitionState = validateIdentityCreateTransitionStateFactory(
-      stateRepositoryMock,
-    );
+    const validator = new IdentityCreateTransitionStateValidator(stateRepositoryMock);
+    validateIdentityCreateTransitionState = (st) => validator.validate(st);
 
-    stateTransition = getIdentityCreateTransitionFixture();
+    stateTransition = new IdentityCreateTransition(
+      getIdentityCreateTransitionFixture().toObject(),
+    );
 
     await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
 
     const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
 
-    stateRepositoryMock.fetchTransaction.resolves(rawTransaction);
+    stateRepositoryMock.fetchTransaction.resolves({
+      data: Buffer.from(rawTransaction, 'hex'),
+      height: 42,
+    });
   });
 
   it('should return invalid result if identity already exists', async () => {
-    stateRepositoryMock.fetchIdentity.resolves({});
+    stateRepositoryMock.fetchIdentityBalance.resolves(1);
 
     const result = await validateIdentityCreateTransitionState(stateTransition);
 
-    expectValidationError(result, IdentityAlreadyExistsError, 1);
+    await expectValidationError(result, IdentityAlreadyExistsError);
 
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(4011);
-    expect(Buffer.isBuffer(error.getIdentityId())).to.be.true();
-    expect(error.getIdentityId()).to.deep.equal(stateTransition.getIdentityId());
+    expect(error.getIdentityId()).to.exist();
+    expect(error.getIdentityId()).to.deep.equal(stateTransition.getIdentityId().toBuffer());
   });
 
   it('should return valid result if state transition is valid', async () => {
+    stateRepositoryMock.fetchIdentityBalance.resolves();
     const result = await validateIdentityCreateTransitionState(stateTransition);
 
     expect(result.isValid()).to.be.true();
   });
 
   it('should return valid result on dry run', async () => {
-    stateRepositoryMock.fetchIdentity.resolves({});
+    stateRepositoryMock.fetchIdentityBalance.resolves(1);
 
     stateTransition.getExecutionContext().enableDryRun();
 

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

@@ -1,20 +1,30 @@
-const stateTransitionTypes = require(
-  '@dashevo/dpp/lib/stateTransition/stateTransitionTypes',
-);
-
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
-
 const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
+const getChainAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
 
+const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('IdentityTopUpTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
+  let IdentityTopUpTransition;
+  let InstantAssetLockProof;
+  let Identifier;
+
+  before(async () => {
+    ({
+      IdentityTopUpTransition, InstantAssetLockProof, Identifier,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(() => {
-    stateTransition = getIdentityTopUpTransitionFixture();
-    rawStateTransition = stateTransition.toObject();
+    rawStateTransition = getIdentityTopUpTransitionFixture().toObject();
+
+    stateTransition = new IdentityTopUpTransition(
+      rawStateTransition,
+    );
   });
 
   describe('#constructor', () => {
@@ -22,10 +32,17 @@ describe('IdentityTopUpTransition', () => {
       expect(stateTransition.getAssetLockProof().toObject()).to.be.deep.equal(
         rawStateTransition.assetLockProof,
       );
-      expect(stateTransition.getIdentityId()).to.be.deep.equal(
+      expect(stateTransition.getIdentityId().toBuffer()).to.be.deep.equal(
         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', () => {
@@ -36,13 +53,16 @@ describe('IdentityTopUpTransition', () => {
 
   describe('#setAssetLockProof', () => {
     it('should set asset lock proof', () => {
-      stateTransition.setAssetLockProof(rawStateTransition.assetLockProof);
+      stateTransition.setAssetLockProof(
+        new InstantAssetLockProof(rawStateTransition.assetLockProof),
+      );
 
-      expect(stateTransition.assetLockProof).to.deep.equal(rawStateTransition.assetLockProof);
+      expect(stateTransition.assetLockProof.toObject())
+        .to.deep.equal(rawStateTransition.assetLockProof);
     });
   });
 
-  describe('#getAssetLock', () => {
+  describe('#getAssetLockProof', () => {
     it('should return currently set asset lock proof', () => {
       expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
         rawStateTransition.assetLockProof,
@@ -52,7 +72,7 @@ describe('IdentityTopUpTransition', () => {
 
   describe('#getIdentityId', () => {
     it('should return identity id', () => {
-      expect(stateTransition.getIdentityId()).to.deep.equal(
+      expect(stateTransition.getIdentityId().toBuffer()).to.deep.equal(
         rawStateTransition.identityId,
       );
     });
@@ -60,7 +80,7 @@ describe('IdentityTopUpTransition', () => {
 
   describe('#getOwnerId', () => {
     it('should return owner id', () => {
-      expect(stateTransition.getOwnerId()).to.deep.equal(
+      expect(stateTransition.getOwnerId().toBuffer()).to.deep.equal(
         rawStateTransition.identityId,
       );
     });
@@ -99,7 +119,7 @@ describe('IdentityTopUpTransition', () => {
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.IDENTITY_TOP_UP,
         assetLockProof: stateTransition.getAssetLockProof().toJSON(),
-        identityId: Identifier(rawStateTransition.identityId).toString(),
+        identityId: new Identifier(rawStateTransition.identityId).toString(),
         signature: undefined,
       });
     });
@@ -113,7 +133,7 @@ describe('IdentityTopUpTransition', () => {
       const identityId = result[0];
 
       expect(identityId).to.be.an.instanceOf(Identifier);
-      expect(identityId).to.be.deep.equal(rawStateTransition.identityId);
+      expect(identityId.toBuffer()).to.be.deep.equal(rawStateTransition.identityId);
     });
   });
 

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

@@ -1,80 +1,120 @@
-const applyIdentityTopUpTransitionFactory = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityTopUpTransition/applyIdentityTopUpTransitionFactory',
-);
-
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
 
 const { convertSatoshiToCredits } = require('@dashevo/dpp/lib/identity/creditsConverter');
 
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
-const getBiggestPossibleIdentity = require('@dashevo/dpp/lib/identity/getBiggestPossibleIdentity');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('applyIdentityTopUpTransitionFactory', () => {
   let stateTransition;
   let applyIdentityTopUpTransition;
   let stateRepositoryMock;
-  let identity;
-  let fetchAssetLockTransactionOutputMock;
   let executionContext;
 
-  beforeEach(function beforeEach() {
-    identity = getIdentityFixture();
+  let StateTransitionExecutionContext;
+  let IdentityTopUpTransition;
+
+  let applyIdentityTopUpTransitionDPP;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      IdentityTopUpTransition,
+      applyIdentityTopUpTransition: applyIdentityTopUpTransitionDPP,
+    } = await loadWasmDpp());
+  });
 
+  beforeEach(async function beforeEach() {
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchIdentity.resolves(identity);
+    stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(0);
+    stateRepositoryMock.addToIdentityBalance.resolves();
+    stateRepositoryMock.addToSystemCredits.resolves();
+    stateRepositoryMock.markAssetLockTransactionOutPointAsUsed.resolves();
 
-    stateTransition = getIdentityTopUpTransitionFixture();
+    const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
 
-    executionContext = new StateTransitionExecutionContext();
+    stateRepositoryMock.fetchTransaction.resolves({
+      data: Buffer.from(rawTransaction, 'hex'),
+      height: 42,
+    });
 
-    stateTransition.setExecutionContext(executionContext);
+    stateTransition = new IdentityTopUpTransition(
+      getIdentityTopUpTransitionFixture().toObject(),
+    );
 
-    const output = stateTransition.getAssetLockProof().getOutput();
+    executionContext = new StateTransitionExecutionContext();
 
-    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
+    stateTransition.setExecutionContext(executionContext);
 
-    applyIdentityTopUpTransition = applyIdentityTopUpTransitionFactory(
+    applyIdentityTopUpTransition = (st) => applyIdentityTopUpTransitionDPP(
       stateRepositoryMock,
-      fetchAssetLockTransactionOutputMock,
+      st,
     );
   });
 
-  it('should store identity created from state transition', async () => {
-    const balanceBeforeTopUp = identity.getBalance();
-
+  it('should add topup amount to identity balance', async function () {
     const balanceToTopUp = convertSatoshiToCredits(
       stateTransition.getAssetLockProof().getOutput().satoshis,
     );
 
     await applyIdentityTopUpTransition(stateTransition);
 
-    expect(identity.getBalance()).to.be.equal(balanceBeforeTopUp + balanceToTopUp);
-    expect(identity.getBalance()).to.be.greaterThan(balanceBeforeTopUp);
+    const { match } = this.sinonSandbox;
 
-    expect(stateRepositoryMock.updateIdentity).to.have.been.calledOnceWithExactly(
-      identity,
-      executionContext,
+    expect(stateRepositoryMock.addToIdentityBalance).to.have.been.calledOnceWithExactly(
+      match((arg) => arg.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      balanceToTopUp,
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
+    expect(stateRepositoryMock.addToSystemCredits).to.have.been.calledOnceWithExactly(
+      balanceToTopUp,
+      match.instanceOf(StateTransitionExecutionContext),
+    );
+
+    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
+
     expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
       .calledOnceWithExactly(
-        stateTransition.getAssetLockProof().getOutPoint(),
-        executionContext,
+        match((arg) => Buffer.from(arg).equals(outPoint)),
+        match.instanceOf(StateTransitionExecutionContext),
       );
+  });
+
+  it('should ignore balance debt for system credits', async function () {
+    stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(-5);
 
-    expect(fetchAssetLockTransactionOutputMock)
-      .to.be.calledOnceWithExactly(
-        stateTransition.getAssetLockProof(),
-        executionContext,
+    const balanceToTopUp = convertSatoshiToCredits(
+      stateTransition.getAssetLockProof().getOutput().satoshis,
+    );
+
+    await applyIdentityTopUpTransition(stateTransition);
+
+    const { match } = this.sinonSandbox;
+
+    expect(stateRepositoryMock.addToIdentityBalance).to.have.been.calledOnceWithExactly(
+      match((arg) => arg.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      balanceToTopUp,
+      match.instanceOf(StateTransitionExecutionContext),
+    );
+
+    expect(stateRepositoryMock.addToSystemCredits).to.have.been.calledOnceWithExactly(
+      balanceToTopUp - 5,
+      match.instanceOf(StateTransitionExecutionContext),
+    );
+
+    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
+
+    expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
+      .calledOnceWithExactly(
+        match((arg) => Buffer.from(arg).equals(outPoint)),
+        match.instanceOf(StateTransitionExecutionContext),
       );
   });
 
-  it('should store biggest possible identity on dry run', async () => {
-    const biggestPossibleIdentity = getBiggestPossibleIdentity();
-
-    const balanceBeforeTopUp = biggestPossibleIdentity.getBalance();
+  it('should add topup amount to identity balance on dry run', async function () {
+    const { match } = this.sinonSandbox;
 
     const balanceToTopUp = convertSatoshiToCredits(
       stateTransition.getAssetLockProof().getOutput().satoshis,
@@ -86,23 +126,18 @@ describe('applyIdentityTopUpTransitionFactory', () => {
 
     executionContext.disableDryRun();
 
-    expect(biggestPossibleIdentity.getBalance()).to.be.equal(balanceBeforeTopUp + balanceToTopUp);
-
-    expect(stateRepositoryMock.updateIdentity).to.have.been.calledOnceWithExactly(
-      biggestPossibleIdentity,
-      executionContext,
+    expect(stateRepositoryMock.addToIdentityBalance).to.have.been.calledOnceWithExactly(
+      match((arg) => arg.toBuffer().equals(stateTransition.getOwnerId().toBuffer())),
+      balanceToTopUp,
+      match.instanceOf(StateTransitionExecutionContext),
     );
 
+    const outPoint = stateTransition.getAssetLockProof().getOutPoint();
+
     expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
       .calledOnceWithExactly(
-        stateTransition.getAssetLockProof().getOutPoint(),
-        executionContext,
-      );
-
-    expect(fetchAssetLockTransactionOutputMock)
-      .to.be.calledOnceWithExactly(
-        stateTransition.getAssetLockProof(),
-        executionContext,
+        match((arg) => Buffer.from(arg).equals(outPoint)),
+        match.instanceOf(StateTransitionExecutionContext),
       );
   });
 });

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

@@ -1,17 +1,35 @@
 const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
 
-const validateIdentityTopUpTransitionStateFactory = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityTopUpTransition/validation/state/validateIdentityTopUpTransitionStateFactory',
-);
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
 
 describe('validateIdentityTopUpTransitionStateFactory', () => {
   let validateIdentityTopUpTransitionState;
   let stateTransition;
+  let stateRepositoryMock;
 
-  beforeEach(() => {
-    validateIdentityTopUpTransitionState = validateIdentityTopUpTransitionStateFactory();
+  let IdentityTopUpTransition;
+  let IdentityTopUpTransitionStateValidator;
 
-    stateTransition = getIdentityTopUpTransitionFixture();
+  before(async () => {
+    ({
+      IdentityTopUpTransition,
+      IdentityTopUpTransitionStateValidator,
+    } = await loadWasmDpp());
+  });
+
+  beforeEach(function () {
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    stateTransition = new IdentityTopUpTransition(
+      getIdentityTopUpTransitionFixture().toObject(),
+    );
+
+    const validator = new IdentityTopUpTransitionStateValidator(stateRepositoryMock);
+
+    validateIdentityTopUpTransitionState = (st) => validator.validate(
+      st,
+    );
   });
 
   it('should return valid result', async () => {

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

@@ -1,22 +1,37 @@
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
-
 const stateTransitionTypes = require(
   '@dashevo/dpp/lib/stateTransition/stateTransitionTypes',
 );
 
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
 
 const getIdentityUpdateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityUpdateTransitionFixture');
-const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+const generateRandomIdentifierAsync = require('../../../../../lib/test/utils/generateRandomIdentifierAsync');
 
 describe('IdentityUpdateTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
+  let IdentityUpdateTransition;
+  let IdentityPublicKey;
+  let Identifier;
+  let IdentityPublicKeyCreateTransition;
+
+  before(async () => {
+    ({
+      IdentityUpdateTransition,
+      IdentityPublicKey,
+      Identifier,
+      IdentityPublicKeyCreateTransition,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(() => {
-    stateTransition = getIdentityUpdateTransitionFixture();
-    rawStateTransition = stateTransition.toObject();
+    rawStateTransition = getIdentityUpdateTransitionFixture().toObject();
+    stateTransition = new IdentityUpdateTransition(
+      rawStateTransition,
+    );
   });
 
   describe('#getType', () => {
@@ -26,18 +41,20 @@ describe('IdentityUpdateTransition', () => {
   });
 
   describe('#setIdentityId', () => {
-    it('should set identityId', () => {
-      const id = generateRandomIdentifier();
+    it('should set identityId', async () => {
+      const id = await generateRandomIdentifierAsync();
 
       stateTransition.setIdentityId(id);
 
-      expect(stateTransition.identityId).to.deep.equal(id);
+      expect(stateTransition.identityId.toBuffer())
+        .to.deep.equal(id.toBuffer());
     });
   });
 
   describe('#getIdentityId', () => {
     it('should return identityId', () => {
-      expect(stateTransition.getIdentityId()).to.deep.equal(rawStateTransition.identityId);
+      expect(stateTransition.getIdentityId().toBuffer())
+        .to.deep.equal(rawStateTransition.identityId);
     });
   });
 
@@ -51,13 +68,13 @@ describe('IdentityUpdateTransition', () => {
     it('should set revision', () => {
       stateTransition.setRevision(42);
 
-      expect(stateTransition.revision).to.equal(42);
+      expect(stateTransition.getRevision()).to.equal(42);
     });
   });
 
   describe('#getOwnerId', () => {
     it('should return owner id', () => {
-      expect(stateTransition.getOwnerId()).to.deep.equal(
+      expect(stateTransition.getOwnerId().toBuffer()).to.deep.equal(
         rawStateTransition.identityId,
       );
     });
@@ -65,33 +82,37 @@ describe('IdentityUpdateTransition', () => {
 
   describe('#getPublicKeysToAdd', () => {
     it('should return public keys to add', () => {
-      expect(stateTransition.getPublicKeysToAdd()).to.deep.equal(
-        rawStateTransition.addPublicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
-      );
+      expect(stateTransition.getPublicKeysToAdd().map((key) => key.toObject()))
+        .to.deep.equal(
+          rawStateTransition.addPublicKeys
+            .map((rawPublicKey) => new IdentityPublicKeyCreateTransition(rawPublicKey).toObject()),
+        );
     });
   });
 
   describe('#setPublicKeysToAdd', () => {
     it('should set public keys to add', () => {
-      const publicKeys = [new IdentityPublicKey({
+      const publicKeys = [new IdentityPublicKeyCreateTransition({
         id: 0,
         type: IdentityPublicKey.TYPES.BLS12_381,
         purpose: 0,
         securityLevel: 0,
         readOnly: true,
+        signature: Buffer.alloc(0),
         data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
       })];
 
       stateTransition.setPublicKeysToAdd(publicKeys);
 
-      expect(stateTransition.addPublicKeys).to.have.deep.members(publicKeys);
+      expect(stateTransition.addPublicKeys.map((key) => key.toObject()))
+        .to.have.deep.members(publicKeys.map((key) => key.toObject()));
     });
   });
 
   describe('#getPublicKeyIdsToDisable', () => {
     it('should return public key ids to disable', () => {
       expect(stateTransition.getPublicKeyIdsToDisable())
-        .to.deep.equal(stateTransition.disablePublicKeys);
+        .to.deep.equal(rawStateTransition.disablePublicKeys);
     });
   });
 
@@ -99,14 +120,15 @@ describe('IdentityUpdateTransition', () => {
     it('should set public key ids to disable', () => {
       stateTransition.setPublicKeyIdsToDisable([1, 2]);
 
-      expect(stateTransition.disablePublicKeys).to.deep.equal([1, 2]);
+      expect(stateTransition.getPublicKeyIdsToDisable())
+        .to.deep.equal([1, 2]);
     });
   });
 
   describe('#getPublicKeysDisabledAt', () => {
     it('should return time to disable public keys', () => {
       expect(stateTransition.getPublicKeysDisabledAt())
-        .to.deep.equal(new Date(stateTransition.publicKeysDisabledAt));
+        .to.deep.equal(new Date(rawStateTransition.publicKeysDisabledAt));
     });
   });
 
@@ -116,7 +138,7 @@ describe('IdentityUpdateTransition', () => {
 
       stateTransition.setPublicKeysDisabledAt(now);
 
-      expect(stateTransition.publicKeysDisabledAt).to.deep.equal(new Date(now));
+      expect(stateTransition.getPublicKeysDisabledAt()).to.deep.equal(new Date(now));
     });
   });
 
@@ -195,7 +217,7 @@ describe('IdentityUpdateTransition', () => {
       const identityId = result[0];
 
       expect(identityId).to.be.an.instanceOf(Identifier);
-      expect(identityId).to.be.deep.equal(rawStateTransition.identityId);
+      expect(identityId.toBuffer()).to.be.deep.equal(rawStateTransition.identityId);
     });
   });