@dashevo/wasm-dpp 0.24.0-dev.23 → 0.24.0-dev.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.24.0-dev.23",
+  "version": "0.24.0-dev.24",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,8 +44,8 @@
     "@babel/core": "^7.15.5",
     "@babel/preset-env": "^7.15.4",
     "@dashevo/dashcore-lib": "~0.20.3",
-    "@dashevo/dpns-contract": "0.24.0-dev.23",
-    "@dashevo/dpp": "0.24.0-dev.23",
+    "@dashevo/dpns-contract": "0.24.0-dev.24",
+    "@dashevo/dpp": "0.24.0-dev.24",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",

package/src/errors/consensus/fee/balance_is_not_enough_error.rs

@@ -26,13 +26,13 @@ impl BalanceIsNotEnoughErrorWasm {
     }
 
     #[wasm_bindgen(js_name=getBalance)]
-    pub fn get_balance(&self) -> Credits {
-        self.inner.balance()
+    pub fn get_balance(&self) -> f64 {
+        self.inner.balance() as f64
     }
 
     #[wasm_bindgen(js_name=getFee)]
-    pub fn get_fee(&self) -> Credits {
-        self.inner.fee()
+    pub fn get_fee(&self) -> f64 {
+        self.inner.fee() as f64
     }
 
     #[wasm_bindgen(js_name=getCode)]

package/src/identity/credits_converter.rs

@@ -0,0 +1,7 @@
+use dpp::identity::RATIO;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name=getCreditsConversionRatio)]
+pub fn credit_conversion_ratio() -> f64 {
+    RATIO as f64
+}

package/src/identity/mod.rs

@@ -24,6 +24,7 @@ use crate::buffer::Buffer;
 use crate::errors::from_dpp_err;
 pub use state_transition::*;
 
+pub mod credits_converter;
 pub mod errors;
 pub mod state_transition;
 

package/src/state_transition/fee/mod.rs

@@ -1,6 +1,8 @@
 use dpp::state_transition::fee::operations::Operation;
 use wasm_bindgen::prelude::*;
 
+pub use operations::*;
+
 use crate::utils::Inner;
 mod calculate_operation_fees;
 mod calculate_state_transition_fee;

package/src/state_transition/validation/mod.rs

@@ -1,2 +1,3 @@
+pub mod state_transition_fee_validator;
 pub mod validate_state_transition_identity_signature;
 pub mod validate_state_transition_key_signature;

package/src/state_transition/validation/state_transition_fee_validator.rs

@@ -0,0 +1,39 @@
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use dpp::state_transition::validation::validate_state_transition_fee::StateTransitionFeeValidator;
+use std::sync::Arc;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+use crate::state_transition::conversion::create_state_transition_from_wasm_instance;
+use crate::utils::WithJsError;
+use crate::validation::ValidationResultWasm;
+
+#[wasm_bindgen(js_name=StateTransitionFeeValidator)]
+pub struct StateTransitionFeeValidatorWasm(
+    StateTransitionFeeValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+#[wasm_bindgen(js_class=StateTransitionFeeValidator)]
+impl StateTransitionFeeValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(state_repository: ExternalStateRepositoryLike) -> Self {
+        Self(StateTransitionFeeValidator::new(Arc::new(
+            ExternalStateRepositoryLikeWrapper::new(state_repository),
+        )))
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        state_transition: &JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let st = create_state_transition_from_wasm_instance(state_transition)?;
+        Ok(self
+            .0
+            .validate(&st)
+            .await
+            .map(|v| v.map(|_| JsValue::undefined()))
+            .with_js_error()?
+            .into())
+    }
+}

package/test/integration/identity/stateTransition/IdentityTopUpTransition/validation/basic/validateIdentityTopUpTransitionBasicFactory.spec.js

@@ -1,5 +1,5 @@
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const getIdentityTopUpTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
+const getIdentityTopUpTransitionFixture = require('../../../../../../../lib/test/fixtures/getIdentityTopUpTransitionFixtureJs');
 
 const {
   expectJsonSchemaError,

package/test/integration/stateTransition/StateTransitionFacade.spec.js

@@ -171,6 +171,7 @@ describe('StateTransitionFacade', () => {
     });
 
     it('should return invalid result if not enough balance to pay fee for State Transition', async () => {
+      identity.setBalance(0);
       stateRepositoryMock.fetchIdentityBalance.resolves(0);
       const result = await dpp.stateTransition.validate(dataContractCreateTransition);
 

package/test/unit/stateTransition/validation/validateStateTransitionFeeFactory.spec.js

@@ -1,167 +1,157 @@
-const validateStateTransitionFeeFactory = require('@dashevo/dpp/lib/stateTransition/validation/validateStateTransitionFeeFactory');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-
-const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
-const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
-const getIdentityTopUpTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityTopUpTransitionFixture');
-
-const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-const DocumentsBatchTransition = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
-
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const IdentityBalanceIsNotEnoughError = require('@dashevo/dpp/lib/errors/consensus/fee/BalanceIsNotEnoughError');
-const InvalidStateTransitionTypeError = require('@dashevo/dpp/lib/stateTransition/errors/InvalidStateTransitionTypeError');
-
-const { RATIO } = require('@dashevo/dpp/lib/identity/creditsConverter');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+
+const createStateRepositoryMock = require('../../../../lib/test/mocks/createStateRepositoryMock');
+const getBlsMock = require('../../../../lib/test/mocks/getBlsAdapterMock');
+
+const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../lib/test/fixtures/getDocumentsFixture');
+const getIdentityCreateTransitionFixture = require('../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+const getIdentityTopUpTransitionFixture = require('../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
+
+let {
+  StateTransitionFeeValidator,
+  DashPlatformProtocol,
+  IdentityBalanceIsNotEnoughError,
+  StateTransitionExecutionContext,
+  PreCalculatedOperation,
+  getCreditsConversionRatio,
+} = require('../../../..');
+const { default: loadWasmDpp } = require('../../../..');
 
 describe('validateStateTransitionFeeFactory', () => {
   let stateRepositoryMock;
   let validateStateTransitionFee;
   let dataContract;
-  let calculateStateTransitionFeeMock;
-  let fetchAssetLockTransactionOutputMock;
-
-  beforeEach(function beforeEach() {
+  let dpp;
+  let dataContractOwnerId;
+  let executionContext;
+
+  beforeEach(async function beforeEach() {
+    ({
+      StateTransitionFeeValidator,
+      IdentityBalanceIsNotEnoughError,
+      DashPlatformProtocol,
+      StateTransitionExecutionContext,
+      PreCalculatedOperation,
+      getCreditsConversionRatio,
+    } = await loadWasmDpp());
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchDataContract.resolves(undefined);
 
-    const output = getIdentityCreateTransitionFixture().getAssetLockProof().getOutput();
+    dpp = new DashPlatformProtocol(getBlsMock(), stateRepositoryMock);
 
-    calculateStateTransitionFeeMock = this.sinonSandbox.stub().returns({
-      desiredAmount: 42,
-    });
+    const validator = new StateTransitionFeeValidator(stateRepositoryMock);
 
-    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
+    validateStateTransitionFee = (st) => validator.validate(st);
 
-    validateStateTransitionFee = validateStateTransitionFeeFactory(
-      stateRepositoryMock,
-      calculateStateTransitionFeeMock,
-      fetchAssetLockTransactionOutputMock,
-    );
+    executionContext = new StateTransitionExecutionContext();
+    executionContext.disableDryRun();
 
-    dataContract = getDataContractFixture();
+    dataContract = await getDataContractFixture();
   });
 
   describe('DataContractCreateTransition', () => {
     let dataContractCreateTransition;
 
     beforeEach(() => {
-      dataContractCreateTransition = new DataContractCreateTransition({
-        dataContract: dataContract.toObject(),
-        entropy: dataContract.getEntropy(),
-      });
+      dataContractOwnerId = dataContract.getOwnerId().toBuffer();
+      dataContractCreateTransition = dpp.dataContract
+        .createDataContractCreateTransition(dataContract);
     });
 
     it('should return invalid result if balance is not enough', async () => {
+      executionContext.addOperation(new PreCalculatedOperation(0, 42, []));
+      dataContractCreateTransition.setExecutionContext(executionContext);
       stateRepositoryMock.fetchIdentityBalance.resolves(1);
 
       const result = await validateStateTransitionFee(dataContractCreateTransition);
 
-      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+      await expectValidationError(result, IdentityBalanceIsNotEnoughError);
 
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(3000);
       expect(error.getBalance()).to.equal(1);
 
-      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
-        dataContract.getOwnerId(),
-        dataContractCreateTransition.getExecutionContext(),
-      );
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        dataContractCreateTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalance.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(dataContractOwnerId);
     });
 
     it('should return valid result', async () => {
       stateRepositoryMock.fetchIdentityBalance.resolves(42);
 
+      executionContext.addOperation(new PreCalculatedOperation(0, 42, []));
+      dataContractCreateTransition.setExecutionContext(executionContext);
+
       const result = await validateStateTransitionFee(dataContractCreateTransition);
 
       expect(result.isValid()).to.be.true();
 
-      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
-        dataContract.getOwnerId(),
-        dataContractCreateTransition.getExecutionContext(),
-      );
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        dataContractCreateTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalance.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(dataContractOwnerId);
     });
   });
 
   describe('DocumentsBatchTransition', () => {
     let documentsBatchTransition;
+    let ownerId;
 
-    beforeEach(() => {
-      const documents = getDocumentsFixture(dataContract);
-
-      const documentTransitions = getDocumentTransitionsFixture({
-        create: documents,
+    beforeEach(async () => {
+      documentsBatchTransition = await dpp.document.createStateTransition({
+        create: await getDocumentsFixture(),
       });
 
-      documentsBatchTransition = new DocumentsBatchTransition({
-        ownerId: getDocumentsFixture.ownerId,
-        contractId: dataContract.getId(),
-        transitions: documentTransitions.map((t) => t.toObject()),
-      }, [dataContract]);
+      ownerId = documentsBatchTransition.getOwnerId().toBuffer();
     });
 
     it('should return invalid result if balance is not enough', async () => {
       stateRepositoryMock.fetchIdentityBalance.resolves(1);
 
+      executionContext.addOperation(new PreCalculatedOperation(0, 42, []));
+      documentsBatchTransition.setExecutionContext(executionContext);
+
       const result = await validateStateTransitionFee(documentsBatchTransition);
 
-      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+      await expectValidationError(result, IdentityBalanceIsNotEnoughError);
 
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(3000);
       expect(error.getBalance()).to.equal(1);
 
-      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
-        getDocumentsFixture.ownerId,
-        documentsBatchTransition.getExecutionContext(),
-      );
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        documentsBatchTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalance.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(ownerId);
     });
 
     it('should return valid result', async () => {
       stateRepositoryMock.fetchIdentityBalance.resolves(42);
 
+      executionContext.addOperation(new PreCalculatedOperation(0, 42, []));
+      documentsBatchTransition.setExecutionContext(executionContext);
+
       const result = await validateStateTransitionFee(documentsBatchTransition);
 
       expect(result.isValid()).to.be.true();
 
-      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
-        getDocumentsFixture.ownerId,
-        documentsBatchTransition.getExecutionContext(),
-      );
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        documentsBatchTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalance.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(ownerId);
     });
 
     it('should not increase balance on dry run', async () => {
-      documentsBatchTransition.getExecutionContext().enableDryRun();
+      stateRepositoryMock.fetchIdentityBalance.resolves(1);
+
+      executionContext.enableDryRun();
+
+      executionContext.addOperation(new PreCalculatedOperation(0, 42, []));
+      documentsBatchTransition.setExecutionContext(executionContext);
 
       const result = await validateStateTransitionFee(documentsBatchTransition);
 
@@ -169,12 +159,10 @@ describe('validateStateTransitionFeeFactory', () => {
 
       expect(result.isValid()).to.be.true();
 
-      expect(calculateStateTransitionFeeMock).to.be.not.called();
-      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnceWithExactly(
-        getDocumentsFixture.ownerId,
-        documentsBatchTransition.getExecutionContext(),
-      );
-      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+      expect(stateRepositoryMock.fetchIdentityBalance).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalance.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(ownerId);
     });
   });
 
@@ -182,22 +170,23 @@ describe('validateStateTransitionFeeFactory', () => {
     let identityCreateTransition;
     let outputAmount;
 
-    beforeEach(() => {
-      identityCreateTransition = getIdentityCreateTransitionFixture();
+    beforeEach(async () => {
+      identityCreateTransition = await getIdentityCreateTransitionFixture();
 
       const { satoshis } = identityCreateTransition
         .getAssetLockProof()
         .getOutput();
 
-      outputAmount = satoshis * RATIO;
+      outputAmount = satoshis * getCreditsConversionRatio();
     });
 
     it('should return invalid result if asset lock output amount is not enough', async () => {
-      calculateStateTransitionFeeMock.returns({ desiredAmount: outputAmount + 1 });
+      executionContext.addOperation(new PreCalculatedOperation(0, outputAmount + 1, []));
+      identityCreateTransition.setExecutionContext(executionContext);
 
       const result = await validateStateTransitionFee(identityCreateTransition);
 
-      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+      await expectValidationError(result, IdentityBalanceIsNotEnoughError);
 
       const [error] = result.getErrors();
 
@@ -205,122 +194,91 @@ describe('validateStateTransitionFeeFactory', () => {
       expect(error.getBalance()).to.equal(outputAmount);
 
       expect(stateRepositoryMock.fetchIdentity).to.be.not.called();
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        identityCreateTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
-        identityCreateTransition.getAssetLockProof(),
-        identityCreateTransition.getExecutionContext(),
-      );
     });
 
     it('should return valid result', async () => {
-      calculateStateTransitionFeeMock.returns(outputAmount);
+      executionContext.addOperation(new PreCalculatedOperation(0, outputAmount, []));
+      identityCreateTransition.setExecutionContext(executionContext);
 
       const result = await validateStateTransitionFee(identityCreateTransition);
 
       expect(result.isValid()).to.be.true();
 
       expect(stateRepositoryMock.fetchIdentity).to.be.not.called();
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        identityCreateTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
-        identityCreateTransition.getAssetLockProof(),
-        identityCreateTransition.getExecutionContext(),
-      );
     });
 
     it('should not increase balance on dry run', async () => {
-      identityCreateTransition.getExecutionContext().enableDryRun();
+      executionContext.enableDryRun();
+      executionContext.addOperation(new PreCalculatedOperation(0, outputAmount + 1, []));
+      identityCreateTransition.setExecutionContext(executionContext);
 
       const result = await validateStateTransitionFee(identityCreateTransition);
 
       identityCreateTransition.getExecutionContext().disableDryRun();
 
       expect(result.isValid()).to.be.true();
-
-      expect(calculateStateTransitionFeeMock).to.be.not.called();
-      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
-        identityCreateTransition.getAssetLockProof(),
-        identityCreateTransition.getExecutionContext(),
-      );
     });
   });
 
   describe('IdentityTopUpTransition', () => {
     let identityTopUpTransition;
     let outputAmount;
+    let identityId;
 
-    beforeEach(() => {
-      identityTopUpTransition = getIdentityTopUpTransitionFixture();
+    beforeEach(async () => {
+      identityTopUpTransition = await getIdentityTopUpTransitionFixture();
+      identityId = identityTopUpTransition.getIdentityId().toBuffer();
 
       const { satoshis } = identityTopUpTransition
         .getAssetLockProof()
         .getOutput();
 
-      outputAmount = satoshis * RATIO;
+      outputAmount = satoshis * getCreditsConversionRatio();
     });
 
     it('should return invalid result if sum of balance and asset lock output amount is not enough', async () => {
       stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(1);
 
-      calculateStateTransitionFeeMock.returns({ desiredAmount: outputAmount + 2 });
+      executionContext.addOperation(new PreCalculatedOperation(0, outputAmount + 2, []));
+      identityTopUpTransition.setExecutionContext(executionContext);
 
       const result = await validateStateTransitionFee(identityTopUpTransition);
 
-      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+      await expectValidationError(result, IdentityBalanceIsNotEnoughError);
 
       const [error] = result.getErrors();
 
       expect(error.getCode()).to.equal(3000);
       expect(error.getBalance()).to.equal(outputAmount + 1);
 
-      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnceWithExactly(
-        identityTopUpTransition.getIdentityId(),
-        identityTopUpTransition.getExecutionContext(),
-      );
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        identityTopUpTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
-        identityTopUpTransition.getAssetLockProof(),
-        identityTopUpTransition.getExecutionContext(),
-      );
+      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalanceWithDebt.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(identityId);
     });
 
     it('should return valid result', async () => {
       stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(41);
 
-      calculateStateTransitionFeeMock.returns(outputAmount - 1);
+      executionContext.addOperation(new PreCalculatedOperation(0, outputAmount - 1, []));
+      identityTopUpTransition.setExecutionContext(executionContext);
 
       const result = await validateStateTransitionFee(identityTopUpTransition);
 
       expect(result.isValid()).to.be.true();
 
-      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnceWithExactly(
-        identityTopUpTransition.getIdentityId(),
-        identityTopUpTransition.getExecutionContext(),
-      );
-
-      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
-        identityTopUpTransition,
-      );
-
-      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
-        identityTopUpTransition.getAssetLockProof(),
-        identityTopUpTransition.getExecutionContext(),
-      );
+      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalanceWithDebt.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(identityId);
     });
 
     it('should not increase balance on dry run', async () => {
-      identityTopUpTransition.getExecutionContext().enableDryRun();
+      stateRepositoryMock.fetchIdentityBalanceWithDebt.resolves(1);
+
+      executionContext.enableDryRun();
+      executionContext.addOperation(new PreCalculatedOperation(0, outputAmount + 42, []));
+      identityTopUpTransition.setExecutionContext(executionContext);
 
       const result = await validateStateTransitionFee(identityTopUpTransition);
 
@@ -328,43 +286,10 @@ describe('validateStateTransitionFeeFactory', () => {
 
       expect(result.isValid()).to.be.true();
 
-      expect(calculateStateTransitionFeeMock).to.be.not.called();
-      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
-        identityTopUpTransition.getAssetLockProof(),
-        identityTopUpTransition.getExecutionContext(),
-      );
-      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnceWithExactly(
-        identityTopUpTransition.getIdentityId(),
-        identityTopUpTransition.getExecutionContext(),
-      );
+      expect(stateRepositoryMock.fetchIdentityBalanceWithDebt).to.be.calledOnce();
+      expect(
+        stateRepositoryMock.fetchIdentityBalanceWithDebt.getCall(0).args[0].toBuffer(),
+      ).to.be.deep.equal(identityId);
     });
   });
-
-  it('should throw InvalidStateTransitionTypeError on invalid State Transition', async function it() {
-    const rawStateTransitionMock = {
-      data: 'sample data',
-      type: -1,
-    };
-
-    const stateTransitionMock = {
-      getType: this.sinonSandbox.stub().returns(rawStateTransitionMock.type),
-      toBuffer: this.sinonSandbox.stub().returns(Buffer.alloc(0)),
-      toObject: this.sinonSandbox.stub().returns(rawStateTransitionMock),
-      getExecutionContext: this.sinonSandbox.stub().returns(new StateTransitionExecutionContext()),
-    };
-
-    try {
-      await validateStateTransitionFee(stateTransitionMock);
-
-      expect.fail('should throw InvalidStateTransitionTypeError');
-    } catch (error) {
-      expect(error).to.be.an.instanceOf(InvalidStateTransitionTypeError);
-      expect(error.getType()).to.equal(rawStateTransitionMock.type);
-
-      expect(calculateStateTransitionFeeMock).to.not.be.called();
-      expect(stateRepositoryMock.fetchIdentity).to.not.be.called();
-
-      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
-    }
-  });
 });

package/test/unit/stateTransition/validation/validateStateTransitionKeySignatureFactory.spec.js

@@ -2,7 +2,7 @@ const { Transaction, PrivateKey, Script } = require('@dashevo/dashcore-lib');
 
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
-const getIdentityTopUpTransitionFixture = require('../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
+const getIdentityTopUpTransitionFixture = require('../../../../lib/test/fixtures/getIdentityTopUpTransitionFixtureJs');
 const { expectValidationError } = require('../../../../lib/test/expect/expectError');
 
 const { default: loadWasmDpp } = require('../../../../dist');