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

package/test/integration/identity/validation/validatePublicKeysFactory.spec.js

@@ -1,41 +1,9 @@
-const { getRE2Class } = require('@dashevo/wasm-re2');
-
 const crypto = require('crypto');
 
-const createAjv = require('@dashevo/dpp/lib/ajv/createAjv');
-
-const JsonSchemaValidator = require(
-  '@dashevo/dpp/lib/validation/JsonSchemaValidator',
-);
-
-const validatePublicKeysFactory = require(
-  '@dashevo/dpp/lib/identity/validation/validatePublicKeysFactory',
-);
-
 const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 
-const DuplicatedIdentityPublicKeyError = require(
-  '@dashevo/dpp/lib/errors/consensus/basic/identity/DuplicatedIdentityPublicKeyError',
-);
-const DuplicatedIdentityPublicKeyIdError = require(
-  '@dashevo/dpp/lib/errors/consensus/basic/identity/DuplicatedIdentityPublicKeyIdError',
-);
-
-const InvalidIdentityPublicKeyDataError = require(
-  '@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidIdentityPublicKeyDataError',
-);
-
-const InvalidIdentityPublicKeySecurityLevelError = require(
-  '@dashevo/dpp/lib/errors/consensus/basic/identity/InvalidIdentityPublicKeySecurityLevelError',
-);
-
-const IdentityPublicKey = require(
-  '@dashevo/dpp/lib/identity/IdentityPublicKey',
-);
 const BlsSignatures = require('@dashevo/dpp/lib/bls/bls');
 
-const identityPublicKeySchema = require('@dashevo/dpp/schema/identity/publicKey.json');
-const stateTransitionPublicKeySchema = require('@dashevo/dpp/schema/identity/stateTransition/publicKey.json');
 const {
   expectValidationError,
   expectJsonSchemaError,
@@ -46,24 +14,29 @@ const { default: loadWasmDpp } = require('../../../../dist');
 describe('validatePublicKeysFactory', () => {
   let rawPublicKeys;
   let validatePublicKeys;
-  let validator;
   let bls;
-  let PublicKeysValidator;
   let publicKeysValidator;
-  let InvalidIdentityPublicKeyDataErrorWasm;
+
+  let PublicKeysValidator;
   let PublicKeyValidationError;
+  let IdentityPublicKey;
+
+  let DuplicatedIdentityPublicKeyError;
+  let DuplicatedIdentityPublicKeyIdError;
+  let InvalidIdentityPublicKeyDataError;
+  let InvalidIdentityPublicKeySecurityLevelError;
 
   beforeEach(async () => {
     ({ publicKeys: rawPublicKeys } = getIdentityFixture().toObject());
 
     ({
-      PublicKeysValidator,
-      InvalidIdentityPublicKeyDataError: InvalidIdentityPublicKeyDataErrorWasm,
+      PublicKeysValidator, IdentityPublicKey,
+      InvalidIdentityPublicKeyDataError,
+      DuplicatedIdentityPublicKeyError, DuplicatedIdentityPublicKeyIdError,
+      InvalidIdentityPublicKeyDataError, InvalidIdentityPublicKeySecurityLevelError,
       PublicKeyValidationError,
     } = await loadWasmDpp());
 
-    const RE2 = await getRE2Class();
-    const ajv = createAjv(RE2);
     bls = await BlsSignatures.getInstance();
 
     const blsAdapter = {
@@ -80,23 +53,17 @@ describe('validatePublicKeysFactory', () => {
       },
     };
 
-    validator = new JsonSchemaValidator(ajv);
-
-    validatePublicKeys = validatePublicKeysFactory(
-      validator,
-      identityPublicKeySchema,
-      bls,
-    );
-
     publicKeysValidator = new PublicKeysValidator(blsAdapter);
+
+    validatePublicKeys = (keys) => publicKeysValidator.validateKeys(keys);
   });
 
   describe('id', () => {
-    it('should be present', () => {
+    it('should be present', async () => {
       delete rawPublicKeys[1].id;
 
       const result = publicKeysValidator.validateKeys(rawPublicKeys);
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -105,12 +72,12 @@ describe('validatePublicKeysFactory', () => {
       expect(error.getParams().missingProperty).to.equal('id');
     });
 
-    it('should be a number', () => {
+    it('should be a number', async () => {
       rawPublicKeys[1].id = 'string';
 
       const result = validatePublicKeys(rawPublicKeys);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -118,12 +85,12 @@ describe('validatePublicKeysFactory', () => {
       expect(error.getKeyword()).to.equal('type');
     });
 
-    it('should be an integer', () => {
+    it('should be an integer', async () => {
       rawPublicKeys[1].id = 1.1;
 
       const result = validatePublicKeys(rawPublicKeys);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -131,12 +98,12 @@ describe('validatePublicKeysFactory', () => {
       expect(error.getKeyword()).to.equal('type');
     });
 
-    it('should be greater or equal to one', () => {
+    it('should be greater or equal to one', async () => {
       rawPublicKeys[1].id = -1;
 
       const result = validatePublicKeys(rawPublicKeys);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -146,12 +113,12 @@ describe('validatePublicKeysFactory', () => {
   });
 
   describe('type', () => {
-    it('should be present', () => {
+    it('should be present', async () => {
       delete rawPublicKeys[1].type;
 
       const result = validatePublicKeys(rawPublicKeys);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 4);
 
       const [error] = result.getErrors();
 
@@ -159,27 +126,30 @@ describe('validatePublicKeysFactory', () => {
       expect(error.getKeyword()).to.equal('minItems');
     });
 
-    it('should be a number', () => {
+    it('should be a number', async () => {
       rawPublicKeys[1].type = 'string';
 
       const result = validatePublicKeys(rawPublicKeys);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result, 2);
 
-      const [error] = result.getErrors();
+      const [typeError, enumError] = result.getErrors();
 
-      expect(error.getInstancePath()).to.equal('/type');
-      expect(error.getKeyword()).to.equal('type');
+      expect(typeError.getInstancePath()).to.equal('/type');
+      expect(typeError.getKeyword()).to.equal('type');
+
+      expect(enumError.getInstancePath()).to.equal('/type');
+      expect(enumError.getKeyword()).to.equal('enum');
     });
   });
 
   describe('data', () => {
-    it('should be present', () => {
+    it('should be present', async () => {
       delete rawPublicKeys[1].data;
 
       const result = validatePublicKeys(rawPublicKeys);
 
-      expectJsonSchemaError(result);
+      await expectJsonSchemaError(result);
 
       const [error] = result.getErrors();
 
@@ -188,28 +158,29 @@ describe('validatePublicKeysFactory', () => {
       expect(error.getParams().missingProperty).to.equal('data');
     });
 
-    it('should be a byte array', () => {
+    it('should be a byte array', async () => {
       rawPublicKeys[1].data = new Array(33).fill('string');
 
       const result = validatePublicKeys(rawPublicKeys);
 
-      expectJsonSchemaError(result, 2);
+      await expectJsonSchemaError(result, 33);
 
       const [error, byteArrayError] = result.getErrors();
 
       expect(error.getInstancePath()).to.equal('/data/0');
       expect(error.getKeyword()).to.equal('type');
 
-      expect(byteArrayError.getKeyword()).to.equal('byteArray');
+      expect(byteArrayError.getInstancePath()).to.equal('/data/1');
+      expect(byteArrayError.getKeyword()).to.equal('type');
     });
 
     describe('ECDSA_SECP256K1', () => {
-      it('should be no less than 33 bytes', () => {
+      it('should be no less than 33 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(32);
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -217,12 +188,12 @@ describe('validatePublicKeysFactory', () => {
         expect(error.getKeyword()).to.equal('minItems');
       });
 
-      it('should be no longer than 33 bytes', () => {
+      it('should be no longer than 33 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(34);
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -232,13 +203,13 @@ describe('validatePublicKeysFactory', () => {
     });
 
     describe('BLS12_381', () => {
-      it('should be no less than 48 bytes', () => {
+      it('should be no less than 48 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(47);
         rawPublicKeys[1].type = 1;
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -246,13 +217,13 @@ describe('validatePublicKeysFactory', () => {
         expect(error.getKeyword()).to.equal('minItems');
       });
 
-      it('should be no longer than 48 bytes', () => {
+      it('should be no longer than 48 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(49);
         rawPublicKeys[1].type = 1;
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -262,13 +233,13 @@ describe('validatePublicKeysFactory', () => {
     });
 
     describe('ECDSA_HASH160', () => {
-      it('should be no less than 20 bytes', () => {
+      it('should be no less than 20 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(19);
         rawPublicKeys[1].type = 2;
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -276,13 +247,13 @@ describe('validatePublicKeysFactory', () => {
         expect(error.getKeyword()).to.equal('minItems');
       });
 
-      it('should be no longer than 20 bytes', () => {
+      it('should be no longer than 20 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(21);
         rawPublicKeys[1].type = 2;
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -292,13 +263,13 @@ describe('validatePublicKeysFactory', () => {
     });
 
     describe('BIP13_SCRIPT_HASH', () => {
-      it('should be no less than 20 bytes', () => {
+      it('should be no less than 20 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(19);
         rawPublicKeys[1].type = 3;
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -306,13 +277,13 @@ describe('validatePublicKeysFactory', () => {
         expect(error.getKeyword()).to.equal('minItems');
       });
 
-      it('should be no longer than 20 bytes', () => {
+      it('should be no longer than 20 bytes', async () => {
         rawPublicKeys[1].data = Buffer.alloc(21);
         rawPublicKeys[1].type = 3;
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
@@ -322,12 +293,12 @@ describe('validatePublicKeysFactory', () => {
     });
   });
 
-  it('should return invalid result if there are duplicate key ids', () => {
+  it('should return invalid result if there are duplicate key ids', async () => {
     rawPublicKeys[1].id = rawPublicKeys[0].id;
 
     const result = validatePublicKeys(rawPublicKeys);
 
-    expectValidationError(result, DuplicatedIdentityPublicKeyIdError);
+    await expectValidationError(result, DuplicatedIdentityPublicKeyIdError);
 
     const [error] = result.getErrors();
 
@@ -335,12 +306,12 @@ describe('validatePublicKeysFactory', () => {
     expect(error.getDuplicatedIds()).to.deep.equal([rawPublicKeys[1].id]);
   });
 
-  it('should return invalid result if there are duplicate keys', () => {
+  it('should return invalid result if there are duplicate keys', async () => {
     rawPublicKeys[1].data = rawPublicKeys[0].data;
 
     const result = validatePublicKeys(rawPublicKeys);
 
-    expectValidationError(result, DuplicatedIdentityPublicKeyError);
+    await expectValidationError(result, DuplicatedIdentityPublicKeyError);
 
     const [error] = result.getErrors();
 
@@ -348,28 +319,28 @@ describe('validatePublicKeysFactory', () => {
     expect(error.getDuplicatedPublicKeysIds()).to.deep.equal([rawPublicKeys[1].id]);
   });
 
-  it('should return invalid result if key data is not a valid DER', () => {
+  it('should return invalid result if key data is not a valid DER', async () => {
     rawPublicKeys[1].data = Buffer.alloc(33);
 
     const result = validatePublicKeys(rawPublicKeys);
 
-    expectValidationError(result, InvalidIdentityPublicKeyDataError);
+    await expectValidationError(result, InvalidIdentityPublicKeyDataError);
 
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(1040);
     expect(error.getPublicKeyId()).to.deep.equal(rawPublicKeys[1].id);
-    expect(error.getValidationError()).to.be.instanceOf(TypeError);
-    expect(error.getValidationError().message).to.equal('Invalid DER format public key');
+    expect(error.getValidationError()).to.be.instanceOf(PublicKeyValidationError);
+    expect(error.getValidationError().message).to.equal('Key secp256k1 error: malformed public key');
   });
 
-  it('should return invalid result if key has an invalid combination of purpose and security level', () => {
+  it('should return invalid result if key has an invalid combination of purpose and security level', async () => {
     rawPublicKeys[1].purpose = IdentityPublicKey.PURPOSES.ENCRYPTION;
     rawPublicKeys[1].securityLevel = IdentityPublicKey.SECURITY_LEVELS.MASTER;
 
     const result = validatePublicKeys(rawPublicKeys);
 
-    expectValidationError(result, InvalidIdentityPublicKeySecurityLevelError);
+    await expectValidationError(result, InvalidIdentityPublicKeySecurityLevelError);
 
     const [error] = result.getErrors();
 
@@ -395,7 +366,7 @@ describe('validatePublicKeysFactory', () => {
       data: Buffer.from('01fac99ca2c8f39c286717c213e190aba4b7af76db320ec43f479b7d9a2012313a0ae59ca576edf801444bc694686694', 'hex'),
     }];
 
-    const result = publicKeysValidator.validateKeys(rawPublicKeys);
+    const result = validatePublicKeys(rawPublicKeys);
 
     expect(result.isValid()).to.be.true();
   });
@@ -427,7 +398,7 @@ describe('validatePublicKeysFactory', () => {
 
     const result = publicKeysValidator.validateKeys(rawPublicKeys);
 
-    await expectValidationError(result, InvalidIdentityPublicKeyDataErrorWasm);
+    await expectValidationError(result, InvalidIdentityPublicKeyDataError);
 
     const [error] = result.getErrors();
 
@@ -451,11 +422,7 @@ describe('validatePublicKeysFactory', () => {
 
   describe('State Transition Schema', () => {
     beforeEach(() => {
-      validatePublicKeys = validatePublicKeysFactory(
-        validator,
-        stateTransitionPublicKeySchema,
-        bls,
-      );
+      validatePublicKeys = (keys) => publicKeysValidator.validateKeysInStateTransition(keys);
 
       rawPublicKeys.forEach((rawPublicKey) => {
         // eslint-disable-next-line no-param-reassign
@@ -464,16 +431,16 @@ describe('validatePublicKeysFactory', () => {
     });
 
     describe('signature', () => {
-      it('should be present', () => {
+      it('should be present', async () => {
         delete rawPublicKeys[0].signature;
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('');
+        expect(error.getInstancePath()).to.equal('');
         expect(error.getKeyword()).to.equal('required');
         expect(error.getParams().missingProperty).to.equal('signature');
       });
@@ -483,39 +450,37 @@ describe('validatePublicKeysFactory', () => {
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result, 2);
+        await expectJsonSchemaError(result, 65);
 
-        const [error, byteArrayError] = result.getErrors();
+        const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/signature/0');
         expect(error.getKeyword()).to.equal('type');
-
-        expect(byteArrayError.getKeyword()).to.equal('byteArray');
+        expect(error.getInstancePath()).to.equal('/signature/0');
       });
 
-      it('should be not shorter than 65 bytes', () => {
+      it('should be not shorter than 65 bytes', async () => {
         rawPublicKeys[0].signature = Buffer.alloc(64);
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/signature');
+        expect(error.getInstancePath()).to.equal('/signature');
         expect(error.getKeyword()).to.equal('minItems');
       });
 
-      it('should be not longer than 65 bytes', () => {
+      it('should be not longer than 65 bytes', async () => {
         rawPublicKeys[0].signature = Buffer.alloc(66);
 
         const result = validatePublicKeys(rawPublicKeys);
 
-        expectJsonSchemaError(result);
+        await expectJsonSchemaError(result);
 
         const [error] = result.getErrors();
 
-        expect(error.instancePath).to.equal('/signature');
+        expect(error.getInstancePath()).to.equal('/signature');
         expect(error.getKeyword()).to.equal('maxItems');
       });
     });

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

@@ -1,7 +1,6 @@
 const { PrivateKey, crypto: { Hash } } = require('@dashevo/dashcore-lib');
 
 const crypto = require('crypto');
-const calculateStateTransitionFee = require('@dashevo/dpp/lib/stateTransition/fee/calculateStateTransitionFee');
 
 const StateTransitionMock = require('@dashevo/dpp/lib/test/mocks/StateTransitionMock');
 const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
@@ -494,14 +493,4 @@ describe('AbstractStateTransitionIdentitySigned', () => {
       expect(stateTransition.signaturePublicKeyId).to.equal(signaturePublicKeyId);
     });
   });
-
-  describe('#calculateFee', () => {
-    it('should calculate fee', () => {
-      const result = stateTransition.calculateFee();
-
-      const fee = calculateStateTransitionFee(stateTransition);
-
-      expect(result).to.equal(fee);
-    });
-  });
 });

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

@@ -71,7 +71,7 @@ describe('StateTransitionFacade', () => {
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
     stateRepositoryMock.fetchIdentity.resolves(identity);
-    stateRepositoryMock.fetchLatestPlatformBlockTime.returns(blockTime);
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
 
     dpp = new DashPlatformProtocol({
       stateRepository: stateRepositoryMock,

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

@@ -0,0 +1,135 @@
+const calculateStateTransitionFeeFactory = require('@dashevo/dpp/lib/stateTransition/fee/calculateStateTransitionFeeFactory');
+
+const getIdentityCreateTransitionFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityCreateTransitionFixture');
+const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
+
+const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+
+describe('calculateStateTransitionFeeFactory', () => {
+  let stateTransition;
+  let calculateStateTransitionFee;
+  let stateRepositoryMock;
+  let calculateOperationFeesMock;
+
+  beforeEach(async function beforeEach() {
+    const privateKey = 'af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837';
+
+    stateTransition = getIdentityCreateTransitionFixture();
+    await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    calculateOperationFeesMock = this.sinonSandbox.stub();
+
+    calculateStateTransitionFee = calculateStateTransitionFeeFactory(
+      stateRepositoryMock,
+      calculateOperationFeesMock,
+    );
+  });
+
+  it('should throw an error if more than two identities have refunds', async () => {
+    const calculatedOperationsFeesResult = {
+      storageFee: 10000,
+      processingFee: 1000,
+      feeRefunds: [
+        {
+          identifier: stateTransition.getOwnerId().toBuffer(),
+          creditsPerEpoch: {
+            0: -100,
+            1: -50,
+          },
+        },
+        {
+          identifier: stateTransition.getOwnerId().toBuffer(),
+          creditsPerEpoch: {
+            1: -50,
+          },
+        },
+      ],
+    };
+
+    calculateOperationFeesMock.returns(calculatedOperationsFeesResult);
+
+    try {
+      await calculateStateTransitionFee(stateTransition);
+
+      expect.fail('should fail');
+    } catch (e) {
+      expect(e.message).to.equals('State Transition removed bytes from several identities that is not defined by protocol');
+    }
+  });
+
+  it('should throw an error if refunded identity is not owner of state transition', async () => {
+    const calculatedOperationsFeesResult = {
+      storageFee: 10000,
+      processingFee: 1000,
+      feeRefunds: [
+        {
+          identifier: Buffer.alloc(32, 1),
+          creditsPerEpoch: {
+            0: -100,
+            1: -50,
+          },
+        },
+      ],
+    };
+
+    calculateOperationFeesMock.returns(calculatedOperationsFeesResult);
+
+    try {
+      await calculateStateTransitionFee(stateTransition);
+
+      expect.fail('should fail');
+    } catch (e) {
+      expect(e.message).to.equals('State Transition removed bytes from different identity');
+    }
+  });
+
+  it('should calculate fee based on executed operations', async () => {
+    const storageFee = 10000;
+    const processingFee = 1000;
+    const feeRefundsSum = 450 + 995 + 400 + 400;
+    const total = storageFee + processingFee - feeRefundsSum;
+
+    const calculatedOperationsFeesResult = {
+      storageFee,
+      processingFee,
+      feeRefunds: [
+        {
+          identifier: stateTransition.getOwnerId().toBuffer(),
+          creditsPerEpoch: {
+            0: 1000,
+            1: 500,
+          },
+        },
+      ],
+    };
+
+    calculateOperationFeesMock.returns(calculatedOperationsFeesResult);
+
+    stateRepositoryMock.calculateStorageFeeDistributionAmountAndLeftovers
+      .onCall(0).resolves([995, 400]);
+
+    stateRepositoryMock.calculateStorageFeeDistributionAmountAndLeftovers
+      .onCall(1).resolves([450, 400]);
+
+    const result = await calculateStateTransitionFee(stateTransition);
+
+    expect(result).to.equal(total);
+
+    expect(stateRepositoryMock.calculateStorageFeeDistributionAmountAndLeftovers)
+      .to.have.been.calledWithExactly(1000, 0);
+
+    expect(stateRepositoryMock.calculateStorageFeeDistributionAmountAndLeftovers)
+      .to.have.been.calledWithExactly(500, 1);
+
+    const lastCalculatedFeeDetails = stateTransition.getExecutionContext()
+      .getLastCalculatedFeeDetails();
+
+    expect(lastCalculatedFeeDetails).to.be.deep.equal({
+      ...calculatedOperationsFeesResult,
+      feeRefundsSum,
+      total,
+    });
+  });
+});