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

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

@@ -1,54 +1,85 @@
-const { expectValidationError } = require(
-  '@dashevo/dpp/lib/test/expect/expectError',
-);
-
-const validateIdentityCreateTransitionStateFactory = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityCreateTransition/validation/state/validateIdentityCreateTransitionStateFactory',
-);
-
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
 
-const IdentityAlreadyExistsError = require(
-  '@dashevo/dpp/lib/errors/consensus/state/identity/IdentityAlreadyExistsError',
-);
-
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
+
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+const generateRandomIdentifierAsync = require('../../../../../../../lib/test/utils/generateRandomIdentifierAsync');
+const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
 
 describe('validateIdentityCreateTransitionStateFactory', () => {
   let validateIdentityCreateTransitionState;
   let stateTransition;
   let stateRepositoryMock;
+  let identity;
+
+  let IdentityCreateTransition;
+  let IdentityPublicKey;
+  let IdentityAlreadyExistsError;
+  let Identity;
+  let IdentityCreateTransitionStateValidator;
+
+  before(async () => {
+    ({
+      IdentityCreateTransition,
+      IdentityAlreadyExistsError,
+      IdentityPublicKey,
+      Identity,
+      IdentityCreateTransitionStateValidator,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(async function beforeEach() {
-    const privateKey = 'af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837';
+  beforeEach(async function () {
+    const privateKey = Buffer.from('af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837', 'hex');
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
-    validateIdentityCreateTransitionState = validateIdentityCreateTransitionStateFactory(
-      stateRepositoryMock,
-    );
+    const validator = new IdentityCreateTransitionStateValidator(stateRepositoryMock);
+    validateIdentityCreateTransitionState = (st) => validator.validate(st);
 
-    stateTransition = getIdentityCreateTransitionFixture();
+    stateTransition = new IdentityCreateTransition(
+      getIdentityCreateTransitionFixture().toObject(),
+    );
 
     await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
 
     const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
 
-    stateRepositoryMock.fetchTransaction.resolves(rawTransaction);
+    stateRepositoryMock.fetchTransaction.returns({
+      data: Buffer.from(rawTransaction, 'hex'),
+      height: 42,
+    });
+
+    identity = new Identity({
+      protocolVersion: protocolVersion.latestVersion,
+      id: await generateRandomIdentifierAsync(),
+      publicKeys: [
+        {
+          id: 0,
+          type: 0,
+          data: Buffer.alloc(36).fill('a'),
+          purpose: 0,
+          securityLevel: 0,
+          readOnly: false,
+          signature: Buffer.alloc(36).fill('a'),
+        },
+      ],
+      balance: 0,
+      revision: 0,
+    });
   });
 
   it('should return invalid result if identity already exists', async () => {
-    stateRepositoryMock.fetchIdentity.resolves({});
+    stateRepositoryMock.fetchIdentity.returns(identity);
 
     const result = await validateIdentityCreateTransitionState(stateTransition);
 
-    expectValidationError(result, IdentityAlreadyExistsError, 1);
+    await expectValidationError(result, IdentityAlreadyExistsError);
 
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(4011);
-    expect(Buffer.isBuffer(error.getIdentityId())).to.be.true();
-    expect(error.getIdentityId()).to.deep.equal(stateTransition.getIdentityId());
+    expect(error.getIdentityId()).to.exist();
+    expect(error.getIdentityId()).to.deep.equal(stateTransition.getIdentityId().toBuffer());
   });
 
   it('should return valid result if state transition is valid', async () => {
@@ -58,7 +89,7 @@ describe('validateIdentityCreateTransitionStateFactory', () => {
   });
 
   it('should return valid result on dry run', async () => {
-    stateRepositoryMock.fetchIdentity.resolves({});
+    stateRepositoryMock.fetchIdentity.returns(identity);
 
     stateTransition.getExecutionContext().enableDryRun();
 

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

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

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

@@ -1,47 +1,66 @@
-const applyIdentityTopUpTransitionFactory = require(
-  '@dashevo/dpp/lib/identity/stateTransition/IdentityTopUpTransition/applyIdentityTopUpTransitionFactory',
-);
-
 const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
 
 const { convertSatoshiToCredits } = require('@dashevo/dpp/lib/identity/creditsConverter');
 
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
-const getBiggestPossibleIdentity = require('@dashevo/dpp/lib/identity/getBiggestPossibleIdentity');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+const generateRandomIdentifierAsync = require('../../../../../lib/test/utils/generateRandomIdentifierAsync');
 
 describe('applyIdentityTopUpTransitionFactory', () => {
   let stateTransition;
   let applyIdentityTopUpTransition;
   let stateRepositoryMock;
   let identity;
-  let fetchAssetLockTransactionOutputMock;
   let executionContext;
 
-  beforeEach(function beforeEach() {
-    identity = getIdentityFixture();
+  let StateTransitionExecutionContext;
+  let IdentityTopUpTransition;
+  let Identity;
+
+  let applyIdentityTopUpTransitionDPP;
+
+  before(async () => {
+    ({
+      StateTransitionExecutionContext,
+      IdentityTopUpTransition,
+      applyIdentityTopUpTransition: applyIdentityTopUpTransitionDPP,
+      Identity,
+    } = await loadWasmDpp());
+  });
+
+  beforeEach(async function beforeEach() {
+    const rawIdentity = getIdentityFixture().toObject();
+    // Patch identity id to match expectation of wasm Identity class
+    rawIdentity.id = await generateRandomIdentifierAsync();
+    identity = new Identity(rawIdentity);
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchIdentity.resolves(identity);
+    stateRepositoryMock.fetchIdentity.returns(identity);
 
-    stateTransition = getIdentityTopUpTransitionFixture();
+    const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
 
-    executionContext = new StateTransitionExecutionContext();
+    stateRepositoryMock.fetchTransaction.returns({
+      data: Buffer.from(rawTransaction, 'hex'),
+      height: 42,
+    });
 
-    stateTransition.setExecutionContext(executionContext);
+    stateTransition = new IdentityTopUpTransition(
+      getIdentityTopUpTransitionFixture().toObject(),
+    );
 
-    const output = stateTransition.getAssetLockProof().getOutput();
+    executionContext = new StateTransitionExecutionContext();
 
-    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
+    stateTransition.setExecutionContext(executionContext);
 
-    applyIdentityTopUpTransition = applyIdentityTopUpTransitionFactory(
+    applyIdentityTopUpTransition = (st) => applyIdentityTopUpTransitionDPP(
       stateRepositoryMock,
-      fetchAssetLockTransactionOutputMock,
+      st,
     );
   });
 
-  it('should store identity created from state transition', async () => {
+  it('should store identity created from state transition', async function () {
     const balanceBeforeTopUp = identity.getBalance();
 
     const balanceToTopUp = convertSatoshiToCredits(
@@ -50,35 +69,24 @@ describe('applyIdentityTopUpTransitionFactory', () => {
 
     await applyIdentityTopUpTransition(stateTransition);
 
-    expect(identity.getBalance()).to.be.equal(balanceBeforeTopUp + balanceToTopUp);
-    expect(identity.getBalance()).to.be.greaterThan(balanceBeforeTopUp);
+    const { args: [updatedIdentity] } = stateRepositoryMock.updateIdentity.firstCall;
+
+    expect(updatedIdentity.getBalance()).to.be.equal(balanceBeforeTopUp + balanceToTopUp);
+    expect(updatedIdentity.getBalance()).to.be.greaterThan(balanceBeforeTopUp);
 
     expect(stateRepositoryMock.updateIdentity).to.have.been.calledOnceWithExactly(
-      identity,
-      executionContext,
+      updatedIdentity,
+      this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
     );
 
     expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
       .calledOnceWithExactly(
         stateTransition.getAssetLockProof().getOutPoint(),
-        executionContext,
-      );
-
-    expect(fetchAssetLockTransactionOutputMock)
-      .to.be.calledOnceWithExactly(
-        stateTransition.getAssetLockProof(),
-        executionContext,
       );
   });
 
-  it('should store biggest possible identity on dry run', async () => {
-    const biggestPossibleIdentity = getBiggestPossibleIdentity();
-
-    const balanceBeforeTopUp = biggestPossibleIdentity.getBalance();
-
-    const balanceToTopUp = convertSatoshiToCredits(
-      stateTransition.getAssetLockProof().getOutput().satoshis,
-    );
+  it('should store biggest possible identity on dry run', async function () {
+    const biggestPossibleBalance = 18446744073709552000;
 
     executionContext.enableDryRun();
 
@@ -86,23 +94,17 @@ describe('applyIdentityTopUpTransitionFactory', () => {
 
     executionContext.disableDryRun();
 
-    expect(biggestPossibleIdentity.getBalance()).to.be.equal(balanceBeforeTopUp + balanceToTopUp);
+    const { args: [biggestPossibleIdentity] } = stateRepositoryMock.updateIdentity.firstCall;
+    expect(biggestPossibleIdentity.getBalance()).to.be.equal(biggestPossibleBalance);
 
     expect(stateRepositoryMock.updateIdentity).to.have.been.calledOnceWithExactly(
       biggestPossibleIdentity,
-      executionContext,
+      this.sinonSandbox.match.instanceOf(StateTransitionExecutionContext),
     );
 
     expect(stateRepositoryMock.markAssetLockTransactionOutPointAsUsed).to.have.been
       .calledOnceWithExactly(
         stateTransition.getAssetLockProof().getOutPoint(),
-        executionContext,
-      );
-
-    expect(fetchAssetLockTransactionOutputMock)
-      .to.be.calledOnceWithExactly(
-        stateTransition.getAssetLockProof(),
-        executionContext,
       );
   });
 });

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

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

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

@@ -0,0 +1,63 @@
+const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+
+describe('ChainAssetLockProof', () => {
+  let ChainAssetLockProof;
+  let chainAssetLockProof;
+  let chainAssetLockProofJS;
+
+  before(async () => {
+    ({ ChainAssetLockProof } = await loadWasmDpp());
+
+    chainAssetLockProofJS = getChainAssetLockFixture();
+    chainAssetLockProof = new ChainAssetLockProof(
+      chainAssetLockProofJS.toObject(),
+    );
+  });
+
+  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());
+    });
+  });
+
+  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());
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return correct object', () => {
+      expect(chainAssetLockProof.toObject())
+        .to.deep.equal(chainAssetLockProofJS.toObject());
+    });
+  });
+
+  describe('#createIdentifier', () => {
+    it('should return correct identifier', () => {
+      const identifier = chainAssetLockProof.createIdentifier();
+      const identifierJS = chainAssetLockProofJS.createIdentifier();
+
+      expect(identifier.toBuffer())
+        .to.deep.equal(identifierJS.toBuffer());
+    });
+  });
+});

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

@@ -0,0 +1,90 @@
+const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+
+describe('InstantAssetLockProof', () => {
+  let InstantAssetLockProof;
+  let instantAssetLockProof;
+  let instantAssetLockProofJS;
+
+  before(async () => {
+    ({ InstantAssetLockProof } = await loadWasmDpp());
+
+    instantAssetLockProofJS = getInstantAssetLockProofFixture();
+    instantAssetLockProof = new InstantAssetLockProof(
+      instantAssetLockProofJS.toObject(),
+    );
+  });
+
+  describe('#getType', () => {
+    it('should return correct type', () => {
+      expect(instantAssetLockProof.getType())
+        .to.equal(instantAssetLockProofJS.getType());
+    });
+  });
+
+  describe('#getOutputIndex', () => {
+    it('should return correct type', () => {
+      expect(instantAssetLockProof.getOutputIndex())
+        .to.equal(instantAssetLockProofJS.getOutputIndex());
+    });
+  });
+
+  describe('#getOutPoint', () => {
+    it('should return correct outPoint', () => {
+      expect(instantAssetLockProof.getOutPoint())
+        .to.deep.equal(instantAssetLockProofJS.getOutPoint());
+    });
+  });
+
+  describe('#getOutput', () => {
+    it('should return correct output', () => {
+      expect(instantAssetLockProof.getOutput())
+        .to.deep.equal(instantAssetLockProofJS.getOutput().toObject());
+    });
+  });
+
+  describe('#createIdentifier', () => {
+    it('should return correct identifier', () => {
+      const identifier = instantAssetLockProof.createIdentifier();
+      const identifierJS = instantAssetLockProofJS.createIdentifier();
+
+      expect(identifier.toBuffer())
+        .to.deep.equal(identifierJS.toBuffer());
+    });
+  });
+
+  describe('#getInstantLock', () => {
+    it('should return correct instant lock', () => {
+      const instantLock = instantAssetLockProof.getInstantLock();
+      const instantLockJS = instantAssetLockProofJS.getInstantLock();
+
+      expect(instantLock)
+        .to.deep.equal(instantLockJS.toBuffer());
+    });
+  });
+
+  describe('#getTransaction', () => {
+    it('should return correct transaction', () => {
+      const transaction = instantAssetLockProof.getTransaction();
+      const transactionJS = instantAssetLockProofJS.getTransaction();
+
+      expect(transaction)
+        .to.deep.equal(transactionJS.toBuffer());
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return correct object', () => {
+      expect(instantAssetLockProof.toObject())
+        .to.deep.equal(instantAssetLockProofJS.toObject());
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return correct JSON', () => {
+      expect(instantAssetLockProof.toJSON())
+        .to.deep.equal(instantAssetLockProofJS.toJSON());
+    });
+  });
+});

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

@@ -1,21 +1,36 @@
-const createAssetLockProofInstance = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/createAssetLockProofInstance');
+const createAssetLockProofInstanceJS = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/createAssetLockProofInstance');
 const getChainAssetLockFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
 const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
-const ChainAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/chain/ChainAssetLockProof');
-const InstantAssetLockProof = require('@dashevo/dpp/lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('createAssetLockProofInstance', () => {
+  let createAssetLockProofInstance;
+  let InstantAssetLockProof;
+  let ChainAssetLockProof;
+
+  before(async () => {
+    ({
+      createAssetLockProofInstance,
+      InstantAssetLockProof,
+      ChainAssetLockProof,
+    } = await loadWasmDpp());
+  });
+
   it('should create an instance of InstantAssetLockProof', () => {
     const assetLockProofFixture = getInstantAssetLockProofFixture();
     const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
+    const instanceJS = createAssetLockProofInstanceJS(assetLockProofFixture.toObject());
 
+    expect(instance.toObject()).to.deep.equal(instanceJS.toObject());
     expect(instance).to.be.an.instanceOf(InstantAssetLockProof);
   });
 
   it('should create an instance of ChainAssetLockProof', () => {
     const assetLockProofFixture = getChainAssetLockFixture();
     const instance = createAssetLockProofInstance(assetLockProofFixture.toObject());
+    const instanceJS = createAssetLockProofInstanceJS(assetLockProofFixture.toObject());
 
+    expect(instance.toObject()).to.deep.equal(instanceJS.toObject());
     expect(instance).to.be.an.instanceOf(ChainAssetLockProof);
   });
 });