git.delta.rocks / unique-network / refs/commits / 96e033fd9b70

--- a/.docker/Dockerfile-chain-dev
+++ b/.docker/Dockerfile-chain-dev
@@ -1,17 +1,19 @@
 FROM ubuntu:20.04
 
+ARG RUST_TOOLCHAIN=
+ARG FEATURE=
+
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC
-
-RUN apt-get update && apt-get install -y git curl libssl-dev llvm pkg-config libclang-dev clang git make cmake
-
+ENV FEATURE=$FEATURE
 ENV CARGO_HOME="/cargo-home"
 ENV PATH="/cargo-home/bin:$PATH"
 
-RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+RUN echo "$FEATURE\n" && echo "$RUST_TOOLCHAIN\n"
 
-ARG RUST_TOOLCHAIN=
-ARG FEATURE=
+RUN apt-get update && apt-get install -y git curl libssl-dev llvm pkg-config libclang-dev clang git make cmake
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
 
 RUN rustup toolchain uninstall $(rustup toolchain list) && \
     rustup toolchain install $RUST_TOOLCHAIN && \
@@ -24,5 +26,6 @@
 WORKDIR /dev_chain
 
 RUN cargo build --release
+RUN echo "$FEATURE"
 
 CMD cargo run --release --features=$FEATURE -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external

--- a/.docker/docker-compose.tmp-dev.j2
+++ b/.docker/docker-compose.tmp-dev.j2
@@ -18,4 +18,4 @@
       options:
         max-size: "1m"
         max-file: "3"
-    command: cargo run --release --features=$FEATURE -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external
+    command: cargo run --release --features={{ FEATURE }} -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external

--- a/.github/workflows/ci-master.yml
+++ b/.github/workflows/ci-master.yml
@@ -18,16 +18,13 @@
     uses: ./.github/workflows/node-only-update_v2.yml
 
   forkless:
-    if: ${{ contains( github.event.pull_request.labels.*.name, 'forkless') }}
     uses: ./.github/workflows/forkless.yml
 
   canary:
-    if: ${{ contains( github.event.pull_request.labels.*.name, 'canary') }}
     uses: ./.github/workflows/canary.yml
     secrets: inherit # pass all secrets
 
   xcm:
-    if: ${{ contains( github.event.pull_request.labels.*.name, 'xcm') }}
     uses: ./.github/workflows/xcm.yml
     secrets: inherit # pass all secrets
 

--- a/.github/workflows/dev-build-tests_v2.yml
+++ b/.github/workflows/dev-build-tests_v2.yml
@@ -95,3 +95,10 @@
       - name: Stop running containers
         if: always()                   # run this step always
         run: docker-compose -f ".docker/docker-compose-dev.yaml" -f ".docker/docker-compose.${{ matrix.network }}.yml" down
+
+      - name: Remove builder cache
+        if: always()                   # run this step always
+        run: |
+          docker builder prune -f -a
+          docker system prune -f
+          docker image prune -f -a
\ No newline at end of file

--- a/.github/workflows/market-test_v2.yml
+++ b/.github/workflows/market-test_v2.yml
@@ -45,7 +45,7 @@
           repository: 'UniqueNetwork/market-e2e-tests'
           ssh-key: ${{ secrets.GH_PAT }}
           path: 'qa-tests'
-          ref: 'ci_test_v2'
+          ref: 'master'
 
       - name: Read .env file
         uses: xom9ikk/dotenv@v1.0.2

--- a/.github/workflows/node-only-update_v2.yml
+++ b/.github/workflows/node-only-update_v2.yml
@@ -10,7 +10,7 @@
 # A workflow run is made up of one or more jobs that can run sequentially or in parallel
 jobs:
 
-  execution-marix:
+  nodes-execution-matrix:
 
     name: execution matrix
 
@@ -42,8 +42,8 @@
 
 
 
-  forkless-update-nodata:
-    needs: execution-marix
+  nodes-only-update:
+    needs: nodes-execution-matrix
     # The type of runner that the job will run on
     runs-on: [self-hosted-ci,large]
 
@@ -57,7 +57,7 @@
 
     strategy:
       matrix:
-        include: ${{fromJson(needs.prepare-execution-marix.outputs.matrix)}}
+        include: ${{fromJson(needs.nodes-execution-matrix.outputs.matrix)}}
 
     steps:
 
@@ -156,12 +156,18 @@
           exit 0
         shell: bash
 
+      - name: Checkout at '${{ matrix.mainnet_branch }}' branch
+        uses: actions/checkout@master
+        with:
+          ref: ${{ matrix.mainnet_branch }}  #Checking out head commit
+          path: ${{ matrix.mainnet_branch }}
+
+
       - name: Run tests before Node Parachain upgrade
-        working-directory: tests
+        working-directory: ${{ matrix.mainnet_branch }}/tests
         run: |
           yarn install
           yarn add mochawesome
-          node scripts/readyness.js
           echo "Ready to start tests"
           yarn polkadot-types
           NOW=$(date +%s) && yarn test --reporter mochawesome --reporter-options reportFilename=test-${NOW}
@@ -174,7 +180,7 @@
         if: success() || failure()    # run this step even if previous step failed
         with:
           name: Tests before node upgrade ${{ matrix.network }}            # Name of the check run which will be created
-          path: tests/mochawesome-report/test-*.json    # Path to test results
+          path: ${{ matrix.mainnet_branch }}/tests/mochawesome-report/test-*.json    # Path to test results
           reporter: mochawesome-json
           fail-on-error: 'false'
 
@@ -263,8 +269,9 @@
       - name: Remove builder cache
         if: always()                   # run this step always
         run: |
-          docker builder prune -f
+          docker builder prune -f -a
           docker system prune -f
+          docker image prune -f -a
 
       - name: Clean Workspace
         if: always()

--- a/pallets/app-promotion/Cargo.toml
+++ b/pallets/app-promotion/Cargo.toml
@@ -68,4 +68,6 @@
 pallet-evm-contract-helpers ={ default-features = false, path = "../evm-contract-helpers" }
 pallet-evm-migration ={ default-features = false, path = "../evm-migration" }
 
+# [dev-dependencies]
+
 ################################################################################

--- a/runtime/common/mod.rs
+++ b/runtime/common/mod.rs
@@ -82,7 +82,7 @@
 
 pub type SignedExtra = (
 	frame_system::CheckSpecVersion<Runtime>,
-	// system::CheckTxVersion<Runtime>,
+	frame_system::CheckTxVersion<Runtime>,
 	frame_system::CheckGenesis<Runtime>,
 	frame_system::CheckEra<Runtime>,
 	frame_system::CheckNonce<Runtime>,

--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/src/lib.rs
@@ -50,7 +50,7 @@
 	spec_name: create_runtime_str!(RUNTIME_NAME),
 	impl_name: create_runtime_str!(RUNTIME_NAME),
 	authoring_version: 1,
-	spec_version: 927020,
+	spec_version: 927030,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 2,

--- a/runtime/quartz/src/lib.rs
+++ b/runtime/quartz/src/lib.rs
@@ -50,7 +50,7 @@
 	spec_name: create_runtime_str!(RUNTIME_NAME),
 	impl_name: create_runtime_str!(RUNTIME_NAME),
 	authoring_version: 1,
-	spec_version: 927020,
+	spec_version: 927030,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 2,

--- a/runtime/unique/src/lib.rs
+++ b/runtime/unique/src/lib.rs
@@ -50,7 +50,7 @@
 	spec_name: create_runtime_str!(RUNTIME_NAME),
 	impl_name: create_runtime_str!(RUNTIME_NAME),
 	authoring_version: 1,
-	spec_version: 927020,
+	spec_version: 927030,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 2,

--- a/tests/src/adminTransferAndBurn.test.ts
+++ b/tests/src/adminTransferAndBurn.test.ts
@@ -24,19 +24,14 @@
 
 let donor: IKeyringPair;
 
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
 describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
   let charlie: IKeyringPair;
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });

--- a/tests/src/allowLists.test.ts
+++ b/tests/src/allowLists.test.ts
@@ -24,12 +24,6 @@
 
 let donor: IKeyringPair;
 
-before(async () => {
-  await usingPlaygrounds(async (_, privateKey) => {
-    donor = privateKey('//Alice');
-  });
-});
-
 let alice: IKeyringPair;
 let bob: IKeyringPair;
 let charlie: IKeyringPair;
@@ -37,7 +31,8 @@
 describe('Integration Test ext. Allow list tests', () => {
 
   before(async () => {
-    await usingPlaygrounds(async (helper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });

--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -20,17 +20,12 @@
   getModuleNames,
   Pallets,
 } from './util/helpers';
-
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
-
+import {itSub, usingPlaygrounds} from './util/playgrounds';
 import {encodeAddress} from '@polkadot/util-crypto';
 import {stringToU8a} from '@polkadot/util';
-import {SponsoringMode, contractHelpers, createEthAccountWithBalance, deployFlipper, itWeb3, transferBalanceToEth} from './eth/util/helpers';
+import {SponsoringMode} from './eth/util/helpers';
 import {DevUniqueHelper} from './util/playgrounds/unique.dev';
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {itEth, expect} from './eth/util/playgrounds';
 
 let alice: IKeyringPair;
 let palletAdmin: IKeyringPair;
@@ -38,723 +33,652 @@
 const palletAddress = calculatePalleteAddress('appstake');
 let accounts: IKeyringPair[] = [];
 const LOCKING_PERIOD = 20n; // 20 blocks of relay
-const UNLOCKING_PERIOD = 10n; // 20 blocks of parachain
+const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain
 const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);
 
-const beforeEach = async (context: Mocha.Context) => {
-  await usingPlaygrounds(async (helper, privateKey) => {
-    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) context.skip();
-    alice = privateKey('//Alice');
-    palletAdmin = privateKey('//Charlie'); // TODO use custom address
-    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
-    nominal = helper.balance.getOneTokenNominal();
-    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);
-    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);
-    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests
-  });
-};
-
-describe('app-promotions.stake extrinsic', () => {
+describe('App promotion', () => {
   before(async function () {
-    await beforeEach(this);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();
+      alice = privateKey('//Alice');
+      palletAdmin = privateKey('//Charlie'); // TODO use custom address
+      await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
+      nominal = helper.balance.getOneTokenNominal();
+      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);
+      await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);
+      accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests
+    });
   });
 
-  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {
-    await usingPlaygrounds(async (helper) => {
+  describe('stake extrinsic', () => {  
+    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {
       const [staker, recepient] = [accounts.pop()!, accounts.pop()!];
       const totalStakedBefore = await helper.staking.getTotalStaked();
-
+  
       // Minimum stake amount is 100:
-      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;
+      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;
       await helper.staking.stake(staker, 100n * nominal);
-
+  
       // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...
       // ...so he can not transfer 900
       expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});
-      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;
+      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');
       
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);
       expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);
       // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 
       expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 
-
+  
       
       await helper.staking.stake(staker, 200n * nominal);
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);
-      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);
+      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);
+      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);
     });
-  });
-
-  it('should allow to create maximum 10 stakes for account', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {
       const [staker] = await helper.arrange.createAccounts([2000n], alice);
       for (let i = 0; i < 10; i++) {
         await helper.staking.stake(staker, 100n * nominal);
       }
-
+  
       // can have 10 stakes
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);
       expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);
-
-      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;
-
+  
+      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');
+  
       // After unstake can stake again
       await helper.staking.unstake(staker);
       await helper.staking.stake(staker, 100n * nominal);
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);
     });
-  });
+    
+    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {
+      const staker = accounts.pop()!;
   
-  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {
-    await usingPlaygrounds(async helper => { 
-      const staker = accounts.pop()!;
-
       // Can't stake full balance because Alice needs to pay some fee
-      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;
+      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;
       await helper.staking.stake(staker, 500n * nominal);
-
+  
       // Can't stake 500 tkn because Alice has Less than 500 transferable;
-      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 
+      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);
     });
-  });
-  
-  it('for different accounts in one block is possible', async () => {
-    await usingPlaygrounds(async helper => {
+    
+    itSub('for different accounts in one block is possible', async ({helper}) => {
       const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];
-      
+        
       const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));
-      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;
-
+      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;
+  
       const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));
       expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);
     });
   });
-});
-
-describe('unstake balance extrinsic', () => {  
-  before(async function () {
-    await beforeEach(this);
-  });
-
-  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {
-    await usingPlaygrounds(async helper => {
+  
+  describe('unstake extrinsic', () => {  
+    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {
       const [staker, recepient] = [accounts.pop()!, accounts.pop()!];
       const totalStakedBefore = await helper.staking.getTotalStaked();
       await helper.staking.stake(staker, 900n * nominal);
       await helper.staking.unstake(staker);
-
+  
       // Right after unstake balance is reserved
       // Staker can not transfer 
       expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});
-      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;
+      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');
       expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);
       expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);
     });
-  });
-
-  it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {
       const staker = accounts.pop()!;
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.unstake(staker);
-      const unstakedInBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];
-
+      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});
+  
       // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n
-      await helper.wait.forParachainBlockNumber(unstakedInBlock);
+      await helper.wait.forParachainBlockNumber(pendingUnstake.block);
       expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});
       expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);
-
+  
       // staker can transfer:
       await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);
       expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);
     });
-  });
-
-  it('should successfully unstake multiple stakes', async () => {
-    await usingPlaygrounds(async helper => {
+  
+    itSub('should successfully unstake multiple stakes', async ({helper}) => {
       const staker = accounts.pop()!;
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.stake(staker, 200n * nominal);
       await helper.staking.stake(staker, 300n * nominal);
-
+  
       // staked: [100, 200, 300]; unstaked: 0
-      let pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});
-      let unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);
-      let stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);
-      expect(pendingUnstake).to.be.deep.equal(0n);
-      expect(unstakedPerBlock).to.be.deep.equal([]);
-      expect(stakedPerBlock).to.be.deep.equal([100n * nominal, 200n * nominal, 300n * nominal]);
-     
+      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});
+      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});
+      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      expect(totalPendingUnstake).to.be.deep.equal(0n);
+      expect(pendingUnstake).to.be.deep.equal([]);
+      expect(stakes[0].amount).to.equal(100n * nominal);
+      expect(stakes[1].amount).to.equal(200n * nominal);
+      expect(stakes[2].amount).to.equal(300n * nominal);
+       
       // Can unstake multiple stakes
       await helper.staking.unstake(staker);
-      const unstakingBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];
-      pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});
-      unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);
-      stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);
-      expect(pendingUnstake).to.be.equal(600n * nominal);
-      expect(stakedPerBlock).to.be.deep.equal([]);
-      expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]);
-
+      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});
+      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});
+      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      expect(totalPendingUnstake).to.be.equal(600n * nominal);
+      expect(stakes).to.be.deep.equal([]);
+      expect(pendingUnstake[0].amount).to.equal(600n * nominal);
+  
       expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});
-      await helper.wait.forParachainBlockNumber(unstakingBlock);
+      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);
       expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});
       expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);
     });
-  });
-
-  it('should not have any effects if no active stakes', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should not have any effects if no active stakes', async ({helper}) => {
       const staker = accounts.pop()!;
-      
+        
       // unstake has no effect if no stakes at all
       await helper.staking.unstake(staker);
       expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);
       expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper
-
+  
       // TODO stake() unstake() waitUnstaked() unstake();
-
+  
       // can't unstake if there are only pendingUnstakes
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.unstake(staker);
       await helper.staking.unstake(staker);
-
+  
       expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);
     });
-  });
-
-  it('should keep different unlocking block for each unlocking stake', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {
       const staker = accounts.pop()!;
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.unstake(staker);
       await helper.staking.stake(staker, 120n * nominal);
       await helper.staking.unstake(staker);
-
+  
       const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});
       expect(unstakingPerBlock).has.length(2);
-      expect(unstakingPerBlock[0][1]).to.equal(100n * nominal);
-      expect(unstakingPerBlock[1][1]).to.equal(120n * nominal);
+      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);
+      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);
     });
-  });
-
-  it('should be possible for different accounts in one block', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should be possible for different accounts in one block', async ({helper}) => {
       const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
-
+  
       await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));
       await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));
-
+  
       await Promise.all(stakers.map(async (staker) => {
         expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);
         expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);
       }));
     });
   });
-});
-
-describe('Admin adress', () => {
-  before(async function () {
-    await beforeEach(this);
-  });
-
-  it('can be set by sudo only', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+  describe('admin adress', () => {
+    itSub('can be set by sudo only', async ({helper}) => {
       const nonAdmin = accounts.pop()!;
       // nonAdmin can not set admin not from himself nor as a sudo
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;
-
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;
+  
       // Alice can
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;
     });
-  });
-  
-  it('can be any valid CrossAccountId', async () => {
-    // We are not going to set an eth address as a sponsor,
-    // but we do want to check, it doesn't break anything;
-    await usingPlaygrounds(async (helper) => {
+    
+    itSub('can be any valid CrossAccountId', async ({helper}) => {
+      // We are not going to set an eth address as a sponsor,
+      // but we do want to check, it doesn't break anything;
       const account = accounts.pop()!;
       const ethAccount = helper.address.substrateToEth(account.address); 
       // Alice sets Ethereum address as a sudo. Then Substrate address back...
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;
-      
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;
+        
       // ...It doesn't break anything;
       const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
-      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
     });
-  });
-
-  it('can be reassigned', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('can be reassigned', async ({helper}) => {
       const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
       const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
-      
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;
-      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;
-      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
-      
-      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
+        
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.fulfilled;
+      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.fulfilled;
+      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
+        
+      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;
     });
   });
-});
-
-describe('App-promotion collection sponsoring', () => {
-  before(async function () {
-    await beforeEach(this);
-    await usingPlaygrounds(async (helper) => {
-      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));
-      await helper.signTransaction(alice, tx);
+  
+  describe('collection sponsoring', () => {
+    before(async function () {
+      await usingPlaygrounds(async (helper) => {
+        const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));
+        await helper.signTransaction(alice, tx);
+      });
     });
-  });
-
-  it('should actually sponsor transactions', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should actually sponsor transactions', async ({helper}) => {
       const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});
       const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});
       await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));
       const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);
-
+  
       await token.transfer(tokenSender, {Substrate: receiver.address});
       expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});
       const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);
-
+  
       // senders balance the same, transaction has sponsored
       expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);
       expect (palletBalanceBefore > palletBalanceAfter).to.be.true;
     });
-  });
-
-  it('can not be set by non admin', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('can not be set by non admin', async ({helper}) => {
       const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];
-
+  
       const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
-      
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+        
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
       expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');
     });
-  });
-
-  it('should set pallet address as confirmed admin', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should set pallet address as confirmed admin', async ({helper}) => {
       const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];
-      
+        
       // Can set sponsoring for collection without sponsor
       const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;
       expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
-
+  
       // Can set sponsoring for collection with unconfirmed sponsor
       const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
       expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;
       expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
-
+  
       // Can set sponsoring for collection with confirmed sponsor
       const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});
       await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;
       expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
     });
-  });
-
-  it('can be overwritten by collection owner', async () => {    
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('can be overwritten by collection owner', async ({helper}) => {    
       const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];
       const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       const collectionId = collection.collectionId;
-      
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;
-      
+        
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;
+        
       // Collection limits still can be changed by the owner
       expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;
       expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);
       expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
-
+  
       // Collection sponsor can be changed too
       expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;
       expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});
     });
-  });
-  
-  it('should not overwrite collection limits set by the owner earlier', async () => {
-    await usingPlaygrounds(async (helper) => {
+    
+    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {
       const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};
       const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});
-
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;
+  
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;
       expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);
     });
-  });
-  
-  it('should reject transaction if collection doesn\'t exist', async () => {
-    await usingPlaygrounds(async (helper) => {
+    
+    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {
       const collectionOwner = accounts.pop()!;
-      
+        
       // collection has never existed
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;
       // collection has been burned
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
       await collection.burn(collectionOwner);
-
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;
+  
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
     });
   });
-});
-
-describe('app-promotion stopSponsoringCollection', () => {
-  before(async function () {
-    await beforeEach(this);
-  });
-
-  it('can not be called by non-admin', async () => {    
-    await usingPlaygrounds(async (helper) => {
+  
+  describe('stopSponsoringCollection', () => {
+    itSub('can not be called by non-admin', async ({helper}) => {    
       const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
-      
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;
-      
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
+        
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;
+        
+      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;
       expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});
     });
-  });
-
-  it('should set sponsoring as disabled', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should set sponsoring as disabled', async ({helper}) => {
       const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});
       const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});
-      
+        
       await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));
       await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));
-      
+        
       expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');
-
+  
       // Transactions are not sponsored anymore:
       const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);
       await token.transfer(collectionOwner, {Substrate: recepient.address});
       const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);
       expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);
     });
-  });
-
-  it('should not affect collection which is not sponsored by pallete', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {
       const collectionOwner = accounts.pop()!;
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});
       await collection.confirmSponsorship(collectionOwner);
-      
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
-      
+        
+      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;
+        
       expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});
     });
-  });
-
-  it('should reject transaction if collection does not exist', async () => {    
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('should reject transaction if collection does not exist', async ({helper}) => {    
       const collectionOwner = accounts.pop()!;
       const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});
-      
+        
       await collection.burn(collectionOwner);
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;
-      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;
+      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');
+      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');
     });
   });
-});
-
-describe('app-promotion contract sponsoring', () => {
-  before(async function () {
-    await beforeEach(this);
-  });
-
-  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-      const contractMethods = contractHelpers(web3, contractOwner);
-
-      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));
+  
+  describe('contract sponsoring', () => {
+    itEth('should set palletes address as a sponsor', async ({helper}) => {
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);
+      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);
+  
+      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);
       
-      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
-      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
-      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
+      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
+      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
+      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
         confirmed: {
           substrate: palletAddress,
         },
       });
     });
-  });
-
-  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-      const contractMethods = contractHelpers(web3, contractOwner);
-
-      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
-
+  
+    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);
+      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);
+  
+      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;
+  
       // Contract is self sponsored
-      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({
+      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({
         confirmed: {
           ethereum: flipper.options.address.toLowerCase(),
         },
       });
-
+  
       // set promotion sponsoring
-      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));
-
+      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);
+  
       // new sponsor is pallet address
-      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
-      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
-      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
+      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
+      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  
+      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({
         confirmed: {
           substrate: palletAddress,
         },
       });
     });
-  });
-
-  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {      
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-      const contractMethods = contractHelpers(web3, contractOwner);
-
+  
+    itEth('can be overwritten by contract owner', async ({helper}) => {
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);
+      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);
+  
       // contract sponsored by pallet
-      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));
-
+      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);
+  
       // owner sets self sponsoring
-      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
-
-      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
-      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
-      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
+      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
+  
+      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  
+      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
+      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
         confirmed: {
           ethereum: flipper.options.address.toLowerCase(),
         },
       });
     });
-  });
-
-  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {      
+  
+    itEth('can not be set by non admin', async ({helper}) => {
       const nonAdmin = accounts.pop()!;
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-      const contractMethods = contractHelpers(web3, contractOwner);
-
-      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
-
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);
+      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);
+  
+      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;
+  
       // nonAdmin calls sponsorContract
-      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address))).to.be.rejected;
-
+      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');
+  
       // contract still self-sponsored 
-      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
+      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
         confirmed: {
           ethereum: flipper.options.address.toLowerCase(),
         },
       });
     });
-
-    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {
-      await usingPlaygrounds(async (helper) => {
-
-      });
-    });
-  });
-
-  itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {      
-      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-      const contractHelper = contractHelpers(web3, contractOwner);
+  
+    itEth('should actually sponsor transactions', async ({helper}) => {
+      // Contract caller
+      const caller = await helper.eth.createAccountWithBalance(alice, 1000n);
+      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);
+          
+      // Deploy flipper
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);
+      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);
+      
+      // Owner sets to sponsor every tx
       await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});
       await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});
-      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);
-
-      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));
+      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);
+  
+      // Set promotion to the Flipper
+      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorContract(flipper.options.address));
+  
+      // Caller calls Flipper
       await flipper.methods.flip().send({from: caller});
       expect(await flipper.methods.getValue().call()).to.be.true;
-
+  
+      // The contracts and caller balances have not changed
       const callerBalance = await helper.balance.getEthereum(caller);
       const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);
-
       expect(callerBalance).to.be.equal(1000n * nominal);
-      expect(1000n * nominal > contractBalanceAfter).to.be.true;
+      expect(1000n * nominal === contractBalanceAfter).to.be.true;
+  
+      // The pallet balance has decreased
+      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);
+      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;
     });
-  });
-});
-
-describe('app-promotion stopSponsoringContract', () => {  
-  before(async function () {
-    await beforeEach(this);
   });
-
-  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {      
-      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-      await transferBalanceToEth(api, alice, flipper.options.address);
-      const contractHelper = contractHelpers(web3, contractOwner);
+  
+  describe('stopSponsoringContract', () => {  
+    itEth('should remove pallet address from contract sponsors', async ({helper}) => {
+      const caller = await helper.eth.createAccountWithBalance(alice, 1000n);
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner);
+      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address);
+      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);
+  
       await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});
-      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));
-      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));
-
+      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);
+      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);
+  
       expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  
-      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
-      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
+      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  
+      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({
         disabled: null,
       });
-
+  
       await flipper.methods.flip().send({from: caller});
       expect(await flipper.methods.getValue().call()).to.be.true;
-
+  
       const callerBalance = await helper.balance.getEthereum(caller);
       const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);
-
+  
       // caller payed for call
       expect(1000n * nominal > callerBalance).to.be.true;
       expect(contractBalanceAfter).to.be.equal(1000n * nominal);
     });
-  });
-
-  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {      
+  
+    itEth('can not be called by non-admin', async ({helper}) => {
       const nonAdmin = accounts.pop()!;
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-
-      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));
-      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner);
+  
+      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);
+      const stopSponsoringResult = await helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]);
+      expect(stopSponsoringResult.status).to.equal('Fail');
+      expect(stopSponsoringResult.moduleError).to.equal('appPromotion.NoPermission');
     });
-  });
-
-  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {
-    await usingPlaygrounds(async (helper) => {      
+  
+    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {
       const nonAdmin = accounts.pop()!;
-      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();
-      const flipper = await deployFlipper(web3, contractOwner);
-      const contractHelper = contractHelpers(web3, contractOwner);
-      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
-
-      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;
+      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();
+      const flipper = await helper.eth.deployFlipper(contractOwner);
+      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);
+      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;
+  
+      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');
     });
   });
-});
-
-describe('app-promotion rewards', () => {
-  before(async function () {
-    await beforeEach(this);
-  });
-
-  it('can not be called by non admin', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+  describe('rewards', () => {
+    itSub('can not be called by non admin', async ({helper}) => {
       const nonAdmin = accounts.pop()!;
-      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;
+      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');
     });
-  });
-
-  it('should credit 0.05% for staking period', async () => {    
-    await usingPlaygrounds(async helper => {
+  
+    itSub('should increase total staked', async ({helper}) => {
       const staker = accounts.pop()!;
-
+      const totalStakedBefore = await helper.staking.getTotalStaked();
+      await helper.staking.stake(staker, 100n * nominal);
+  
+      // Wait for rewards and pay
+      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));
+      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);
+  
+      const totalStakedAfter = await helper.staking.getTotalStaked();
+      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);
+      // staker can unstake
+      await helper.staking.unstake(staker);
+      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));
+    });
+  
+    itSub('should credit 0.05% for staking period', async ({helper}) => {    
+      const staker = accounts.pop()!;
+  
       await waitPromotionPeriodDoesntEnd(helper);
-      
+        
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.stake(staker, 200n * nominal);
-
+  
       // wait rewards are available:
-      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[1][0];
-      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));
-
-      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
-
-      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
-      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);
+      const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));
+  
+      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;
+      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));
+  
+      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));
+      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));
     });
-  });
-
-  it('shoud be paid for more than one period if payments was missed', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {
       const staker = accounts.pop()!;
-
+  
       await helper.staking.stake(staker, 100n * nominal);
       // wait for two rewards are available:
-      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];
-      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);
-
-      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
-      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);
+  
+      await helper.admin.payoutStakers(palletAdmin, 100);
+      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
       const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);
-      expect(stakedPerBlock[0][1]).to.be.equal(frozenBalanceShouldBe);
-
+      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);
+  
       const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);
-
+  
       expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});
     });
-  });
-  
-  it('should not be credited for unstaked (reserved) balance', async () => {
-    await usingPlaygrounds(async helper => {
+    
+    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {
       // staker unstakes before rewards has been payed
       const staker = accounts.pop()!;
       await helper.staking.stake(staker, 100n * nominal);
-      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];
-      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);
+      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);
       await helper.staking.unstake(staker);
-      
+        
       // so he did not receive any rewards
       const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);
-      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
+      await helper.admin.payoutStakers(palletAdmin, 100);
       const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);
-
+  
       expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);
     });
-  });
-  
-  it('should bring compound interest', async () => {
-    await usingPlaygrounds(async helper => {
+    
+    itSub('should bring compound interest', async ({helper}) => {
       const staker = accounts.pop()!;
-            
+              
       await helper.staking.stake(staker, 100n * nominal);
-
-      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];
-      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));
-      
-      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
-      let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
-      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n)]);
-      
-      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);
-      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
-      totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
-      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2)]);      
+  
+      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));
+        
+      await helper.admin.payoutStakers(palletAdmin, 100);
+      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));
+        
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);
+      await helper.admin.payoutStakers(palletAdmin, 100);
+      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
+      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));
     });
-  });
-
-  it.skip('can be paid 1000 rewards in a time', async () => {
-    // all other stakes should be unstaked
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {
+      // all other stakes should be unstaked
       const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);
-
+  
       // stakers stakes 10 times each
       for (let i = 0; i < 10; i++) {
         await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));
       }
       await helper.wait.newBlocks(40);
-      const result = await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
+      await helper.admin.payoutStakers(palletAdmin, 100);
     });
-  });
-
-  it.skip('can handle 40.000 rewards', async () => {
-    await usingPlaygrounds(async (helper) => {
+  
+    itSub.skip('can handle 40.000 rewards', async ({helper}) => {
       const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);
       const crowdStakes = async () => {
         // each account in the crowd stakes 2 times
@@ -763,11 +687,11 @@
         await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));
         // 
       };
-
+  
       for (let i = 0; i < 40; i++) {
         await crowdStakes();
       }
-
+  
       // TODO pay rewards for some period
     });
   });

--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -198,8 +198,24 @@
     }
   `);
   }
-}
-  
+
+  async deployFlipper(signer: string): Promise<Contract> {
+    return await this.helper.ethContract.deployByCode(signer, 'Flipper', `
+    // SPDX-License-Identifier: UNLICENSED
+    pragma solidity ^0.8.6;
+
+    contract Flipper {
+      bool value = false;
+      function flip() public {
+        value = !value;
+      }
+      function getValue() public view returns (bool) {
+        return value;
+      }
+    }
+  `);
+  }
+}  
   
 class EthAddressGroup extends EthGroupBase {
   extractCollectionId(address: string): number {

--- a/tests/src/util/playgrounds/types.ts
+++ b/tests/src/util/playgrounds/types.ts
@@ -147,6 +147,11 @@
   feeFrozen: bigint
 }
 
+export interface IStakingInfo {
+  block: bigint,
+  amount: bigint,
+}
+
 export type TSubstrateAccount = string;
 export type TEthereumAccount = string;
 export type TApiAllowedListeners = 'connected' | 'disconnected' | 'error' | 'ready' | 'decorated';

--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -60,11 +60,13 @@
    */
   arrange: ArrangeGroup;
   wait: WaitGroup;
+  admin: AdminGroup;
 
   constructor(logger: { log: (msg: any, level: any) => void, level: any }) {
     super(logger);
     this.arrange = new ArrangeGroup(this);
     this.wait = new WaitGroup(this);
+    this.admin = new AdminGroup(this);
   }
 
   async connect(wsEndpoint: string, _listeners?: any): Promise<void> {
@@ -120,6 +122,7 @@
    */
   createAccounts = async (balances: bigint[], donor: IKeyringPair): Promise<IKeyringPair[]> => {
     let nonce = await this.helper.chain.getNonce(donor.address);
+    const wait = new WaitGroup(this.helper);
     const ss58Format = this.helper.chain.getChainProperties().ss58Format;
     const tokenNominal = this.helper.balance.getOneTokenNominal();
     const transactions = [];
@@ -154,7 +157,7 @@
     for (let index = 0; index < 5; index++) {
       accountsCreated = await checkBalances();
       if(accountsCreated) break;
-      
+      await wait.newBlocks(1);
     }
 
     if (!accountsCreated) throw Error('Accounts generation failed');
@@ -281,3 +284,22 @@
     });
   }
 }
+
+class AdminGroup {
+  helper: UniqueHelper;
+
+  constructor(helper: UniqueHelper) {
+    this.helper = helper;
+  }
+
+  async payoutStakers(signer: IKeyringPair, stakersToPayout: number) {
+    const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true);
+    return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => {
+      return {
+        staker: e.event.data[0].toString(),
+        stake: e.event.data[1].toBigInt(),
+        payout: e.event.data[2].toBigInt(),
+      };
+    });
+  }
+}