@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

package/test/unit/document/stateTransition/DocumetsBatchTransition/DocumentsBatchTransition.spec.js

@@ -3,36 +3,68 @@ const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocuments
 const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const DocumentFactory = require('@dashevo/dpp/lib/document/DocumentFactory');
-const serializer = require('@dashevo/dpp/lib/util/serializer');
-const hash = require('@dashevo/dpp/lib/util/hash');
+const DocumentFactoryJs = require('@dashevo/dpp/lib/document/DocumentFactory');
+const lodash = require('lodash');
+const { default: loadWasmDpp } = require('../../../../../dist');
+const newDocumentsContainer = require('../../../../../lib/test/utils/newDocumentsContainer');
+
+let Identifier;
+let DocumentFactory;
+let DataContract;
+let Document;
+let DocumentValidator;
+let ProtocolVersionValidator;
 
 describe('DocumentsBatchTransition', () => {
+  let stateTransitionJs;
   let stateTransition;
+  let documentsJs;
   let documents;
-  let hashMock;
-  let encodeMock;
+  let dataContractJs;
   let dataContract;
+  let factoryJs;
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
-    documents = getDocumentsFixture(dataContract);
+  beforeEach(async () => {
+    ({
+      Identifier, ProtocolVersionValidator, DocumentValidator, DocumentFactory, DataContract,
+      Document,
+    } = await loadWasmDpp());
+  });
 
-    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
-    hashMock = this.sinonSandbox.stub(hash, 'hash');
+  beforeEach(async () => {
+    dataContractJs = getDataContractFixture();
+    dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
 
-    const factory = new DocumentFactory(createDPPMock(), undefined, undefined);
-    stateTransition = factory.createStateTransition({
-      create: documents,
+    documentsJs = getDocumentsFixture(dataContractJs);
+    documents = documentsJs.map((d) => {
+      const doc = new Document(d.toObject(), dataContract);
+      doc.setEntropy(d.entropy);
+      return doc;
     });
-  });
 
-  afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
+    const protocolVersionValidatorRs = new ProtocolVersionValidator();
+    const documentValidatorRs = new DocumentValidator(protocolVersionValidatorRs);
+    const factory = new DocumentFactory(1, documentValidatorRs, {});
+    factoryJs = new DocumentFactoryJs(createDPPMock(), undefined, undefined);
+
+    stateTransitionJs = factoryJs.createStateTransition({
+      create: documentsJs,
+    });
+
+    stateTransition = factory.createStateTransition(await newDocumentsContainer({
+      create: documents,
+    }));
   });
 
   describe('#getProtocolVersion', () => {
+    it('should return the current protocol version', () => {
+      const result = stateTransitionJs.getProtocolVersion();
+
+      expect(result).to.equal(protocolVersion.latestVersion);
+    });
+  });
+
+  describe('#getProtocolVersion - Rust', () => {
     it('should return the current protocol version', () => {
       const result = stateTransition.getProtocolVersion();
 
@@ -41,6 +73,14 @@ describe('DocumentsBatchTransition', () => {
   });
 
   describe('#getType', () => {
+    it('should return State Transition type', () => {
+      const result = stateTransitionJs.getType();
+
+      expect(result).to.equal(stateTransitionTypes.DOCUMENTS_BATCH);
+    });
+  });
+
+  describe('#getType - Rust', () => {
     it('should return State Transition type', () => {
       const result = stateTransition.getType();
 
@@ -50,19 +90,38 @@ describe('DocumentsBatchTransition', () => {
 
   describe('#getTransitions', () => {
     it('should return document transitions', () => {
-      const result = stateTransition.getTransitions();
+      const result = stateTransitionJs.getTransitions();
 
-      expect(result).to.equal(stateTransition.transitions);
+      expect(result).to.equal(stateTransitionJs.transitions);
+    });
+  });
+
+  describe('#getTransitions - Rust', () => {
+    it('should return document transitions', () => {
+      const transitionsJs = stateTransitionJs.getTransitions().map((t) => t.toJSON());
+      const transitions = stateTransition.getTransitions().map((t) => t.toJSON());
+      expect(transitionsJs).to.deep.equal(transitions);
     });
   });
 
   describe('#toJSON', () => {
     it('should return State Transition as JSON', () => {
+      expect(stateTransitionJs.toJSON()).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.DOCUMENTS_BATCH,
+        ownerId: documentsJs[0].getOwnerId().toString(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toJSON()),
+        signaturePublicKeyId: undefined,
+        signature: undefined,
+      });
+    });
+
+    it('should return State Transition as JSON - Rust', () => {
       expect(stateTransition.toJSON()).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DOCUMENTS_BATCH,
-        ownerId: documents[0].getOwnerId().toString(),
-        transitions: stateTransition.getTransitions().map((d) => d.toJSON()),
+        ownerId: documentsJs[0].getOwnerId().toString(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toJSON()),
         signaturePublicKeyId: undefined,
         signature: undefined,
       });
@@ -71,77 +130,78 @@ describe('DocumentsBatchTransition', () => {
 
   describe('#toObject', () => {
     it('should return State Transition as plain object', () => {
-      expect(stateTransition.toObject()).to.deep.equal({
+      expect(stateTransitionJs.toObject()).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DOCUMENTS_BATCH,
-        ownerId: documents[0].getOwnerId(),
-        transitions: stateTransition.getTransitions().map((d) => d.toObject()),
+        ownerId: documentsJs[0].getOwnerId(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toObject()),
         signaturePublicKeyId: undefined,
         signature: undefined,
       });
     });
-  });
-
-  describe('#toBuffer', () => {
-    it('should return serialized Documents State Transition', () => {
-      const serializedStateTransition = Buffer.from('123');
-
-      encodeMock.returns(serializedStateTransition);
-
-      const result = stateTransition.toBuffer();
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+    it('should return State Transition as plain object -  Rust', () => {
+      const rawObject = stateTransition.toObject();
+      const rawObjectJs = stateTransitionJs.toObject();
+      /* eslint-disable */
+      const rawObjectWithBuffers = lodash.cloneDeepWith(rawObject, (value) => {
+        if (value instanceof Identifier) {
+          return value.toBuffer();
+        }
+      });
 
-      expect(result).to.deep.equal(
-        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
-      );
+      expect(rawObjectWithBuffers).to.deep.equal(rawObjectJs);
+    });
+  });
 
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
+  describe('#toBuffer', () => {
+    it('should return the same bytes as JS version', () => {
+      const bufferJs = stateTransitionJs.toBuffer();
+      const buffer = stateTransition.toBuffer();
 
-      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+      expect(bufferJs).to.deep.equal(buffer);
     });
   });
 
   describe('#hash', () => {
-    it('should return Documents State Transition hash as hex', () => {
-      const serializedDocument = Buffer.from('123');
-      const hashedDocument = '456';
-
-      encodeMock.returns(serializedDocument);
-      hashMock.returns(hashedDocument);
+    it('should return the same hash as the JS version', () => {
+      const hashJs = stateTransitionJs.hash();
+      const hash = stateTransitionJs.hash();
 
-      const result = stateTransition.hash();
-
-      expect(result).to.equal(hashedDocument);
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+      expect(hash).to.deep.equal(hashJs);
+    });
+  });
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+  describe('#getOwnerId', () => {
+    it('should return owner id', async () => {
+      const result = stateTransitionJs.getOwnerId();
 
-      expect(hashMock).to.have.been.calledOnceWith(
-        Buffer.concat([protocolVersionUInt32, serializedDocument]),
-      );
+      expect(result).to.deep.equal(getDocumentsFixture.ownerId);
     });
   });
 
-  describe('#getOwnerId', () => {
+  describe('#getOwnerId - Rust', () => {
     it('should return owner id', async () => {
       const result = stateTransition.getOwnerId();
 
-      expect(result).to.deep.equal(getDocumentsFixture.ownerId);
+      expect(result.toBuffer()).to.deep.equal(getDocumentsFixture.ownerId.toBuffer());
     });
   });
 
   describe('#getModifiedDataIds', () => {
     it('should return ids of affected documents', () => {
-      const expectedIds = documents.map((doc) => doc.getId());
-      const result = stateTransition.getModifiedDataIds();
+      const expectedIds = documentsJs.map((doc) => doc.getId());
+      const result = stateTransitionJs.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(10);
+      expect(result).to.be.deep.equal(expectedIds);
+    });
+  });
+
+  describe('#getModifiedDataIds - Rust', () => {
+    it('should return ids of affected documents', () => {
+      const expectedIds = documentsJs.map((doc) => doc.getId().toBuffer());
+      const result = stateTransition.getModifiedDataIds().map((id) => id.toBuffer());
 
       expect(result.length).to.be.equal(10);
       expect(result).to.be.deep.equal(expectedIds);
@@ -149,18 +209,36 @@ describe('DocumentsBatchTransition', () => {
   });
 
   describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransitionJs.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDataContractStateTransition - Rust', () => {
     it('should return false', () => {
       expect(stateTransition.isDataContractStateTransition()).to.be.false();
     });
   });
 
   describe('#isDocumentStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransitionJs.isDocumentStateTransition()).to.be.true();
+    });
+  });
+
+  describe('#isDocumentStateTransition - Rust', () => {
     it('should return true', () => {
       expect(stateTransition.isDocumentStateTransition()).to.be.true();
     });
   });
 
   describe('#isIdentityStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransitionJs.isIdentityStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition - Rust', () => {
     it('should return false', () => {
       expect(stateTransition.isIdentityStateTransition()).to.be.false();
     });

package/test/unit/document/stateTransition/DocumetsBatchTransition/applyDocumentsBatchTransitionFactory.spec.js

@@ -66,7 +66,7 @@ describe('applyDocumentsBatchTransitionFactory', () => {
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
     stateRepositoryMock.fetchDataContract.resolves(dataContract);
-    stateRepositoryMock.fetchLatestPlatformBlockTime.returns(blockTimeMs);
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTimeMs);
 
     fetchDocumentsMock = this.sinonSandbox.stub();
     fetchDocumentsMock.resolves([

package/test/unit/document/stateTransition/DocumetsBatchTransition/validation/state/validateDocumentsBatchTransitionStateFactory.spec.js

@@ -68,7 +68,7 @@ describe('validateDocumentsBatchTransitionStateFactory', () => {
 
     blockTime = Date.now();
 
-    stateRepositoryMock.fetchLatestPlatformBlockTime.returns(blockTime);
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
 
     fetchDocumentsMock = this.sinonSandbox.stub().resolves([]);
 

package/test/unit/identity/Identity.spec.js

@@ -1,3 +1,4 @@
+const varint = require('varint');
 const JSIdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 const JSIdentity = require('@dashevo/dpp/lib/identity/Identity');
@@ -145,8 +146,7 @@ describe('Identity', () => {
       const identityDataToEncode = identity.toObject();
       delete identityDataToEncode.protocolVersion;
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(identity.getProtocolVersion(), 0);
+      varint.encode(identity.getProtocolVersion());
 
       expect(result).to.deep.equal(expectedHash);
     });

package/test/unit/identity/IdentityPublicKey.spec.js

@@ -4,24 +4,18 @@ describe('IdentityPublicKey', () => {
   let rawPublicKey;
   let publicKey;
   let IdentityPublicKey;
-  let KeyPurpose;
-  let KeyType;
-  let KeySecurityLevel;
 
   beforeEach(async () => {
-    ({
-      IdentityPublicKey, KeyPurpose, KeyType, KeySecurityLevel,
-    } = await loadWasmDpp());
+    ({ IdentityPublicKey } = await loadWasmDpp());
 
     rawPublicKey = {
       id: 0,
-      type: KeyType.ECDSA_SECP256K1,
+      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
       data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
-      purpose: KeyPurpose.AUTHENTICATION,
-      securityLevel: KeySecurityLevel.MASTER,
+      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
       readOnly: false,
     };
-
     publicKey = new IdentityPublicKey(rawPublicKey);
   });
 
@@ -89,9 +83,9 @@ describe('IdentityPublicKey', () => {
 
   describe('#setPurpose', () => {
     it('should set data', () => {
-      publicKey.setPurpose(KeyPurpose.DECRYPTION);
+      publicKey.setPurpose(IdentityPublicKey.PURPOSES.DECRYPTION);
 
-      expect(publicKey.getPurpose()).to.equal(KeyPurpose.DECRYPTION);
+      expect(publicKey.getPurpose()).to.equal(IdentityPublicKey.PURPOSES.DECRYPTION);
     });
   });
 
@@ -103,9 +97,9 @@ describe('IdentityPublicKey', () => {
 
   describe('#setSecurityLevel', () => {
     it('should set data', () => {
-      publicKey.setSecurityLevel(KeySecurityLevel.MEDIUM);
+      publicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
 
-      expect(publicKey.getSecurityLevel()).to.equal(KeySecurityLevel.MEDIUM);
+      expect(publicKey.getSecurityLevel()).to.equal(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
     });
   });
 
@@ -151,10 +145,10 @@ describe('IdentityPublicKey', () => {
     it('should return data in case ECDSA_HASH160', () => {
       rawPublicKey = {
         id: 0,
-        type: KeyType.ECDSA_HASH160,
+        type: IdentityPublicKey.TYPES.ECDSA_HASH160,
         data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
-        purpose: KeyPurpose.AUTHENTICATION,
-        securityLevel: KeySecurityLevel.MASTER,
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
         readOnly: false,
         disabledAt: 123,
       };
@@ -171,10 +165,10 @@ describe('IdentityPublicKey', () => {
     it('should return original public key hash in case BLS12_381', () => {
       rawPublicKey = {
         id: 0,
-        type: KeyType.BLS12_381,
+        type: IdentityPublicKey.TYPES.BLS12_381,
         data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
-        purpose: KeyPurpose.AUTHENTICATION,
-        securityLevel: KeySecurityLevel.MASTER,
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
         readOnly: false,
         disabledAt: 123,
       };
@@ -191,10 +185,10 @@ describe('IdentityPublicKey', () => {
     it('should return data in case BIP13_SCRIPT_HASH', () => {
       rawPublicKey = {
         id: 0,
-        type: KeyType.BIP13_SCRIPT_HASH,
+        type: IdentityPublicKey.TYPES.BIP13_SCRIPT_HASH,
         data: Buffer.from('54c557e07dde5bb6cb791c7a540e0a4796f5e97e', 'hex'),
-        purpose: KeyPurpose.AUTHENTICATION,
-        securityLevel: KeySecurityLevel.MASTER,
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
         readOnly: false,
         disabledAt: 123,
       };
@@ -215,10 +209,10 @@ describe('IdentityPublicKey', () => {
 
       expect(jsonPublicKey).to.deep.equal({
         id: 0,
-        type: KeyType.ECDSA_SECP256K1,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
         data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
-        purpose: KeyPurpose.AUTHENTICATION,
-        securityLevel: KeySecurityLevel.MASTER,
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
         readOnly: false,
       });
     });
@@ -230,10 +224,10 @@ describe('IdentityPublicKey', () => {
 
       expect(jsonPublicKey).to.deep.equal({
         id: 0,
-        type: KeyType.ECDSA_SECP256K1,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
         data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
-        purpose: KeyPurpose.AUTHENTICATION,
-        securityLevel: KeySecurityLevel.MASTER,
+        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
         readOnly: false,
         disabledAt: 42,
       });
@@ -242,7 +236,7 @@ describe('IdentityPublicKey', () => {
 
   describe('#isMaster', () => {
     it('should return true when public key has MASTER security level', () => {
-      publicKey.setSecurityLevel(KeySecurityLevel.MASTER);
+      publicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.MASTER);
 
       const result = publicKey.isMaster();
 
@@ -250,7 +244,7 @@ describe('IdentityPublicKey', () => {
     });
 
     it('should return false when public key doesn\'t have MASTER security level', () => {
-      publicKey.setSecurityLevel(KeySecurityLevel.HIGH);
+      publicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.HIGH);
 
       const result = publicKey.isMaster();
 

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

@@ -1,35 +1,65 @@
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
-
-const stateTransitionTypes = require(
-  '@dashevo/dpp/lib/stateTransition/stateTransitionTypes',
-);
+const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
+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 IdentityCreateTransition = require('@dashevo/dpp/lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
-
-const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-const InstantAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('IdentityCreateTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
+  let IdentityCreateTransition;
+  let InstantAssetLockProof;
+  let KeyType;
+  let KeyPurpose;
+  let KeySecurityLevel;
+  let IdentityPublicKey;
+  let Identifier;
+
+  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, IdentityPublicKey, KeyType, KeyPurpose, KeySecurityLevel,
+      InstantAssetLockProof, Identifier,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(() => {
-    stateTransition = getIdentityCreateTransitionFixture();
-    rawStateTransition = stateTransition.toObject();
+    rawStateTransition = getIdentityCreateTransitionFixture().toObject();
+    stateTransition = new IdentityCreateTransition(
+      rawStateTransition,
+    );
   });
 
   describe('#constructor', () => {
-    it('should create an instance with specified data', () => {
+    it('should create instance with specified data', () => {
       expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
         rawStateTransition.assetLockProof,
       );
 
-      expect(stateTransition.publicKeys).to.deep.equal([
-        new IdentityPublicKey(rawStateTransition.publicKeys[0]),
+      expect(stateTransition.publicKeys.map((key) => key.toObject())).to.deep.equal([
+        new IdentityPublicKey(rawStateTransition.publicKeys[0]).toObject(),
       ]);
     });
+
+    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', () => {
@@ -53,8 +83,8 @@ describe('IdentityCreateTransition', () => {
         new InstantAssetLockProof(rawStateTransition.assetLockProof),
       );
 
-      expect(stateTransition.identityId).to.deep.equal(
-        stateTransition.getAssetLockProof().createIdentifier(),
+      expect(stateTransition.identityId.toBuffer()).to.deep.equal(
+        stateTransition.getAssetLockProof().createIdentifier().toBuffer(),
       );
     });
   });
@@ -69,44 +99,53 @@ describe('IdentityCreateTransition', () => {
 
   describe('#setPublicKeys', () => {
     it('should set public keys', () => {
-      const publicKeys = [new IdentityPublicKey(), new IdentityPublicKey()];
+      const publicKeys = [
+        new IdentityPublicKey(mockRawPublicKey({ id: 0 })),
+        new IdentityPublicKey(mockRawPublicKey({ id: 1 })),
+      ];
 
       stateTransition.setPublicKeys(publicKeys);
 
-      expect(stateTransition.publicKeys).to.have.deep.members(publicKeys);
+      expect(stateTransition.publicKeys.map((key) => key.toObject()))
+        .to.have.deep.members(publicKeys.map((key) => key.toObject()));
     });
   });
 
   describe('#getPublicKeys', () => {
     it('should return set public keys', () => {
-      expect(stateTransition.getPublicKeys()).to.deep.equal(
-        rawStateTransition.publicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      expect(stateTransition.getPublicKeys().map((key) => key.toObject())).to.deep.equal(
+        rawStateTransition.publicKeys
+          .map((rawPublicKey) => new IdentityPublicKey(rawPublicKey).toObject()),
       );
     });
   });
 
   describe('#addPublicKeys', () => {
     it('should add more public keys', () => {
-      const publicKeys = [new IdentityPublicKey(), new IdentityPublicKey()];
+      const publicKeys = [
+        new IdentityPublicKey(mockRawPublicKey({ id: 0 })),
+        new IdentityPublicKey(mockRawPublicKey({ id: 1 })),
+      ];
 
-      stateTransition.publicKeys = [];
+      stateTransition.setPublicKeys([]);
       stateTransition.addPublicKeys(publicKeys);
-      expect(stateTransition.getPublicKeys()).to.have.deep.members(publicKeys);
+      expect(stateTransition.getPublicKeys().map((key) => key.toObject()))
+        .to.have.deep.members(publicKeys.map((key) => key.toObject()));
     });
   });
 
   describe('#getIdentityId', () => {
     it('should return identity id', () => {
-      expect(stateTransition.getIdentityId()).to.deep.equal(
-        stateTransition.getAssetLockProof().createIdentifier(),
+      expect(stateTransition.getIdentityId().toBuffer()).to.deep.equal(
+        stateTransition.getAssetLockProof().createIdentifier().toBuffer(),
       );
     });
   });
 
   describe('#getOwnerId', () => {
     it('should return owner id', () => {
-      expect(stateTransition.getOwnerId()).to.equal(
-        stateTransition.getIdentityId(),
+      expect(stateTransition.getOwnerId().toBuffer()).to.deep.equal(
+        stateTransition.getIdentityId().toBuffer(),
       );
     });
   });
@@ -158,8 +197,8 @@ describe('IdentityCreateTransition', () => {
       const identityId = result[0];
 
       expect(identityId).to.be.an.instanceOf(Identifier);
-      expect(identityId).to.be.deep.equal(
-        new IdentityCreateTransition(rawStateTransition).getIdentityId(),
+      expect(identityId.toBuffer()).to.be.deep.equal(
+        new IdentityCreateTransition(rawStateTransition).getIdentityId().toBuffer(),
       );
     });
   });