@dashevo/wasm-dpp 0.23.0-dev.15 → 0.24.0-dev.11

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

@@ -1,32 +1,42 @@
-const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+const JSIdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const JSIdentity = require('@dashevo/dpp/lib/identity/Identity');
 
-const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
-const Metadata = require('../../../lib/Metadata');
-const protocolVersion = require('../../../lib/version/protocolVersion');
-
-const Identity = require('../../../lib/identity/Identity');
-const serializer = require('../../../lib/util/serializer');
-const hash = require('../../../lib/util/hash');
+const { hash: hashFunction } = require('@dashevo/dpp/lib/util/hash');
+const { expect } = require('chai');
+const generateRandomIdentifierAsync = require('../../../lib/test/utils/generateRandomIdentifierAsync');
+const { default: loadWasmDpp } = require('../../../dist');
 
 describe('Identity', () => {
   let rawIdentity;
   let identity;
-  let hashMock;
-  let encodeMock;
   let metadataFixture;
+  let Identity;
+  let Metadata;
+  let IdentityPublicKey;
+  let KeyPurpose;
+  let KeyType;
+  let KeySecurityLevel;
+
+  before(async () => {
+    ({
+      Identity, Metadata, IdentityPublicKey, KeyPurpose, KeyType, KeySecurityLevel,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
+  beforeEach(async () => {
     rawIdentity = {
       protocolVersion: protocolVersion.latestVersion,
-      id: generateRandomIdentifier(),
+      id: await generateRandomIdentifierAsync(),
       publicKeys: [
         {
           id: 0,
-          type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+          type: KeyType.ECDSA_SECP256K1,
           data: Buffer.alloc(36).fill('a'),
-          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-          securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+          purpose: KeyPurpose.AUTHENTICATION,
+          securityLevel: KeySecurityLevel.MASTER,
           readOnly: false,
+          signature: Buffer.alloc(36).fill('a'),
         },
       ],
       balance: 0,
@@ -39,45 +49,62 @@ describe('Identity', () => {
 
     identity.setMetadata(metadataFixture);
 
-    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
-    hashMock = this.sinonSandbox.stub(hash, 'hash');
+    metadataFixture = new Metadata(42, 0);
   });
 
   afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
   });
 
   describe('#constructor', () => {
     it('should set variables from raw model', () => {
-      const instance = new Identity(rawIdentity);
+      const instance = identity;
 
-      expect(instance.id).to.deep.equal(rawIdentity.id);
-      expect(instance.type).to.equal(rawIdentity.type);
-      expect(instance.publicKeys).to.deep.equal(
-        rawIdentity.publicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      expect(instance.getId().toBuffer()).to.deep.equal(rawIdentity.id.toBuffer());
+      expect(
+        instance.getPublicKeys().map((pk) => pk.toObject()),
+      ).to.deep.equal(
+        rawIdentity.publicKeys,
       );
     });
   });
 
   describe('#getId', () => {
     it('should return set id', () => {
-      expect(identity.getId()).to.deep.equal(rawIdentity.id);
+      expect(identity.getId().toBuffer()).to.deep.equal(rawIdentity.id.toBuffer());
     });
   });
 
   describe('#getPublicKeys', () => {
     it('should return set public keys', () => {
-      expect(identity.getPublicKeys()).to.deep.equal(
-        rawIdentity.publicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      expect(identity.getPublicKeys().map((pk) => pk.toObject())).to.deep.equal(
+        rawIdentity.publicKeys,
       );
     });
   });
 
   describe('#setPublicKeys', () => {
+    it('should reject input which is not array of public keys', () => {
+      expect(() => { identity.setPublicKeys(42); })
+        .throws("Setting public keys failed. The input ('42') is invalid. You must use array of PublicKeys");
+      expect(identity.getPublicKeys()).length(1);
+    });
+
     it('should set public keys', () => {
-      identity.setPublicKeys(42);
-      expect(identity.publicKeys).to.equal(42);
+      const rawKey = {
+        id: 2,
+        type: KeyType.ECDSA_SECP256K1,
+        data: Buffer.alloc(36).fill('a'),
+        purpose: KeyPurpose.AUTHENTICATION,
+        securityLevel: KeySecurityLevel.MASTER,
+        signature: Buffer.alloc(36).fill('a'),
+        readOnly: false,
+      };
+
+      const ipk = new JSIdentityPublicKey(rawKey);
+
+      identity.setPublicKeys([ipk]);
+      expect(identity.getPublicKeys()).length(1);
+      expect(identity.getPublicKeys()[0].toObject()).to.be.deep.equal(rawKey);
     });
   });
 
@@ -85,7 +112,11 @@ describe('Identity', () => {
     it('should return a public key for a given id', () => {
       const key = identity.getPublicKeyById(0);
 
-      expect(key).to.be.deep.equal(new IdentityPublicKey(rawIdentity.publicKeys[0]));
+      expect(
+        key.toObject(),
+      ).to.be.deep.equal(
+        rawIdentity.publicKeys[0],
+      );
     });
 
     it("should return undefined if there's no key with such id", () => {
@@ -95,30 +126,20 @@ describe('Identity', () => {
   });
 
   describe('#toBuffer', () => {
-    it('should return serialized Identity', () => {
-      const encodeMockData = Buffer.from('42');
-      encodeMock.returns(encodeMockData); // for example
-
+    it('should return the same buffer as JS Identity', () => {
+      // Due to browser polyfill, we got two different versions of buffers, and makes
+      // the compatibility test to fail in karma, so hence this hack here.
+      rawIdentity.id = Buffer.from(rawIdentity.id.toBuffer());
+      const oldIdentity = new JSIdentity(rawIdentity);
       const result = identity.toBuffer();
 
-      const identityDataToEncode = identity.toObject();
-      delete identityDataToEncode.protocolVersion;
-
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(identity.getProtocolVersion(), 0);
-
-      expect(encodeMock).to.have.been.calledOnceWith(identityDataToEncode);
-      expect(result).to.deep.equal(Buffer.concat([protocolVersionUInt32, encodeMockData]));
+      expect(result).to.deep.eq(oldIdentity.toBuffer());
     });
   });
 
   describe('#hash', () => {
-    it('should return hex string of a buffer return by serialize', () => {
-      const buffer = Buffer.from('someString');
-
-      encodeMock.returns(buffer);
-      hashMock.returns(buffer);
-
+    it('should return the same has as JS Identity', () => {
+      const expectedHash = hashFunction(identity.toBuffer());
       const result = identity.hash();
 
       const identityDataToEncode = identity.toObject();
@@ -127,15 +148,18 @@ describe('Identity', () => {
       const protocolVersionUInt32 = Buffer.alloc(4);
       protocolVersionUInt32.writeUInt32LE(identity.getProtocolVersion(), 0);
 
-      expect(encodeMock).to.have.been.calledOnceWith(identityDataToEncode);
-      expect(hashMock).to.have.been.calledOnceWith(Buffer.concat([protocolVersionUInt32, buffer]));
-      expect(result).to.equal(buffer);
+      expect(result).to.deep.equal(expectedHash);
     });
   });
 
   describe('#toObject', () => {
     it('should return plain object representation', () => {
-      expect(identity.toObject()).to.deep.equal(rawIdentity);
+      const identityObject = identity.toObject();
+
+      // We can't compare Identifier directly - it needs to be converted into a Buffer
+      rawIdentity.id = rawIdentity.id.toBuffer();
+
+      expect(identityObject).to.deep.equal(rawIdentity);
     });
   });
 
@@ -149,10 +173,11 @@ describe('Identity', () => {
         publicKeys: [
           {
             id: 0,
-            type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+            type: KeyType.ECDSA_SECP256K1,
             data: rawIdentity.publicKeys[0].data.toString('base64'),
-            purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-            securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+            purpose: KeyPurpose.AUTHENTICATION,
+            securityLevel: KeySecurityLevel.MASTER,
+            signature: rawIdentity.publicKeys[0].signature.toString('base64'),
             readOnly: false,
           },
         ],
@@ -164,7 +189,7 @@ describe('Identity', () => {
 
   describe('#getBalance', () => {
     it('should return set identity balance', () => {
-      identity.balance = 42;
+      identity.setBalance(42);
       expect(identity.getBalance()).to.equal(42);
     });
   });
@@ -172,7 +197,7 @@ describe('Identity', () => {
   describe('#setBalance', () => {
     it('should set identity balance', () => {
       identity.setBalance(42);
-      expect(identity.balance).to.equal(42);
+      expect(identity.getBalance()).to.equal(42);
     });
   });
 
@@ -181,54 +206,57 @@ describe('Identity', () => {
       const result = identity.increaseBalance(42);
 
       expect(result).to.equal(42);
-      expect(identity.balance).to.equal(42);
+      expect(identity.getBalance()).to.equal(42);
     });
   });
 
   describe('#reduceBalance', () => {
     it('should reduce identity balance', () => {
-      identity.balance = 42;
+      identity.setBalance(42);
 
       const result = identity.reduceBalance(2);
 
       expect(result).to.equal(40);
-      expect(identity.balance).to.equal(40);
+      expect(identity.getBalance()).to.equal(40);
     });
   });
 
   describe('#setMetadata', () => {
     it('should set metadata', () => {
       const otherMetadata = new Metadata(43, 1);
+      const expectedMetadata = new Metadata(43, 1);
 
       identity.setMetadata(otherMetadata);
 
-      expect(identity.metadata).to.deep.equal(otherMetadata);
+      expect(identity.getMetadata().toObject()).to.deep.equal(expectedMetadata.toObject());
     });
   });
 
   describe('#getMetadata', () => {
     it('should get metadata', () => {
-      expect(identity.getMetadata()).to.deep.equal(metadataFixture);
+      expect(identity.getMetadata().toObject()).to.deep.equal(metadataFixture.toObject());
     });
   });
 
   describe('#getPublicKeyMaxId', () => {
     it('should get the biggest public key ID', () => {
-      identity.publicKeys.push(
+      identity.addPublicKeys(
         new IdentityPublicKey({
           id: 99,
-          type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+          type: KeyType.ECDSA_SECP256K1,
           data: Buffer.alloc(36).fill('a'),
-          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-          securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+          purpose: KeyPurpose.AUTHENTICATION,
+          securityLevel: KeySecurityLevel.MASTER,
+          signature: Buffer.alloc(36).fill('a'),
           readOnly: false,
         }),
         new IdentityPublicKey({
           id: 50,
-          type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+          type: KeyType.ECDSA_SECP256K1,
           data: Buffer.alloc(36).fill('a'),
-          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-          securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+          purpose: KeyPurpose.AUTHENTICATION,
+          securityLevel: KeySecurityLevel.MASTER,
+          signature: Buffer.alloc(36).fill('a'),
           readOnly: false,
         }),
       );
@@ -237,6 +265,7 @@ describe('Identity', () => {
 
       const publicKeyIds = identity.getPublicKeys().map((publicKey) => publicKey.getId());
 
+      expect(Math.max(...publicKeyIds)).to.equal(99);
       expect(Math.max(...publicKeyIds)).to.equal(maxId);
     });
   });

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

@@ -1,24 +1,24 @@
 const { PublicKey } = require('@dashevo/dashcore-lib');
-const Identity = require('../../../lib/identity/Identity');
-const IdentityCreateTransition = require('../../../lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
-const IdentityTopUpTransition = require('../../../lib/identity/stateTransition/IdentityTopUpTransition/IdentityTopUpTransition');
+const Identity = require('@dashevo/dpp/lib/identity/Identity');
+const IdentityCreateTransition = require('@dashevo/dpp/lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
+const IdentityTopUpTransition = require('@dashevo/dpp/lib/identity/stateTransition/IdentityTopUpTransition/IdentityTopUpTransition');
 
-const getIdentityFixture = require('../../../lib/test/fixtures/getIdentityFixture');
+const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 
-const ValidationResult = require('../../../lib/validation/ValidationResult');
-const SerializedObjectParsingError = require('../../../lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
+const SerializedObjectParsingError = require('@dashevo/dpp/lib/errors/consensus/basic/decode/SerializedObjectParsingError');
 
 const InvalidIdentityError = require(
-  '../../../lib/identity/errors/InvalidIdentityError',
+  '@dashevo/dpp/lib/identity/errors/InvalidIdentityError',
 );
-const getInstantAssetLockProofFixture = require('../../../lib/test/fixtures/getInstantAssetLockProofFixture');
-const InstantAssetLockProof = require('../../../lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
-const getChainAssetLockProofFixture = require('../../../lib/test/fixtures/getChainAssetLockProofFixture');
-const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
-const SomeConsensusError = require('../../../lib/test/mocks/SomeConsensusError');
-const IdentityFactory = require('../../../lib/identity/IdentityFactory');
-const IdentityUpdateTransition = require('../../../lib/identity/stateTransition/IdentityUpdateTransition/IdentityUpdateTransition');
-const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
+const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
+const InstantAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const getChainAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
+const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
+const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
+const IdentityFactory = require('@dashevo/dpp/lib/identity/IdentityFactory');
+const IdentityUpdateTransition = require('@dashevo/dpp/lib/identity/stateTransition/IdentityUpdateTransition/IdentityUpdateTransition');
+const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
 
 describe('IdentityFactory', () => {
   let factory;

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

@@ -1,17 +1,24 @@
-const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
-const EmptyPublicKeyDataError = require('../../../lib/identity/errors/EmptyPublicKeyDataError');
+const { default: loadWasmDpp } = require('@dashevo/wasm-dpp');
 
 describe('IdentityPublicKey', () => {
   let rawPublicKey;
   let publicKey;
+  let IdentityPublicKey;
+  let KeyPurpose;
+  let KeyType;
+  let KeySecurityLevel;
+
+  beforeEach(async () => {
+    ({
+      IdentityPublicKey, KeyPurpose, KeyType, KeySecurityLevel,
+    } = await loadWasmDpp());
 
-  beforeEach(() => {
     rawPublicKey = {
       id: 0,
-      type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+      type: KeyType.ECDSA_SECP256K1,
       data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
-      purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-      securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+      purpose: KeyPurpose.AUTHENTICATION,
+      securityLevel: KeySecurityLevel.MASTER,
       readOnly: false,
     };
 
@@ -19,20 +26,12 @@ describe('IdentityPublicKey', () => {
   });
 
   describe('#constructor', () => {
-    it('should not set anything if nothing passed', () => {
-      const instance = new IdentityPublicKey();
-
-      expect(instance.id).to.be.undefined();
-      expect(instance.type).to.be.undefined();
-      expect(instance.data).to.be.undefined();
-    });
-
     it('should set variables from raw model', () => {
       const instance = new IdentityPublicKey(rawPublicKey);
 
-      expect(instance.id).to.equal(rawPublicKey.id);
-      expect(instance.type).to.equal(rawPublicKey.type);
-      expect(instance.data).to.equal(rawPublicKey.data);
+      expect(instance.getId()).to.equal(rawPublicKey.id);
+      expect(instance.getType()).to.equal(rawPublicKey.type);
+      expect(instance.getData()).to.deep.equal(rawPublicKey.data);
     });
   });
 
@@ -46,29 +45,29 @@ describe('IdentityPublicKey', () => {
     it('should set id', () => {
       publicKey.setId(42);
 
-      expect(publicKey.id).to.equal(42);
+      expect(publicKey.getId()).to.equal(42);
     });
   });
 
   describe('#getType', () => {
     it('should return set type', () => {
-      publicKey.type = 42;
+      publicKey.setType(3);
 
-      expect(publicKey.getType()).to.equal(42);
+      expect(publicKey.getType()).to.equal(3);
     });
   });
 
   describe('#setType', () => {
     it('should set type', () => {
-      publicKey.setType(42);
+      publicKey.setType(3);
 
-      expect(publicKey.type).to.equal(42);
+      expect(publicKey.getType()).to.equal(3);
     });
   });
 
   describe('#getData', () => {
     it('should return set data', () => {
-      expect(publicKey.getData()).to.equal(rawPublicKey.data);
+      expect(publicKey.getData()).to.be.deep.equal(rawPublicKey.data);
     });
   });
 
@@ -78,7 +77,7 @@ describe('IdentityPublicKey', () => {
 
       publicKey.setData(buffer);
 
-      expect(publicKey.data).to.equal(buffer);
+      expect(publicKey.getData()).to.be.deep.equal(buffer);
     });
   });
 
@@ -90,9 +89,9 @@ describe('IdentityPublicKey', () => {
 
   describe('#setPurpose', () => {
     it('should set data', () => {
-      publicKey.setPurpose(IdentityPublicKey.PURPOSES.DECRYPTION);
+      publicKey.setPurpose(KeyPurpose.DECRYPTION);
 
-      expect(publicKey.purpose).to.equal(IdentityPublicKey.PURPOSES.DECRYPTION);
+      expect(publicKey.getPurpose()).to.equal(KeyPurpose.DECRYPTION);
     });
   });
 
@@ -104,9 +103,9 @@ describe('IdentityPublicKey', () => {
 
   describe('#setSecurityLevel', () => {
     it('should set data', () => {
-      publicKey.setSecurityLevel(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
+      publicKey.setSecurityLevel(KeySecurityLevel.MEDIUM);
 
-      expect(publicKey.securityLevel).to.equal(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
+      expect(publicKey.getSecurityLevel()).to.equal(KeySecurityLevel.MEDIUM);
     });
   });
 
@@ -120,7 +119,7 @@ describe('IdentityPublicKey', () => {
     it('should set readOnly', () => {
       publicKey.setReadOnly(true);
 
-      expect(publicKey.readOnly).to.equal(true);
+      expect(publicKey.isReadOnly()).to.equal(true);
     });
   });
 
@@ -128,13 +127,13 @@ describe('IdentityPublicKey', () => {
     it('should set disabledAt', () => {
       publicKey.setDisabledAt(123);
 
-      expect(publicKey.disabledAt).to.equal(123);
+      expect(publicKey.getDisabledAt()).to.equal(123);
     });
   });
 
   describe('#getDisabledAt', () => {
     it('should return disabledAt', () => {
-      publicKey.disabledAt = 42;
+      publicKey.setDisabledAt(42);
 
       expect(publicKey.getDisabledAt()).to.equal(42);
     });
@@ -152,10 +151,12 @@ describe('IdentityPublicKey', () => {
     it('should return data in case ECDSA_HASH160', () => {
       rawPublicKey = {
         id: 0,
-        type: IdentityPublicKey.TYPES.ECDSA_HASH160,
+        type: KeyType.ECDSA_HASH160,
         data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        purpose: KeyPurpose.AUTHENTICATION,
+        securityLevel: KeySecurityLevel.MASTER,
+        readOnly: false,
+        disabledAt: 123,
       };
 
       publicKey = new IdentityPublicKey(rawPublicKey);
@@ -170,10 +171,12 @@ describe('IdentityPublicKey', () => {
     it('should return original public key hash in case BLS12_381', () => {
       rawPublicKey = {
         id: 0,
-        type: IdentityPublicKey.TYPES.BLS12_381,
+        type: KeyType.BLS12_381,
         data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        purpose: KeyPurpose.AUTHENTICATION,
+        securityLevel: KeySecurityLevel.MASTER,
+        readOnly: false,
+        disabledAt: 123,
       };
 
       publicKey = new IdentityPublicKey(rawPublicKey);
@@ -188,10 +191,12 @@ describe('IdentityPublicKey', () => {
     it('should return data in case BIP13_SCRIPT_HASH', () => {
       rawPublicKey = {
         id: 0,
-        type: IdentityPublicKey.TYPES.BIP13_SCRIPT_HASH,
+        type: KeyType.BIP13_SCRIPT_HASH,
         data: Buffer.from('54c557e07dde5bb6cb791c7a540e0a4796f5e97e', 'hex'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        purpose: KeyPurpose.AUTHENTICATION,
+        securityLevel: KeySecurityLevel.MASTER,
+        readOnly: false,
+        disabledAt: 123,
       };
 
       publicKey = new IdentityPublicKey(rawPublicKey);
@@ -202,24 +207,6 @@ describe('IdentityPublicKey', () => {
 
       expect(result).to.deep.equal(expectedHash);
     });
-
-    it('should throw invalid argument error if data was not originally provided', async () => {
-      publicKey = new IdentityPublicKey({
-        id: 0,
-        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-      });
-
-      try {
-        publicKey.hash();
-
-        expect.fail('Error was not thrown');
-      } catch (e) {
-        expect(e).to.be.an.instanceOf(EmptyPublicKeyDataError);
-        expect(e.message).to.equal(
-          'Public key data is not set',
-        );
-      }
-    });
   });
 
   describe('#toJSON', () => {
@@ -228,10 +215,10 @@ describe('IdentityPublicKey', () => {
 
       expect(jsonPublicKey).to.deep.equal({
         id: 0,
-        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        type: KeyType.ECDSA_SECP256K1,
         data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        purpose: KeyPurpose.AUTHENTICATION,
+        securityLevel: KeySecurityLevel.MASTER,
         readOnly: false,
       });
     });
@@ -243,10 +230,10 @@ describe('IdentityPublicKey', () => {
 
       expect(jsonPublicKey).to.deep.equal({
         id: 0,
-        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        type: KeyType.ECDSA_SECP256K1,
         data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+        purpose: KeyPurpose.AUTHENTICATION,
+        securityLevel: KeySecurityLevel.MASTER,
         readOnly: false,
         disabledAt: 42,
       });
@@ -255,7 +242,7 @@ describe('IdentityPublicKey', () => {
 
   describe('#isMaster', () => {
     it('should return true when public key has MASTER security level', () => {
-      publicKey.securityLevel = IdentityPublicKey.SECURITY_LEVELS.MASTER;
+      publicKey.setSecurityLevel(KeySecurityLevel.MASTER);
 
       const result = publicKey.isMaster();
 
@@ -263,7 +250,7 @@ describe('IdentityPublicKey', () => {
     });
 
     it('should return false when public key doesn\'t have MASTER security level', () => {
-      publicKey.securityLevel = IdentityPublicKey.SECURITY_LEVELS.HIGH;
+      publicKey.setSecurityLevel(KeySecurityLevel.HIGH);
 
       const result = publicKey.isMaster();
 

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

@@ -2,7 +2,7 @@ const {
   convertSatoshiToCredits,
   convertCreditsToSatoshi,
   RATIO,
-} = require('../../../lib/identity/creditsConverter');
+} = require('@dashevo/dpp/lib/identity/creditsConverter');
 
 describe('creditsConverter', () => {
   describe('convertSatoshiToCredits', () => {

package/test/unit/identity/errors/InvalidIdentityError.spec.js

@@ -1,5 +1,5 @@
-const InvalidIdentityError = require('../../../../lib/identity/errors/InvalidIdentityError');
-const getIdentityFixture = require('../../../../lib/test/fixtures/getIdentityFixture');
+const InvalidIdentityError = require('@dashevo/dpp/lib/identity/errors/InvalidIdentityError');
+const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 
 describe('InvalidIdentityError', () => {
   let rawIdentity;

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

@@ -1,15 +1,15 @@
-const IdentityPublicKey = require('../../../../../lib/identity/IdentityPublicKey');
+const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
 
 const stateTransitionTypes = require(
-  '../../../../../lib/stateTransition/stateTransitionTypes',
+  '@dashevo/dpp/lib/stateTransition/stateTransitionTypes',
 );
 
-const protocolVersion = require('../../../../../lib/version/protocolVersion');
-const IdentityCreateTransition = require('../../../../../lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
-const Identifier = require('../../../../../lib/identifier/Identifier');
+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('../../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
-const InstantAssetLockProof = require('../../../../../lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
+const InstantAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
 
 describe('IdentityCreateTransition', () => {
   let rawStateTransition;