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

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

@@ -1,49 +1,26 @@
-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');
-
 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');
+const {
+  Identity, Metadata, IdentityPublicKey, KeyPurpose, KeyType, KeySecurityLevel,
+  Identifier,
+} = require('../../..');
 
 describe('Identity', () => {
   let rawIdentity;
   let identity;
   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(async () => {
-    rawIdentity = {
-      protocolVersion: protocolVersion.latestVersion,
-      id: await generateRandomIdentifierAsync(),
-      publicKeys: [
-        {
-          id: 0,
-          type: KeyType.ECDSA_SECP256K1,
-          data: Buffer.alloc(36).fill('a'),
-          purpose: KeyPurpose.AUTHENTICATION,
-          securityLevel: KeySecurityLevel.MASTER,
-          readOnly: false,
-        },
-      ],
-      balance: 0,
-      revision: 0,
-    };
-
-    identity = new Identity(rawIdentity);
+    identity = new Identity(1);
+    identity.setId(await generateRandomIdentifierAsync());
+
+    const publicKey = new IdentityPublicKey(1);
+    publicKey.setData(Buffer.alloc(36).fill('a'));
+
+    identity.setPublicKeys([publicKey]);
+
+    rawIdentity = identity.toObject();
 
     metadataFixture = new Metadata({
       blockHeight: 42,
@@ -62,14 +39,11 @@ describe('Identity', () => {
     });
   });
 
-  afterEach(() => {
-  });
-
   describe('#constructor', () => {
     it('should set variables from raw model', () => {
       const instance = identity;
 
-      expect(instance.getId().toBuffer()).to.deep.equal(rawIdentity.id.toBuffer());
+      expect(instance.getId()).to.deep.equal(rawIdentity.id);
       expect(
         instance.getPublicKeys().map((pk) => pk.toObject()),
       ).to.deep.equal(
@@ -80,7 +54,7 @@ describe('Identity', () => {
 
   describe('#getId', () => {
     it('should return set id', () => {
-      expect(identity.getId().toBuffer()).to.deep.equal(rawIdentity.id.toBuffer());
+      expect(identity.getId()).to.deep.equal(rawIdentity.id);
     });
   });
 
@@ -101,15 +75,20 @@ describe('Identity', () => {
 
     it('should set public keys', () => {
       const rawKey = {
+        $version: '0',
         id: 2,
         type: KeyType.ECDSA_SECP256K1,
         data: Buffer.alloc(36).fill('a'),
         purpose: KeyPurpose.AUTHENTICATION,
         securityLevel: KeySecurityLevel.MASTER,
         readOnly: false,
+        disabledAt: null,
+        contractBounds: null,
       };
 
-      const ipk = new JSIdentityPublicKey(rawKey);
+      const ipk = new IdentityPublicKey(1);
+      ipk.setData(Buffer.alloc(36).fill('a'));
+      ipk.setId(2);
 
       identity.setPublicKeys([ipk]);
       expect(identity.getPublicKeys()).length(1);
@@ -135,14 +114,19 @@ describe('Identity', () => {
   });
 
   describe('#toBuffer', () => {
-    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);
+    it('should return buffer', () => {
       const result = identity.toBuffer();
+      expect(result).to.be.instanceOf(Buffer);
+      expect(result).to.have.length(82);
+    });
+  });
 
-      expect(result).to.deep.eq(oldIdentity.toBuffer());
+  describe('#fromBuffer', () => {
+    it('should re-create identity from buffer', () => {
+      const buffer = identity.toBuffer();
+      const recoveredIdentity = Identity.fromBuffer(buffer);
+      expect(recoveredIdentity.toObject())
+        .to.be.deep.equal(identity.toObject());
     });
   });
 
@@ -150,12 +134,6 @@ describe('Identity', () => {
     it('should return the same has as JS Identity', () => {
       const expectedHash = hashFunction(identity.toBuffer());
       const result = identity.hash();
-
-      const identityDataToEncode = identity.toObject();
-      delete identityDataToEncode.protocolVersion;
-
-      varint.encode(identity.getProtocolVersion());
-
       expect(result).to.deep.equal(expectedHash);
     });
   });
@@ -163,10 +141,6 @@ describe('Identity', () => {
   describe('#toObject', () => {
     it('should return plain object representation', () => {
       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);
     });
   });
@@ -176,16 +150,19 @@ describe('Identity', () => {
       const jsonIdentity = identity.toJSON();
 
       expect(jsonIdentity).to.deep.equal({
-        protocolVersion: protocolVersion.latestVersion,
-        id: rawIdentity.id.toString(),
+        $version: '0',
+        id: Identifier.from(rawIdentity.id).toString(),
         publicKeys: [
           {
+            $version: '0',
             id: 0,
             type: KeyType.ECDSA_SECP256K1,
             data: rawIdentity.publicKeys[0].data.toString('base64'),
             purpose: KeyPurpose.AUTHENTICATION,
             securityLevel: KeySecurityLevel.MASTER,
             readOnly: false,
+            disabledAt: null,
+            contractBounds: null,
           },
         ],
         balance: 0,
@@ -257,27 +234,15 @@ describe('Identity', () => {
 
   describe('#getPublicKeyMaxId', () => {
     it('should get the biggest public key ID', () => {
-      const key = new IdentityPublicKey({
-        id: 99,
-        type: KeyType.ECDSA_SECP256K1,
-        data: Buffer.alloc(36).fill('a'),
-        purpose: KeyPurpose.AUTHENTICATION,
-        securityLevel: KeySecurityLevel.MASTER,
-        signature: Buffer.alloc(36).fill('a'),
-        readOnly: false,
-      });
-      identity.addPublicKeys(
-        key,
-        new IdentityPublicKey({
-          id: 50,
-          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 key1 = new IdentityPublicKey(1);
+      key1.setId(99);
+      key1.setData(Buffer.alloc(36).fill('a'));
+
+      const key2 = new IdentityPublicKey(1);
+      key2.setId(50);
+      key2.setData(Buffer.alloc(36).fill('a'));
+
+      identity.addPublicKeys([key1, key2]);
 
       const maxId = identity.getPublicKeyMaxId();
 

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

@@ -1,9 +1,13 @@
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
-const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
+const getInstantAssetLockProofFixture = require('../../../lib/test/fixtures/getInstantAssetLockProofFixture');
+const getIdentityFixture = require('../../../lib/test/fixtures/getIdentityFixture');
 const getChainAssetLockProofFixture = require('../../../lib/test/fixtures/getChainAssetLockProofFixture');
-const { default: loadWasmDpp } = require('../../../dist');
-const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
+const {
+  Identity, IdentityFactory,
+  InstantAssetLockProof, ChainAssetLockProof, IdentityUpdateTransition,
+  IdentityCreateTransition, IdentityTopUpTransition, IdentityPublicKeyWithWitness,
+  InvalidIdentityError, UnsupportedProtocolVersionError,
+} = require('../../..');
+const { SerializedObjectParsingError } = require('../../..');
 
 describe('IdentityFactory', () => {
   let factory;
@@ -12,48 +16,17 @@ describe('IdentityFactory', () => {
   let chainAssetLockProof;
   let fakeTime;
 
-  let Identity;
-  let IdentityFactory;
-  let IdentityValidator;
-  let InstantAssetLockProof;
-  let IdentityCreateTransition;
-  let IdentityTopUpTransition;
-  let IdentityUpdateTransition;
-  let IdentityPublicKeyWithWitness;
-  let InvalidIdentityError;
-  let PlatformValueError;
-  let UnsupportedProtocolVersionError;
-  let ChainAssetLockProof;
-
-  before(async () => {
-    ({
-      Identity, IdentityFactory, IdentityValidator,
-      InstantAssetLockProof, ChainAssetLockProof, IdentityUpdateTransition,
-      IdentityCreateTransition, IdentityTopUpTransition, IdentityPublicKeyWithWitness,
-      InvalidIdentityError, UnsupportedProtocolVersionError, PlatformValueError,
-    } = await loadWasmDpp());
-  });
-
-  beforeEach(async function () {
-    const instantAssetLockProofJS = getInstantAssetLockProofFixture();
-    const chainAssetLockProofJS = getChainAssetLockProofFixture();
-    instantAssetLockProof = new InstantAssetLockProof(instantAssetLockProofJS.toObject());
-    chainAssetLockProof = new ChainAssetLockProof(chainAssetLockProofJS.toObject());
-
-    const blsAdapter = await getBlsAdapterMock();
+  beforeEach(async function beforeEach() {
+    instantAssetLockProof = await getInstantAssetLockProofFixture();
+    chainAssetLockProof = new ChainAssetLockProof(getChainAssetLockProofFixture().toObject());
 
-    const identityValidator = new IdentityValidator(blsAdapter);
+    // const blsAdapter = await getBlsAdapterMock();
 
-    factory = new IdentityFactory(
-      1,
-      identityValidator,
-    );
+    // const identityValidator = new IdentityValidator(blsAdapter);
 
-    const identityObject = getIdentityFixture().toObject();
-    identityObject.id = instantAssetLockProof.createIdentifier();
+    factory = new IdentityFactory(1);
 
-    identity = new Identity(identityObject);
-    identity.setAssetLockProof(instantAssetLockProof);
+    identity = await getIdentityFixture(instantAssetLockProof.createIdentifier());
     identity.setBalance(0);
 
     fakeTime = this.sinonSandbox.useFakeTimers(new Date());
@@ -65,15 +38,12 @@ describe('IdentityFactory', () => {
 
   describe('#create', () => {
     it('should create Identity from asset lock transaction, output index, proof and public keys', () => {
-      const publicKeys = identity
-        .getPublicKeys()
-        .map((identityPublicKey) => ({
-          ...identityPublicKey.toObject(),
-          readonly: true,
-        }));
+      const publicKeys = identity.getPublicKeys();
+      publicKeys.forEach((key) => key.setReadOnly(true));
+      identity.setPublicKeys(publicKeys);
 
       const result = factory.create(
-        instantAssetLockProof,
+        instantAssetLockProof.createIdentifier(),
         publicKeys,
       );
 
@@ -82,7 +52,8 @@ describe('IdentityFactory', () => {
     });
   });
 
-  describe('#createFromObject', () => {
+  // TODO(versioning): re-check. Not used anymore
+  describe.skip('#createFromObject', () => {
     it('should skip validation if options is set', () => {
       const identityObject = identity.toObject();
       identityObject.protocolVersion = 100;
@@ -90,7 +61,8 @@ describe('IdentityFactory', () => {
       expect(result).to.exist();
     });
 
-    it('should throw an error if validation have failed', () => {
+    // TODO(versioning): restore
+    it.skip('should throw an error if validation have failed', () => {
       const identityObject = identity.toObject();
       identityObject.protocolVersion = 3;
 
@@ -127,7 +99,8 @@ describe('IdentityFactory', () => {
       expect(result.toObject()).to.deep.equal(rawIdentity);
     });
 
-    it('should throw InvalidIdentityError if the decoding fails with consensus error', () => {
+    // TODO(versioning): restore
+    it.skip('should throw InvalidIdentityError if the decoding fails with consensus error', () => {
       try {
         // Mess up protocol version
         serializedIdentity[0] = 3;
@@ -142,14 +115,15 @@ describe('IdentityFactory', () => {
       }
     });
 
-    it('should throw an error if decoding fails with any other error', () => {
+    // TODO(versioning): restore
+    it.skip('should throw an error if decoding fails with any other error', () => {
       try {
         serializedIdentity = serializedIdentity.slice(4);
         factory.createFromBuffer(serializedIdentity);
 
         expect.fail('should throw an error');
       } catch (e) {
-        expect(e).to.be.instanceOf(PlatformValueError);
+        expect(e).to.be.instanceOf(SerializedObjectParsingError);
       }
     });
   });
@@ -173,7 +147,11 @@ describe('IdentityFactory', () => {
 
   describe('#createIdentityCreateTransition', () => {
     it('should create IdentityCreateTransition from Identity model', () => {
-      const stateTransition = factory.createIdentityCreateTransition(identity);
+      const stateTransition = factory.createIdentityCreateTransition(
+        identity,
+        instantAssetLockProof,
+        1,
+      );
 
       expect(stateTransition).to.be.instanceOf(IdentityCreateTransition);
       const keysToExpect = stateTransition.getPublicKeys()
@@ -183,22 +161,29 @@ describe('IdentityFactory', () => {
           return keyObject;
         });
 
+      const actualKeys = identity.getPublicKeys().map((key) => {
+        const keyObject = key.toObject();
+        delete keyObject.disabledAt;
+        return keyObject;
+      });
+
       expect(keysToExpect)
-        .to.deep.equal(identity.getPublicKeys().map((key) => key.toObject()));
+        .to.deep.equal(actualKeys);
       expect(stateTransition.getAssetLockProof().toObject())
         .to.deep.equal(instantAssetLockProof.toObject());
     });
   });
 
   describe('createChainAssetLockProof', () => {
-    it('should create IdentityCreateTransition from Identity model', () => {
-      const identityObject = getIdentityFixture().toObject();
-      identityObject.id = chainAssetLockProof.createIdentifier();
-      identity = new Identity(identityObject);
-      identity.setAssetLockProof(chainAssetLockProof);
+    it('should create IdentityCreateTransition from Identity model', async () => {
+      identity = await getIdentityFixture(chainAssetLockProof.createIdentifier());
       identity.setBalance(0);
 
-      const stateTransition = factory.createIdentityCreateTransition(identity);
+      const stateTransition = factory.createIdentityCreateTransition(
+        identity,
+        chainAssetLockProof,
+        1,
+      );
 
       expect(stateTransition).to.be.instanceOf(IdentityCreateTransition);
       const keysToExpect = stateTransition.getPublicKeys()
@@ -208,8 +193,14 @@ describe('IdentityFactory', () => {
           return keyObject;
         });
 
+      const actualKeys = identity.getPublicKeys().map((key) => {
+        const keyObject = key.toObject();
+        delete keyObject.disabledAt;
+        return keyObject;
+      });
+
       expect(keysToExpect)
-        .to.deep.equal(identity.getPublicKeys().map((key) => key.toObject()));
+        .to.deep.equal(actualKeys);
 
       expect(stateTransition.getAssetLockProof().toObject())
         .to.deep.equal(chainAssetLockProof.toObject());
@@ -235,15 +226,10 @@ describe('IdentityFactory', () => {
     it('should create IdentityUpdateTransition', () => {
       const revision = 1;
       const disablePublicKeys = [identity.getPublicKeyById(0)];
-      const addPublicKeys = [new IdentityPublicKeyWithWitness({
-        id: 0,
-        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-        data: Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
-        readOnly: false,
-        signature: Buffer.alloc(0),
-      })];
+      const key = new IdentityPublicKeyWithWitness(1);
+      key.setData(Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'));
+
+      const addPublicKeys = [key];
 
       const stateTransition = factory
         .createIdentityUpdateTransition(
@@ -257,8 +243,8 @@ describe('IdentityFactory', () => {
       expect(stateTransition).to.be.instanceOf(IdentityUpdateTransition);
       expect(stateTransition.getIdentityId().toBuffer()).to.deep.equal(identity.getId().toBuffer());
       expect(stateTransition.getRevision()).to.deep.equal(revision);
-      expect(stateTransition.getPublicKeysToAdd().map((key) => key.toObject()))
-        .to.deep.equal(addPublicKeys.map((key) => key.toObject()));
+      expect(stateTransition.getPublicKeysToAdd().map((k) => k.toObject()))
+        .to.deep.equal(addPublicKeys.map((k) => k.toObject()));
       expect(stateTransition.getPublicKeyIdsToDisable()).to.deep.equal([0]);
       expect(stateTransition.getPublicKeysDisabledAt()).to.deep.equal(new Date());
     });

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

@@ -1,31 +1,31 @@
-const { default: loadWasmDpp } = require('@dashevo/wasm-dpp');
+const { IdentityPublicKey } = require('@dashevo/wasm-dpp');
 
 describe('IdentityPublicKey', () => {
   let rawPublicKey;
   let publicKey;
-  let IdentityPublicKey;
 
-  beforeEach(async () => {
-    ({ IdentityPublicKey } = await loadWasmDpp());
+  beforeEach(() => {
+    const keyData = Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64');
 
     rawPublicKey = {
       id: 0,
       type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-      data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
+      data: keyData,
       purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
       securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
       readOnly: false,
+      contractBounds: null,
     };
-    publicKey = new IdentityPublicKey(rawPublicKey);
+
+    publicKey = new IdentityPublicKey(1);
+    publicKey.setData(keyData);
   });
 
   describe('#constructor', () => {
     it('should set variables from raw model', () => {
-      const instance = new IdentityPublicKey(rawPublicKey);
-
-      expect(instance.getId()).to.equal(rawPublicKey.id);
-      expect(instance.getType()).to.equal(rawPublicKey.type);
-      expect(instance.getData()).to.deep.equal(rawPublicKey.data);
+      expect(publicKey.getId()).to.equal(rawPublicKey.id);
+      expect(publicKey.getType()).to.equal(rawPublicKey.type);
+      expect(publicKey.getData()).to.deep.equal(rawPublicKey.data);
     });
   });
 
@@ -145,37 +145,21 @@ describe('IdentityPublicKey', () => {
     });
 
     it('should return data in case ECDSA_HASH160', () => {
-      rawPublicKey = {
-        id: 0,
-        type: IdentityPublicKey.TYPES.ECDSA_HASH160,
-        data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
-        readOnly: false,
-        disabledAt: 123,
-      };
-
-      publicKey = new IdentityPublicKey(rawPublicKey);
+      publicKey = new IdentityPublicKey(1);
+      publicKey.setType(IdentityPublicKey.TYPES.ECDSA_HASH160);
+      publicKey.setData(Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTdi', 'base64'));
 
       const result = publicKey.hash();
 
-      const expectedHash = Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64');
+      const expectedHash = Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTdg=', 'base64');
 
       expect(result).to.deep.equal(expectedHash);
     });
 
     it('should return original public key hash in case BLS12_381', () => {
-      rawPublicKey = {
-        id: 0,
-        type: IdentityPublicKey.TYPES.BLS12_381,
-        data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
-        readOnly: false,
-        disabledAt: 123,
-      };
-
-      publicKey = new IdentityPublicKey(rawPublicKey);
+      publicKey = new IdentityPublicKey(1);
+      publicKey.setType(IdentityPublicKey.TYPES.BLS12_381);
+      publicKey.setData(Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'));
 
       const result = publicKey.hash();
 
@@ -185,17 +169,9 @@ describe('IdentityPublicKey', () => {
     });
 
     it('should return data in case BIP13_SCRIPT_HASH', () => {
-      rawPublicKey = {
-        id: 0,
-        type: IdentityPublicKey.TYPES.BIP13_SCRIPT_HASH,
-        data: Buffer.from('54c557e07dde5bb6cb791c7a540e0a4796f5e97e', 'hex'),
-        purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
-        securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
-        readOnly: false,
-        disabledAt: 123,
-      };
-
-      publicKey = new IdentityPublicKey(rawPublicKey);
+      publicKey = new IdentityPublicKey(1);
+      publicKey.setType(IdentityPublicKey.TYPES.BIP13_SCRIPT_HASH);
+      publicKey.setData(Buffer.from('54c557e07dde5bb6cb791c7a540e0a4796f5e97e', 'hex'));
 
       const result = publicKey.hash();
 
@@ -207,32 +183,42 @@ describe('IdentityPublicKey', () => {
 
   describe('#toJSON', () => {
     it('should return JSON representation', () => {
+      const now = new Date();
+      publicKey.setDisabledAt(now);
+
       const jsonPublicKey = publicKey.toJSON();
 
       expect(jsonPublicKey).to.deep.equal({
+        $version: '0',
         id: 0,
         type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
         data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
         purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
         securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
         readOnly: false,
+        disabledAt: now.getTime(),
+        contractBounds: null,
       });
     });
+  });
 
-    it('should return JSON representation with optional properties', () => {
+  describe('#toObject', () => {
+    it('should return object representation', () => {
       const now = new Date();
       publicKey.setDisabledAt(now);
 
-      const jsonPublicKey = publicKey.toJSON();
+      const jsonPublicKey = publicKey.toObject();
 
       expect(jsonPublicKey).to.deep.equal({
+        $version: '0',
         id: 0,
         type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
-        data: 'AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH',
+        data: Buffer.from('AkVuTKyF3YgKLAQlLEtaUL2HTditwGILfWUVqjzYnIgH', 'base64'),
         purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
         securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
         readOnly: false,
         disabledAt: now.getTime(),
+        contractBounds: null,
       });
     });
   });