@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0-pr.1545.2

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

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

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

@@ -1,17 +1,16 @@
-const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
+const getIdentityCreateTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
 
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
 
 const { default: loadWasmDpp } = require('../../../../../../../dist');
 const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
 
-describe('validateIdentityCreateTransitionStateFactory', () => {
+describe.skip('validateIdentityCreateTransitionStateFactory', () => {
   let validateIdentityCreateTransitionState;
   let stateTransition;
   let stateRepositoryMock;
   let executionContext;
 
-  let IdentityCreateTransition;
   let IdentityPublicKey;
   let IdentityAlreadyExistsError;
   let IdentityCreateTransitionStateValidator;
@@ -19,7 +18,6 @@ describe('validateIdentityCreateTransitionStateFactory', () => {
 
   before(async () => {
     ({
-      IdentityCreateTransition,
       IdentityAlreadyExistsError,
       IdentityPublicKey,
       IdentityCreateTransitionStateValidator,
@@ -27,7 +25,7 @@ describe('validateIdentityCreateTransitionStateFactory', () => {
     } = await loadWasmDpp());
   });
 
-  beforeEach(async function () {
+  beforeEach(async function beforeEach() {
     executionContext = new StateTransitionExecutionContext();
     const privateKey = Buffer.from('af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837', 'hex');
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
@@ -35,9 +33,7 @@ describe('validateIdentityCreateTransitionStateFactory', () => {
     const validator = new IdentityCreateTransitionStateValidator(stateRepositoryMock);
     validateIdentityCreateTransitionState = (st) => validator.validate(st, executionContext);
 
-    stateTransition = new IdentityCreateTransition(
-      getIdentityCreateTransitionFixture().toObject(),
-    );
+    stateTransition = await getIdentityCreateTransitionFixture();
 
     await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
 

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

@@ -1,30 +1,15 @@
-const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
-const getChainAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
+const getIdentityTopUpTransitionFixture = require('../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
 
-const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
-const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const { default: loadWasmDpp } = require('../../../../../dist');
+const { InstantAssetLockProof, Identifier } = require('../../../../..');
+const { StateTransitionTypes } = require('../../../../..');
 
 describe('IdentityTopUpTransition', () => {
   let rawStateTransition;
   let stateTransition;
 
-  let IdentityTopUpTransition;
-  let InstantAssetLockProof;
-  let Identifier;
-
-  before(async () => {
-    ({
-      IdentityTopUpTransition, InstantAssetLockProof, Identifier,
-    } = await loadWasmDpp());
-  });
-
-  beforeEach(() => {
-    rawStateTransition = getIdentityTopUpTransitionFixture().toObject();
-
-    stateTransition = new IdentityTopUpTransition(
-      rawStateTransition,
-    );
+  beforeEach(async () => {
+    stateTransition = await getIdentityTopUpTransitionFixture();
+    rawStateTransition = stateTransition.toObject();
   });
 
   describe('#constructor', () => {
@@ -36,18 +21,11 @@ describe('IdentityTopUpTransition', () => {
         rawStateTransition.identityId,
       );
     });
-
-    it('should create instance with chain asset lock proof', () => {
-      rawStateTransition.assetLockProof = getChainAssetLockProofFixture().toObject();
-      stateTransition = new IdentityTopUpTransition(rawStateTransition);
-      expect(stateTransition.getAssetLockProof().toObject())
-        .to.deep.equal(rawStateTransition.assetLockProof);
-    });
   });
 
   describe('#getType', () => {
     it('should return IDENTITY_TOP_UP type', () => {
-      expect(stateTransition.getType()).to.equal(stateTransitionTypes.IDENTITY_TOP_UP);
+      expect(stateTransition.getType()).to.equal(StateTransitionTypes.IdentityTopUp);
     });
   });
 
@@ -91,8 +69,8 @@ describe('IdentityTopUpTransition', () => {
       rawStateTransition = stateTransition.toObject();
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: protocolVersion.latestVersion,
-        type: stateTransitionTypes.IDENTITY_TOP_UP,
+        $version: '0',
+        type: StateTransitionTypes.IdentityTopUp,
         assetLockProof: rawStateTransition.assetLockProof,
         identityId: rawStateTransition.identityId,
         signature: undefined,
@@ -103,8 +81,8 @@ describe('IdentityTopUpTransition', () => {
       rawStateTransition = stateTransition.toObject({ skipSignature: true });
 
       expect(rawStateTransition).to.deep.equal({
-        protocolVersion: protocolVersion.latestVersion,
-        type: stateTransitionTypes.IDENTITY_TOP_UP,
+        $version: '0',
+        type: StateTransitionTypes.IdentityTopUp,
         assetLockProof: rawStateTransition.assetLockProof,
         identityId: rawStateTransition.identityId,
       });
@@ -116,8 +94,8 @@ describe('IdentityTopUpTransition', () => {
       const jsonStateTransition = stateTransition.toJSON();
 
       expect(jsonStateTransition).to.deep.equal({
-        protocolVersion: protocolVersion.latestVersion,
-        type: stateTransitionTypes.IDENTITY_TOP_UP,
+        $version: '0',
+        type: StateTransitionTypes.IdentityTopUp,
         assetLockProof: stateTransition.getAssetLockProof().toJSON(),
         identityId: new Identifier(rawStateTransition.identityId).toString(),
         signature: undefined,

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

@@ -1,32 +1,28 @@
-const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
+const getIdentityTopUpTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
 
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
 const { default: loadWasmDpp } = require('../../../../../../../dist');
 
-describe('validateIdentityTopUpTransitionStateFactory', () => {
+describe.skip('validateIdentityTopUpTransitionStateFactory', () => {
   let validateIdentityTopUpTransitionState;
   let stateTransition;
   let stateRepositoryMock;
   let executionContext;
 
-  let IdentityTopUpTransition;
   let IdentityTopUpTransitionStateValidator;
   let StateTransitionExecutionContext;
 
   before(async () => {
     ({
-      IdentityTopUpTransition,
       IdentityTopUpTransitionStateValidator,
       StateTransitionExecutionContext,
     } = await loadWasmDpp());
   });
 
-  beforeEach(function () {
+  beforeEach(async function beforeEach() {
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    stateTransition = new IdentityTopUpTransition(
-      getIdentityTopUpTransitionFixture().toObject(),
-    );
+    stateTransition = await getIdentityTopUpTransitionFixture();
 
     const validator = new IdentityTopUpTransitionStateValidator(stateRepositoryMock);
 

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

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

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

@@ -1,63 +1,44 @@
-const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
-
-const { default: loadWasmDpp } = require('../../../../../dist');
+const { ChainAssetLockProof } = require('../../../../../dist');
+const getChainAssetLockProofFixture = require('../../../../../lib/test/fixtures/getChainAssetLockProofFixture');
 
 describe('ChainAssetLockProof', () => {
-  let ChainAssetLockProof;
+  let rawChainAssetLockProof;
   let chainAssetLockProof;
-  let chainAssetLockProofJS;
 
   before(async () => {
-    ({ ChainAssetLockProof } = await loadWasmDpp());
-
-    chainAssetLockProofJS = getChainAssetLockFixture();
+    rawChainAssetLockProof = getChainAssetLockProofFixture().toObject();
     chainAssetLockProof = new ChainAssetLockProof(
-      chainAssetLockProofJS.toObject(),
+      rawChainAssetLockProof,
     );
   });
 
-  describe('#getType', () => {
-    it('should return correct type', () => {
-      expect(chainAssetLockProof.getType())
-        .to.equal(chainAssetLockProofJS.getType());
-    });
-  });
-
   describe('#getCoreChainLockedHeight', () => {
     it('should return correct coreChainLockedHeight', () => {
       expect(chainAssetLockProof.getCoreChainLockedHeight())
-        .to.equal(chainAssetLockProofJS.getCoreChainLockedHeight());
+        .to.equal(rawChainAssetLockProof.coreChainLockedHeight);
     });
   });
 
   describe('#getOutPoint', () => {
     it('should return correct outPoint', () => {
       expect(chainAssetLockProof.getOutPoint())
-        .to.deep.equal(chainAssetLockProofJS.getOutPoint());
-    });
-  });
-
-  describe('#toJSON', () => {
-    it('should return correct JSON', () => {
-      expect(chainAssetLockProof.toJSON())
-        .to.deep.equal(chainAssetLockProofJS.toJSON());
+        .to.deep.equal(rawChainAssetLockProof.outPoint);
     });
   });
 
   describe('#toObject', () => {
     it('should return correct object', () => {
       expect(chainAssetLockProof.toObject())
-        .to.deep.equal(chainAssetLockProofJS.toObject());
+        .to.deep.equal(rawChainAssetLockProof);
     });
   });
 
   describe('#createIdentifier', () => {
     it('should return correct identifier', () => {
       const identifier = chainAssetLockProof.createIdentifier();
-      const identifierJS = chainAssetLockProofJS.createIdentifier();
 
       expect(identifier.toBuffer())
-        .to.deep.equal(identifierJS.toBuffer());
+        .to.have.length(32);
     });
   });
 });