git.delta.rocks / unique-network / refs/commits / 2a3de5473dad

difftreelog

fix the behavior of the `appPromotion::payoutStakers` extrinsic, in which one staker could be skipped when called sequentially.

PraetorP2022-12-14parent: #bf956bf.patch.diff
in: master

3 files changed

modifiedpallets/app-promotion/src/lib.rsdiffbeforeafterboth
--- a/pallets/app-promotion/src/lib.rs
+++ b/pallets/app-promotion/src/lib.rs
@@ -255,11 +255,11 @@
 		ValueQuery,
 	>;
 
-	/// Stores a key for record for which the next revenue recalculation would be performed.
+	/// Stores a key for record for which the revenue recalculation was performed.
 	/// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.
 	#[pallet::storage]
 	#[pallet::getter(fn get_next_calculated_record)]
-	pub type NextCalculatedRecord<T: Config> =
+	pub type PreviousCalculatedRecord<T: Config> =
 		StorageValue<Value = (T::AccountId, T::BlockNumber), QueryKind = OptionQuery>;
 
 	#[pallet::hooks]
@@ -577,7 +577,7 @@
 			let mut stakers_number = stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS);
 
 			ensure!(
-				stakers_number <= config.max_stakers_per_calculation,
+				stakers_number <= config.max_stakers_per_calculation && stakers_number != 0,
 				Error::<T>::NoPermission
 			);
 
@@ -595,7 +595,7 @@
 			let mut storage_iterator = Self::get_next_calculated_key()
 				.map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));
 
-			NextCalculatedRecord::<T>::set(None);
+			PreviousCalculatedRecord::<T>::set(None);
 
 			{
 				let last_id = RefCell::new(None);
@@ -640,10 +640,6 @@
 					(amount, next_recalc_block_for_stake),
 				)) = storage_iterator.next()
 				{
-					if stakers_number == 0 {
-						NextCalculatedRecord::<T>::set(Some((current_id, staked_block)));
-						break;
-					}
 					if last_id.borrow().as_ref() != Some(&current_id) {
 						flush_stake()?;
 						*last_id.borrow_mut() = Some(current_id.clone());
@@ -662,6 +658,13 @@
 							&mut *income_acc.borrow_mut(),
 						);
 					}
+
+					if stakers_number == 0 {
+						if storage_iterator.next().is_some() {
+							PreviousCalculatedRecord::<T>::set(Some((current_id, staked_block)));
+						}
+						break;
+					}
 				}
 				flush_stake()?;
 			}
modifiedtests/src/app-promotion.test.tsdiffbeforeafterboth
before · tests/src/app-promotion.test.ts
1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import {itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip} from './util';19import {DevUniqueHelper} from './util/playgrounds/unique.dev';20import {itEth, expect, SponsoringMode} from './eth/util';2122let donor: IKeyringPair;23let palletAdmin: IKeyringPair;24let nominal: bigint;25let palletAddress: string;26let accounts: IKeyringPair[];27const LOCKING_PERIOD = 8n; // 8 blocks of relay28const UNLOCKING_PERIOD = 4n; // 4 blocks of parachain2930describe('App promotion', () => {31  before(async function () {32    await usingPlaygrounds(async (helper, privateKey) => {33      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);34      donor = await privateKey({filename: __filename});35      palletAddress = helper.arrange.calculatePalletAddress('appstake');36      palletAdmin = await privateKey('//PromotionAdmin');37      nominal = helper.balance.getOneTokenNominal();3839      const accountBalances = new Array(100);40      accountBalances.fill(1000n);41      accounts = await helper.arrange.createAccounts(accountBalances, donor); // create accounts-pool to speed up tests42    });43  });4445  describe('stake extrinsic', () => {  46    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {47      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];48      const totalStakedBefore = await helper.staking.getTotalStaked();49  50      // Minimum stake amount is 100:51      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;52      await helper.staking.stake(staker, 100n * nominal);53  54      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...55      // ...so he can not transfer 90056      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});57      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');58      59      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);60      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);61      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 62      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 63  64      65      await helper.staking.stake(staker, 200n * nominal);66      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);67      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});68      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);69      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);70    });71  72    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {73      const [staker] = await helper.arrange.createAccounts([2000n], donor);74      for (let i = 0; i < 10; i++) {75        await helper.staking.stake(staker, 100n * nominal);76      }77  78      // can have 10 stakes79      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);80      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);81  82      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');83  84      // After unstake can stake again85      await helper.staking.unstake(staker);86      await helper.staking.stake(staker, 100n * nominal);87      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);88    });89    90    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {91      const staker = accounts.pop()!;92  93      // Can't stake full balance because Alice needs to pay some fee94      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;95      await helper.staking.stake(staker, 500n * nominal);96  97      // Can't stake 500 tkn because Alice has Less than 500 transferable;98      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 99      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);100    });101    102    itSub('for different accounts in one block is possible', async ({helper}) => {103      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];104        105      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));106      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;107  108      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));109      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);110    });111  });112  113  describe('unstake extrinsic', () => {  114    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {115      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];116      const totalStakedBefore = await helper.staking.getTotalStaked();117      await helper.staking.stake(staker, 900n * nominal);118      await helper.staking.unstake(staker);119  120      // Right after unstake balance is reserved121      // Staker can not transfer 122      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});123      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');124      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);125      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);126      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);127    });128  129    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {130      const staker = accounts.pop()!;131      await helper.staking.stake(staker, 100n * nominal);132      await helper.staking.unstake(staker);133      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});134  135      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n136      await helper.wait.forParachainBlockNumber(pendingUnstake.block);137      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});138      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);139  140      // staker can transfer:141      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);142      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);143    });144  145    itSub('should successfully unstake multiple stakes', async ({helper}) => {146      const staker = accounts.pop()!;147      await helper.staking.stake(staker, 100n * nominal);148      await helper.staking.stake(staker, 200n * nominal);149      await helper.staking.stake(staker, 300n * nominal);150  151      // staked: [100, 200, 300]; unstaked: 0152      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});153      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});154      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});155      expect(totalPendingUnstake).to.be.deep.equal(0n);156      expect(pendingUnstake).to.be.deep.equal([]);157      expect(stakes[0].amount).to.equal(100n * nominal);158      expect(stakes[1].amount).to.equal(200n * nominal);159      expect(stakes[2].amount).to.equal(300n * nominal);160       161      // Can unstake multiple stakes162      await helper.staking.unstake(staker);163      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});164      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});165      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});166      expect(totalPendingUnstake).to.be.equal(600n * nominal);167      expect(stakes).to.be.deep.equal([]);168      expect(pendingUnstake[0].amount).to.equal(600n * nominal);169  170      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});171      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);172      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});173      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);174    });175  176    itSub('should not have any effects if no active stakes', async ({helper}) => {177      const staker = accounts.pop()!;178        179      // unstake has no effect if no stakes at all180      await helper.staking.unstake(staker);181      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);182      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper183  184      // TODO stake() unstake() waitUnstaked() unstake();185  186      // can't unstake if there are only pendingUnstakes187      await helper.staking.stake(staker, 100n * nominal);188      await helper.staking.unstake(staker);189      await helper.staking.unstake(staker);190  191      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);192      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);193    });194  195    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {196      const staker = accounts.pop()!;197      await helper.staking.stake(staker, 100n * nominal);198      await helper.staking.unstake(staker);199      await helper.staking.stake(staker, 120n * nominal);200      await helper.staking.unstake(staker);201  202      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});203      expect(unstakingPerBlock).has.length(2);204      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);205      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);206    });207  208    itSub('should be possible for different accounts in one block', async ({helper}) => {209      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];210  211      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));212      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));213  214      await Promise.all(stakers.map(async (staker) => {215        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);216        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);217      }));218    });219  });220  221  describe('collection sponsoring', () => {222    itSub('should actually sponsor transactions', async ({helper}) => {223      const api = helper.getApi();224      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];225      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});226      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});227      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));228      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);229  230      await token.transfer(tokenSender, {Substrate: receiver.address});231      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});232      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);233  234      // senders balance the same, transaction has sponsored235      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);236      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;237    });238  239    itSub('can not be set by non admin', async ({helper}) => {240      const api = helper.getApi();241      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];242  243      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});244        245      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;246      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');247    });248  249    itSub('should set pallet address as confirmed admin', async ({helper}) => {250      const api = helper.getApi();251      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];252        253      // Can set sponsoring for collection without sponsor254      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});255      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;256      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});257  258      // Can set sponsoring for collection with unconfirmed sponsor259      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});260      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});261      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;262      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});263  264      // Can set sponsoring for collection with confirmed sponsor265      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});266      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);267      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;268      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});269    });270  271    itSub('can be overwritten by collection owner', async ({helper}) => {    272      const api = helper.getApi();273      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];274      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});275      const collectionId = collection.collectionId;276        277      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;278        279      // Collection limits still can be changed by the owner280      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;281      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);282      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});283  284      // Collection sponsor can be changed too285      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;286      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});287    });288    289    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {290      const api = helper.getApi();291      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};292      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});293  294      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;295      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);296    });297    298    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {299      const api = helper.getApi();300      const collectionOwner = accounts.pop()!;301        302      // collection has never existed303      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;304      // collection has been burned305      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});306      await collection.burn(collectionOwner);307  308      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;309    });310  });311  312  describe('stopSponsoringCollection', () => {313    itSub('can not be called by non-admin', async ({helper}) => {314      const api = helper.getApi();315      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];316      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});317        318      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;319        320      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;321      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});322    });323  324    itSub('should set sponsoring as disabled', async ({helper}) => {325      const api = helper.getApi();326      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];327      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});328      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});329        330      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));331      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));332        333      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');334  335      // Transactions are not sponsored anymore:336      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);337      await token.transfer(collectionOwner, {Substrate: recepient.address});338      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);339      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);340    });341  342    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {343      const api = helper.getApi();344      const collectionOwner = accounts.pop()!;345      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});346      await collection.confirmSponsorship(collectionOwner);347        348      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;349        350      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});351    });352  353    itSub('should reject transaction if collection does not exist', async ({helper}) => {    354      const collectionOwner = accounts.pop()!;355      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});356        357      await collection.burn(collectionOwner);358      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');359      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');360    });361  });362  363  describe('contract sponsoring', () => {364    itEth('should set palletes address as a sponsor', async ({helper}) => {365      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();366      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);367      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);368  369      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);370      371      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  372      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  373      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({374        confirmed: {375          substrate: palletAddress,376        },377      });378    });379  380    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {381      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();382      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);383      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);384  385      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;386  387      // Contract is self sponsored388      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({389        confirmed: {390          ethereum: flipper.options.address.toLowerCase(),391        },392      });393  394      // set promotion sponsoring395      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);396  397      // new sponsor is pallet address398      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  399      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  400      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({401        confirmed: {402          substrate: palletAddress,403        },404      });405    });406  407    itEth('can be overwritten by contract owner', async ({helper}) => {408      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();409      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);410      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);411  412      // contract sponsored by pallet413      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);414  415      // owner sets self sponsoring416      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;417  418      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  419      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  420      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({421        confirmed: {422          ethereum: flipper.options.address.toLowerCase(),423        },424      });425    });426  427    itEth('can not be set by non admin', async ({helper}) => {428      const nonAdmin = accounts.pop()!;429      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();430      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);431      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);432  433      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;434  435      // nonAdmin calls sponsorContract436      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');437  438      // contract still self-sponsored 439      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({440        confirmed: {441          ethereum: flipper.options.address.toLowerCase(),442        },443      });444    });445  446    itEth('should actually sponsor transactions', async ({helper}) => {447      // Contract caller448      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);449      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);450          451      // Deploy flipper452      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();453      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);454      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);455      456      // Owner sets to sponsor every tx457      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});458      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});459      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);460  461      // Set promotion to the Flipper462      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);463  464      // Caller calls Flipper465      await flipper.methods.flip().send({from: caller});466      expect(await flipper.methods.getValue().call()).to.be.true;467  468      // The contracts and caller balances have not changed469      const callerBalance = await helper.balance.getEthereum(caller);470      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);471      expect(callerBalance).to.be.equal(1000n * nominal);472      expect(1000n * nominal === contractBalanceAfter).to.be.true;473  474      // The pallet balance has decreased475      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);476      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;477    });478  });479  480  describe('stopSponsoringContract', () => {  481    itEth('should remove pallet address from contract sponsors', async ({helper}) => {482      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);483      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();484      const flipper = await helper.eth.deployFlipper(contractOwner);485      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);486      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);487  488      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});489      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);490      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);491  492      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  493      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  494      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({495        disabled: null,496      });497  498      await flipper.methods.flip().send({from: caller});499      expect(await flipper.methods.getValue().call()).to.be.true;500  501      const callerBalance = await helper.balance.getEthereum(caller);502      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);503  504      // caller payed for call505      expect(1000n * nominal > callerBalance).to.be.true;506      expect(contractBalanceAfter).to.be.equal(100n * nominal);507    });508  509    itEth('can not be called by non-admin', async ({helper}) => {510      const nonAdmin = accounts.pop()!;511      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();512      const flipper = await helper.eth.deployFlipper(contractOwner);513  514      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);515      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))516        .to.be.rejectedWith(/appPromotion\.NoPermission/);517    });518  519    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {520      const nonAdmin = accounts.pop()!;521      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();522      const flipper = await helper.eth.deployFlipper(contractOwner);523      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);524      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;525  526      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');527    });528  });529  530  describe('rewards', () => {531    itSub('can not be called by non admin', async ({helper}) => {532      const nonAdmin = accounts.pop()!;533      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');534    });535  536    itSub('should increase total staked', async ({helper}) => {537      const staker = accounts.pop()!;538      const totalStakedBefore = await helper.staking.getTotalStaked();539      await helper.staking.stake(staker, 100n * nominal);540  541      // Wait for rewards and pay542      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});543      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));544      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);545  546      const totalStakedAfter = await helper.staking.getTotalStaked();547      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);548      // staker can unstake549      await helper.staking.unstake(staker);550      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal));551    });552  553    itSub('should credit 0.05% for staking period', async ({helper}) => {    554      const staker = accounts.pop()!;555  556      await waitPromotionPeriodDoesntEnd(helper);557        558      await helper.staking.stake(staker, 100n * nominal);559      await helper.staking.stake(staker, 200n * nominal);560  561      // wait rewards are available:562      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});563      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));564  565      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;566      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal));567  568      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});569      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal));570      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal));571    });572  573    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {574      const staker = accounts.pop()!;575  576      await helper.staking.stake(staker, 100n * nominal);577      // wait for two rewards are available:578      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});579      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);580  581      await helper.admin.payoutStakers(palletAdmin, 100);582      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});583      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);584      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);585  586      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);587  588      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});589    });590    591    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {592      // staker unstakes before rewards has been payed593      const staker = accounts.pop()!;594      await helper.staking.stake(staker, 100n * nominal);595      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});596      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);597      await helper.staking.unstake(staker);598        599      // so he did not receive any rewards600      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);601      await helper.admin.payoutStakers(palletAdmin, 100);602      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);603  604      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);605    });606    607    itSub('should bring compound interest', async ({helper}) => {608      const staker = accounts.pop()!;609              610      await helper.staking.stake(staker, 100n * nominal);611  612      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});613      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));614        615      await helper.admin.payoutStakers(palletAdmin, 100);616      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});617      expect(stake.amount).to.equal(calculateIncome(100n * nominal));618        619      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);620      await helper.admin.payoutStakers(palletAdmin, 100);621      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});622      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 2));623    });624  625    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {626      // all other stakes should be unstaked627      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);628  629      // stakers stakes 10 times each630      for (let i = 0; i < 10; i++) {631        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));632      }633      await helper.wait.newBlocks(40);634      await helper.admin.payoutStakers(palletAdmin, 100);635    });636  637    itSub.skip('can handle 40.000 rewards', async ({helper}) => {638      const crowdStakes = async () => {639        // each account in the crowd stakes 2 times640        const crowd = await helper.arrange.createCrowd(500, 300n, donor);641        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));642        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));643        // 644      };645  646      for (let i = 0; i < 40; i++) {647        await crowdStakes();648      }649  650      // TODO pay rewards for some period651    });652  });653});654655function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {656  const DAY = 7200n;657  const ACCURACY = 1_000_000_000n;658  // 5n / 10_000n = 0.05% p/day659  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;660  661  if (iter > 1) {662    return calculateIncome(income, iter - 1, calcPeriod);663  } else return income;664}665666function rewardAvailableInBlock(stakedInBlock: bigint) {667  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;668  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);669}670671// Wait while promotion period less than specified block, to avoid boundary cases672// 0 if this should be the beginning of the period.673async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {674  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();675  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;676677  if (currentPeriodBlock > waitBlockLessThan) {678    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);679  }680}
after · tests/src/app-promotion.test.ts
1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import {itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip} from './util';19import {DevUniqueHelper} from './util/playgrounds/unique.dev';20import {itEth, expect, SponsoringMode} from './eth/util';2122let donor: IKeyringPair;23let palletAdmin: IKeyringPair;24let nominal: bigint;25let palletAddress: string;26let accounts: IKeyringPair[];27const LOCKING_PERIOD = 8n; // 8 blocks of relay28const UNLOCKING_PERIOD = 4n; // 4 blocks of parachain2930describe('App promotion', () => {31  before(async function () {32    await usingPlaygrounds(async (helper, privateKey) => {33      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);34      donor = await privateKey({filename: __filename});35      palletAddress = helper.arrange.calculatePalletAddress('appstake');36      palletAdmin = await privateKey('//Alice');37      nominal = helper.balance.getOneTokenNominal();3839      await helper.executeExtrinsic(palletAdmin, 'api.tx.sudo.sudo', [helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})]);40      await helper.executeExtrinsic(palletAdmin, 'api.tx.sudo.sudo', [helper.api!.tx.configuration41        .setAppPromotionConfigurationOverride({42          recalculationInterval: LOCKING_PERIOD,43          pendingInterval: UNLOCKING_PERIOD})], true);44    });45  });4647  describe('stake extrinsic', () => {  48    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {49     50   51    });52  53    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {54      const [staker] = await helper.arrange.createAccounts([2000n], donor);55      for (let i = 0; i < 10; i++) {56        await helper.staking.stake(staker, 100n * nominal);57      }58  59      // can have 10 stakes60      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);61      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);62  63      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');64  65      // After unstake can stake again66      await helper.staking.unstake(staker);67      await helper.staking.stake(staker, 100n * nominal);68      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);69    });70    71    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {72      const staker = accounts.pop()!;73  74      // Can't stake full balance because Alice needs to pay some fee75      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;76      await helper.staking.stake(staker, 500n * nominal);77  78      // Can't stake 500 tkn because Alice has Less than 500 transferable;79      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 80      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);81    });82    83    itSub('for different accounts in one block is possible', async ({helper}) => {84      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];85        86      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));87      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;88  89      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));90      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);91    });92  });93  94  describe('unstake extrinsic', () => {  95    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {96      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];97      const totalStakedBefore = await helper.staking.getTotalStaked();98      await helper.staking.stake(staker, 900n * nominal);99      await helper.staking.unstake(staker);100  101      // Right after unstake balance is reserved102      // Staker can not transfer 103      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});104      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');105      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);106      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);107      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);108    });109  110    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {111      const staker = accounts.pop()!;112      await helper.staking.stake(staker, 100n * nominal);113      await helper.staking.unstake(staker);114      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});115  116      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n117      await helper.wait.forParachainBlockNumber(pendingUnstake.block);118      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});119      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);120  121      // staker can transfer:122      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);123      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);124    });125  126    itSub('should successfully unstake multiple stakes', async ({helper}) => {127      const staker = accounts.pop()!;128      await helper.staking.stake(staker, 100n * nominal);129      await helper.staking.stake(staker, 200n * nominal);130      await helper.staking.stake(staker, 300n * nominal);131  132      // staked: [100, 200, 300]; unstaked: 0133      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});134      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});135      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});136      expect(totalPendingUnstake).to.be.deep.equal(0n);137      expect(pendingUnstake).to.be.deep.equal([]);138      expect(stakes[0].amount).to.equal(100n * nominal);139      expect(stakes[1].amount).to.equal(200n * nominal);140      expect(stakes[2].amount).to.equal(300n * nominal);141       142      // Can unstake multiple stakes143      await helper.staking.unstake(staker);144      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});145      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});146      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});147      expect(totalPendingUnstake).to.be.equal(600n * nominal);148      expect(stakes).to.be.deep.equal([]);149      expect(pendingUnstake[0].amount).to.equal(600n * nominal);150  151      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});152      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);153      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});154      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);155    });156  157    itSub('should not have any effects if no active stakes', async ({helper}) => {158      const staker = accounts.pop()!;159        160      // unstake has no effect if no stakes at all161      await helper.staking.unstake(staker);162      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);163      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper164  165      // TODO stake() unstake() waitUnstaked() unstake();166  167      // can't unstake if there are only pendingUnstakes168      await helper.staking.stake(staker, 100n * nominal);169      await helper.staking.unstake(staker);170      await helper.staking.unstake(staker);171  172      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);173      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);174    });175  176    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {177      const staker = accounts.pop()!;178      await helper.staking.stake(staker, 100n * nominal);179      await helper.staking.unstake(staker);180      await helper.staking.stake(staker, 120n * nominal);181      await helper.staking.unstake(staker);182  183      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});184      expect(unstakingPerBlock).has.length(2);185      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);186      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);187    });188  189    itSub('should be possible for different accounts in one block', async ({helper}) => {190      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];191  192      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));193      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));194  195      await Promise.all(stakers.map(async (staker) => {196        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);197        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);198      }));199    });200  });201  202  describe('collection sponsoring', () => {203    itSub('should actually sponsor transactions', async ({helper}) => {204      const api = helper.getApi();205      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];206      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});207      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});208      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));209      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);210  211      await token.transfer(tokenSender, {Substrate: receiver.address});212      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});213      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);214  215      // senders balance the same, transaction has sponsored216      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);217      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;218    });219  220    itSub('can not be set by non admin', async ({helper}) => {221      const api = helper.getApi();222      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];223  224      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});225        226      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;227      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');228    });229  230    itSub('should set pallet address as confirmed admin', async ({helper}) => {231      const api = helper.getApi();232      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];233        234      // Can set sponsoring for collection without sponsor235      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});236      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;237      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});238  239      // Can set sponsoring for collection with unconfirmed sponsor240      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});241      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});242      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;243      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});244  245      // Can set sponsoring for collection with confirmed sponsor246      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});247      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);248      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;249      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});250    });251  252    itSub('can be overwritten by collection owner', async ({helper}) => {    253      const api = helper.getApi();254      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];255      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});256      const collectionId = collection.collectionId;257        258      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;259        260      // Collection limits still can be changed by the owner261      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;262      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);263      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});264  265      // Collection sponsor can be changed too266      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;267      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});268    });269    270    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {271      const api = helper.getApi();272      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};273      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});274  275      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;276      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);277    });278    279    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {280      const api = helper.getApi();281      const collectionOwner = accounts.pop()!;282        283      // collection has never existed284      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;285      // collection has been burned286      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});287      await collection.burn(collectionOwner);288  289      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;290    });291  });292  293  describe('stopSponsoringCollection', () => {294    itSub('can not be called by non-admin', async ({helper}) => {295      const api = helper.getApi();296      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];297      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});298        299      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;300        301      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;302      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});303    });304  305    itSub('should set sponsoring as disabled', async ({helper}) => {306      const api = helper.getApi();307      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];308      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});309      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});310        311      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));312      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));313        314      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');315  316      // Transactions are not sponsored anymore:317      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);318      await token.transfer(collectionOwner, {Substrate: recepient.address});319      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);320      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);321    });322  323    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {324      const api = helper.getApi();325      const collectionOwner = accounts.pop()!;326      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});327      await collection.confirmSponsorship(collectionOwner);328        329      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;330        331      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});332    });333  334    itSub('should reject transaction if collection does not exist', async ({helper}) => {    335      const collectionOwner = accounts.pop()!;336      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});337        338      await collection.burn(collectionOwner);339      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');340      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');341    });342  });343  344  describe('contract sponsoring', () => {345    itEth('should set palletes address as a sponsor', async ({helper}) => {346      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();347      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);348      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);349  350      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);351      352      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  353      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  354      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({355        confirmed: {356          substrate: palletAddress,357        },358      });359    });360  361    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {362      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();363      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);364      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);365  366      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;367  368      // Contract is self sponsored369      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({370        confirmed: {371          ethereum: flipper.options.address.toLowerCase(),372        },373      });374  375      // set promotion sponsoring376      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);377  378      // new sponsor is pallet address379      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  380      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  381      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({382        confirmed: {383          substrate: palletAddress,384        },385      });386    });387  388    itEth('can be overwritten by contract owner', async ({helper}) => {389      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();390      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);391      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);392  393      // contract sponsored by pallet394      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);395  396      // owner sets self sponsoring397      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;398  399      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  400      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  401      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({402        confirmed: {403          ethereum: flipper.options.address.toLowerCase(),404        },405      });406    });407  408    itEth('can not be set by non admin', async ({helper}) => {409      const nonAdmin = accounts.pop()!;410      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();411      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);412      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);413  414      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;415  416      // nonAdmin calls sponsorContract417      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');418  419      // contract still self-sponsored 420      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({421        confirmed: {422          ethereum: flipper.options.address.toLowerCase(),423        },424      });425    });426  427    itEth('should actually sponsor transactions', async ({helper}) => {428      // Contract caller429      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);430      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);431          432      // Deploy flipper433      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();434      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);435      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);436      437      // Owner sets to sponsor every tx438      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});439      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});440      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);441  442      // Set promotion to the Flipper443      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);444  445      // Caller calls Flipper446      await flipper.methods.flip().send({from: caller});447      expect(await flipper.methods.getValue().call()).to.be.true;448  449      // The contracts and caller balances have not changed450      const callerBalance = await helper.balance.getEthereum(caller);451      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);452      expect(callerBalance).to.be.equal(1000n * nominal);453      expect(1000n * nominal === contractBalanceAfter).to.be.true;454  455      // The pallet balance has decreased456      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);457      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;458    });459  });460  461  describe('stopSponsoringContract', () => {  462    itEth('should remove pallet address from contract sponsors', async ({helper}) => {463      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);464      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();465      const flipper = await helper.eth.deployFlipper(contractOwner);466      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);467      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);468  469      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});470      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);471      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);472  473      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  474      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  475      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({476        disabled: null,477      });478  479      await flipper.methods.flip().send({from: caller});480      expect(await flipper.methods.getValue().call()).to.be.true;481  482      const callerBalance = await helper.balance.getEthereum(caller);483      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);484  485      // caller payed for call486      expect(1000n * nominal > callerBalance).to.be.true;487      expect(contractBalanceAfter).to.be.equal(100n * nominal);488    });489  490    itEth('can not be called by non-admin', async ({helper}) => {491      const nonAdmin = accounts.pop()!;492      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();493      const flipper = await helper.eth.deployFlipper(contractOwner);494  495      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);496      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))497        .to.be.rejectedWith(/appPromotion\.NoPermission/);498    });499  500    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {501      const nonAdmin = accounts.pop()!;502      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();503      const flipper = await helper.eth.deployFlipper(contractOwner);504      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);505      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;506  507      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');508    });509  });510  511  describe('rewards', () => {512    itSub('can not be called by non admin', async ({helper}) => {513      const nonAdmin = accounts.pop()!;514      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');515    });516  517    itSub('should increase total staked', async ({helper}) => {518      const staker = accounts.pop()!;519      const totalStakedBefore = await helper.staking.getTotalStaked();520      await helper.staking.stake(staker, 100n * nominal);521  522      // Wait for rewards and pay523      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});524      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));525      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);526  527      const totalStakedAfter = await helper.staking.getTotalStaked();528      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);529      // staker can unstake530      await helper.staking.unstake(staker);531      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal));532    });533  534    itSub('should credit 0.05% for staking period', async ({helper}) => {    535      const staker = accounts.pop()!;536  537      await waitPromotionPeriodDoesntEnd(helper);538        539      await helper.staking.stake(staker, 100n * nominal);540      await helper.staking.stake(staker, 200n * nominal);541  542      // wait rewards are available:543      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});544      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));545  546      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;547      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal));548  549      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});550      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal));551      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal));552    });553  554    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {555      const staker = accounts.pop()!;556  557      await helper.staking.stake(staker, 100n * nominal);558      // wait for two rewards are available:559      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});560      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);561  562      await helper.admin.payoutStakers(palletAdmin, 100);563      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});564      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);565      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);566  567      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);568  569      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});570    });571    572    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {573      // staker unstakes before rewards has been payed574      const staker = accounts.pop()!;575      await helper.staking.stake(staker, 100n * nominal);576      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});577      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);578      await helper.staking.unstake(staker);579        580      // so he did not receive any rewards581      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);582      await helper.admin.payoutStakers(palletAdmin, 100);583      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);584  585      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);586    });587    588    itSub('should bring compound interest', async ({helper}) => {589      const staker = accounts.pop()!;590              591      await helper.staking.stake(staker, 100n * nominal);592  593      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});594      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));595        596      await helper.admin.payoutStakers(palletAdmin, 100);597      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});598      expect(stake.amount).to.equal(calculateIncome(100n * nominal));599        600      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);601      await helper.admin.payoutStakers(palletAdmin, 100);602      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});603      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 2));604    });605  606    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {607      // all other stakes should be unstaked608      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);609  610      // stakers stakes 10 times each611      for (let i = 0; i < 10; i++) {612        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));613      }614      await helper.wait.newBlocks(40);615      await helper.admin.payoutStakers(palletAdmin, 100);616    });617  618    itSub.skip('can handle 40.000 rewards', async ({helper}) => {619      const crowdStakes = async () => {620        // each account in the crowd stakes 2 times621        const crowd = await helper.arrange.createCrowd(500, 300n, donor);622        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));623        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));624        // 625      };626  627      for (let i = 0; i < 40; i++) {628        await crowdStakes();629      }630  631      // TODO pay rewards for some period632    });633  });634});635636function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {637  const DAY = 7200n;638  const ACCURACY = 1_000_000_000n;639  // 5n / 10_000n = 0.05% p/day640  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;641  642  if (iter > 1) {643    return calculateIncome(income, iter - 1, calcPeriod);644  } else return income;645}646647function rewardAvailableInBlock(stakedInBlock: bigint) {648  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;649  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);650}651652// Wait while promotion period less than specified block, to avoid boundary cases653// 0 if this should be the beginning of the period.654async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {655  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();656  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;657658  if (currentPeriodBlock > waitBlockLessThan) {659    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);660  }661}
modifiedtests/src/interfaces/augment-api-query.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-api-query.ts
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -23,11 +23,6 @@
        **/
       admin: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
-       * Stores a key for record for which the next revenue recalculation would be performed.
-       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.
-       **/
-      nextCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
        * Stores amount of stakes for an `Account`.
        * 
        * * **Key** - Staker account.
@@ -35,6 +30,11 @@
        **/
       pendingUnstake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
       /**
+       * Stores a key for record for which the next revenue recalculation would be performed.
+       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.
+       **/
+      previousCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
        * Stores the amount of tokens staked by account in the blocknumber.
        * 
        * * **Key1** - Staker account.