git.delta.rocks / unique-network / refs/commits / 6c62f5a03f69

difftreelog

Split promotion tests to sequential and parallel

Maksandre2022-10-10parent: #d52c8f5.patch.diff
in: master
- add globalSetup script to set app promotion admin
- move calculatePalleteAddress helper to DevUniqueHelper

5 files changed

addedtests/globalSetup.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/globalSetup.ts
@@ -0,0 +1,18 @@
+import {Pallets, usingPlaygrounds} from './src/util/playgrounds/index';
+
+export async function mochaGlobalSetup() {
+  await usingPlaygrounds(async (helper, privateKey) => {
+    // Set up App Promotion admin
+    const missingPallets = helper.fetchMissingPalletNames([Pallets.AppPromotion]);
+    if (missingPallets.length === 0) {
+      const superuser = await privateKey('//Alice');
+      const palletAddress = helper.arrange.calculatePalleteAddress('appstake');
+      const palletAdmin = await privateKey('//PromotionAdmin');
+      const api = helper.getApi();
+      await helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
+      const nominal = helper.balance.getOneTokenNominal();
+      await helper.balance.transferToSubstrate(superuser, palletAdmin.address, 1000n * nominal);
+      await helper.balance.transferToSubstrate(superuser, palletAddress, 1000n * nominal);
+    }
+  });
+}
modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -21,7 +21,7 @@
   },
   "mocha": {
     "timeout": 9999999,
-    "require": "ts-node/register"
+    "require": ["ts-node/register", "./globalSetup.ts"]
   },
   "scripts": {
     "lint": "eslint --ext .ts,.js src/",
addedtests/src/app-promotion.seqtest.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/app-promotion.seqtest.ts
@@ -0,0 +1,83 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip} from './util/playgrounds';
+import {expect} from './eth/util/playgrounds';
+
+let superuser: IKeyringPair;
+let donor: IKeyringPair;
+let palletAdmin: IKeyringPair;
+let nominal: bigint;
+let palletAddress;
+let accounts: IKeyringPair[];
+
+
+describe('App promotion', () => {
+  before(async function () {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);
+      superuser = await privateKey('//Alice');
+      donor = await privateKey({filename: __filename});
+      palletAddress = helper.arrange.calculatePalleteAddress('appstake');
+      palletAdmin = await privateKey('//PromotionAdmin');
+      const api = helper.getApi();
+      await helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
+      nominal = helper.balance.getOneTokenNominal();
+      await helper.balance.transferToSubstrate(donor, palletAdmin.address, 1000n * nominal);
+      await helper.balance.transferToSubstrate(donor, palletAddress, 1000n * nominal);
+      accounts = await helper.arrange.createCrowd(100, 1000n, donor); // create accounts-pool to speed up tests
+    });
+  });
+
+  describe('admin adress', () => {
+    itSub('can be set by sudo only', async ({helper}) => {
+      const api = helper.getApi();
+      const nonAdmin = accounts.pop()!;
+      // nonAdmin can not set admin not from himself nor as a sudo
+      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;
+      await expect(helper.signTransaction(nonAdmin, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;
+    });
+    
+    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 api = helper.getApi();
+      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(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;
+      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(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, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
+    });
+  
+    itSub('can be reassigned', async ({helper}) => {
+      const api = helper.getApi();
+      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(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: oldAdmin.address})))).to.be.fulfilled;
+      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: newAdmin.address})))).to.be.fulfilled;
+      await expect(helper.signTransaction(oldAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;
+        
+      await expect(helper.signTransaction(newAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;
+    });
+  });
+});
+
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/playgrounds';19import {encodeAddress} from '@polkadot/util-crypto';20import {stringToU8a} from '@polkadot/util';21import {DevUniqueHelper} from './util/playgrounds/unique.dev';22import {itEth, expect, SponsoringMode} from './eth/util/playgrounds';2324let superuser: IKeyringPair;25let donor: IKeyringPair;26let palletAdmin: IKeyringPair;27let nominal: bigint;28const palletAddress = calculatePalleteAddress('appstake');29let accounts: IKeyringPair[] = [];30const LOCKING_PERIOD = 20n; // 20 blocks of relay31const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain32const rewardAvailableInBlock = (stakedInBlock: bigint) => {33  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + 20n;34  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);35};3637describe('App promotion', () => {38  before(async function () {39    await usingPlaygrounds(async (helper, privateKey) => {40      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);41      superuser = await privateKey('//Alice');42      donor = await privateKey({filename: __filename});43      [palletAdmin] = await helper.arrange.createAccounts([100n], donor);44      const api = helper.getApi();45      await helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));46      nominal = helper.balance.getOneTokenNominal();47      await helper.balance.transferToSubstrate(donor, palletAdmin.address, 1000n * nominal);48      await helper.balance.transferToSubstrate(donor, palletAddress, 1000n * nominal);49      accounts = await helper.arrange.createCrowd(100, 1000n, donor); // create accounts-pool to speed up tests50    });51  });5253  describe('stake extrinsic', () => {  54    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {55      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];56      const totalStakedBefore = await helper.staking.getTotalStaked();57  58      // Minimum stake amount is 100:59      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;60      await helper.staking.stake(staker, 100n * nominal);61  62      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...63      // ...so he can not transfer 90064      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});65      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');66      67      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);68      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);69      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 70      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 71  72      73      await helper.staking.stake(staker, 200n * nominal);74      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);75      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});76      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);77      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);78    });79  80    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {81      const [staker] = await helper.arrange.createAccounts([2000n], donor);82      for (let i = 0; i < 10; i++) {83        await helper.staking.stake(staker, 100n * nominal);84      }85  86      // can have 10 stakes87      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);88      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);89  90      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');91  92      // After unstake can stake again93      await helper.staking.unstake(staker);94      await helper.staking.stake(staker, 100n * nominal);95      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);96    });97    98    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {99      const staker = accounts.pop()!;100  101      // Can't stake full balance because Alice needs to pay some fee102      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;103      await helper.staking.stake(staker, 500n * nominal);104  105      // Can't stake 500 tkn because Alice has Less than 500 transferable;106      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 107      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);108    });109    110    itSub('for different accounts in one block is possible', async ({helper}) => {111      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];112        113      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));114      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;115  116      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));117      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);118    });119  });120  121  describe('unstake extrinsic', () => {  122    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {123      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];124      const totalStakedBefore = await helper.staking.getTotalStaked();125      await helper.staking.stake(staker, 900n * nominal);126      await helper.staking.unstake(staker);127  128      // Right after unstake balance is reserved129      // Staker can not transfer 130      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});131      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');132      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);133      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);134      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);135    });136  137    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {138      const staker = accounts.pop()!;139      await helper.staking.stake(staker, 100n * nominal);140      await helper.staking.unstake(staker);141      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});142  143      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n144      await helper.wait.forParachainBlockNumber(pendingUnstake.block);145      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});146      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);147  148      // staker can transfer:149      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);150      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);151    });152  153    itSub('should successfully unstake multiple stakes', async ({helper}) => {154      const staker = accounts.pop()!;155      await helper.staking.stake(staker, 100n * nominal);156      await helper.staking.stake(staker, 200n * nominal);157      await helper.staking.stake(staker, 300n * nominal);158  159      // staked: [100, 200, 300]; unstaked: 0160      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});161      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});162      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});163      expect(totalPendingUnstake).to.be.deep.equal(0n);164      expect(pendingUnstake).to.be.deep.equal([]);165      expect(stakes[0].amount).to.equal(100n * nominal);166      expect(stakes[1].amount).to.equal(200n * nominal);167      expect(stakes[2].amount).to.equal(300n * nominal);168       169      // Can unstake multiple stakes170      await helper.staking.unstake(staker);171      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});172      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});173      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});174      expect(totalPendingUnstake).to.be.equal(600n * nominal);175      expect(stakes).to.be.deep.equal([]);176      expect(pendingUnstake[0].amount).to.equal(600n * nominal);177  178      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});179      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);180      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});181      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);182    });183  184    itSub('should not have any effects if no active stakes', async ({helper}) => {185      const staker = accounts.pop()!;186        187      // unstake has no effect if no stakes at all188      await helper.staking.unstake(staker);189      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);190      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper191  192      // TODO stake() unstake() waitUnstaked() unstake();193  194      // can't unstake if there are only pendingUnstakes195      await helper.staking.stake(staker, 100n * nominal);196      await helper.staking.unstake(staker);197      await helper.staking.unstake(staker);198  199      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);200      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);201    });202  203    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {204      const staker = accounts.pop()!;205      await helper.staking.stake(staker, 100n * nominal);206      await helper.staking.unstake(staker);207      await helper.staking.stake(staker, 120n * nominal);208      await helper.staking.unstake(staker);209  210      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});211      expect(unstakingPerBlock).has.length(2);212      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);213      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);214    });215  216    itSub('should be possible for different accounts in one block', async ({helper}) => {217      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];218  219      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));220      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));221  222      await Promise.all(stakers.map(async (staker) => {223        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);224        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);225      }));226    });227  });228  229  describe('admin adress', () => {230    itSub('can be set by sudo only', async ({helper}) => {231      const api = helper.getApi();232      const nonAdmin = accounts.pop()!;233      // nonAdmin can not set admin not from himself nor as a sudo234      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;235      await expect(helper.signTransaction(nonAdmin, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;236  237      // Alice can238      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;239    });240    241    itSub('can be any valid CrossAccountId', async ({helper}) => {242      // We are not going to set an eth address as a sponsor,243      // but we do want to check, it doesn't break anything;244      const api = helper.getApi();245      const account = accounts.pop()!;246      const ethAccount = helper.address.substrateToEth(account.address); 247      // Alice sets Ethereum address as a sudo. Then Substrate address back...248      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;249      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;250        251      // ...It doesn't break anything;252      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});253      await expect(helper.signTransaction(account, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;254    });255  256    itSub('can be reassigned', async ({helper}) => {257      const api = helper.getApi();258      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];259      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});260        261      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: oldAdmin.address})))).to.be.fulfilled;262      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: newAdmin.address})))).to.be.fulfilled;263      await expect(helper.signTransaction(oldAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;264        265      await expect(helper.signTransaction(newAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;266    });267  });268  269  describe('collection sponsoring', () => {270    before(async function () {271      await usingPlaygrounds(async (helper) => {272        const api = helper.getApi();273        const tx = api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));274        await helper.signTransaction(superuser, tx);275      });276    });277  278    itSub('should actually sponsor transactions', async ({helper}) => {279      const api = helper.getApi();280      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];281      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});282      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});283      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));284      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);285  286      await token.transfer(tokenSender, {Substrate: receiver.address});287      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});288      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);289  290      // senders balance the same, transaction has sponsored291      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);292      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;293    });294  295    itSub('can not be set by non admin', async ({helper}) => {296      const api = helper.getApi();297      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];298  299      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});300        301      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;302      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');303    });304  305    itSub('should set pallet address as confirmed admin', async ({helper}) => {306      const api = helper.getApi();307      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];308        309      // Can set sponsoring for collection without sponsor310      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});311      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;312      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});313  314      // Can set sponsoring for collection with unconfirmed sponsor315      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});316      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});317      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;318      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});319  320      // Can set sponsoring for collection with confirmed sponsor321      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});322      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);323      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;324      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});325    });326  327    itSub('can be overwritten by collection owner', async ({helper}) => {    328      const api = helper.getApi();329      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];330      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});331      const collectionId = collection.collectionId;332        333      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;334        335      // Collection limits still can be changed by the owner336      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;337      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);338      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});339  340      // Collection sponsor can be changed too341      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;342      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});343    });344    345    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {346      const api = helper.getApi();347      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};348      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});349  350      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;351      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);352    });353    354    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {355      const api = helper.getApi();356      const collectionOwner = accounts.pop()!;357        358      // collection has never existed359      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;360      // collection has been burned361      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});362      await collection.burn(collectionOwner);363  364      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;365    });366  });367  368  describe('stopSponsoringCollection', () => {369    itSub('can not be called by non-admin', async ({helper}) => {370      const api = helper.getApi();371      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];372      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});373        374      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;375        376      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;377      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});378    });379  380    itSub('should set sponsoring as disabled', async ({helper}) => {381      const api = helper.getApi();382      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];383      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});384      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});385        386      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));387      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));388        389      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');390  391      // Transactions are not sponsored anymore:392      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);393      await token.transfer(collectionOwner, {Substrate: recepient.address});394      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);395      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);396    });397  398    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {399      const api = helper.getApi();400      const collectionOwner = accounts.pop()!;401      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});402      await collection.confirmSponsorship(collectionOwner);403        404      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;405        406      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});407    });408  409    itSub('should reject transaction if collection does not exist', async ({helper}) => {    410      const collectionOwner = accounts.pop()!;411      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});412        413      await collection.burn(collectionOwner);414      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');415      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');416    });417  });418  419  describe('contract sponsoring', () => {420    itEth('should set palletes address as a sponsor', async ({helper}) => {421      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();422      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);423      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);424  425      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);426      427      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  428      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  429      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({430        confirmed: {431          substrate: palletAddress,432        },433      });434    });435  436    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {437      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();438      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);439      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);440  441      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;442  443      // Contract is self sponsored444      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({445        confirmed: {446          ethereum: flipper.options.address.toLowerCase(),447        },448      });449  450      // set promotion sponsoring451      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);452  453      // new sponsor is pallet address454      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  455      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  456      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({457        confirmed: {458          substrate: palletAddress,459        },460      });461    });462  463    itEth('can be overwritten by contract owner', async ({helper}) => {464      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();465      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);466      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);467  468      // contract sponsored by pallet469      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);470  471      // owner sets self sponsoring472      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;473  474      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  475      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  476      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({477        confirmed: {478          ethereum: flipper.options.address.toLowerCase(),479        },480      });481    });482  483    itEth('can not be set by non admin', async ({helper}) => {484      const nonAdmin = accounts.pop()!;485      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();486      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);487      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);488  489      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;490  491      // nonAdmin calls sponsorContract492      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');493  494      // contract still self-sponsored 495      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({496        confirmed: {497          ethereum: flipper.options.address.toLowerCase(),498        },499      });500    });501  502    itEth('should actually sponsor transactions', async ({helper}) => {503      // Contract caller504      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);505      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);506          507      // Deploy flipper508      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();509      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);510      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);511      512      // Owner sets to sponsor every tx513      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});514      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});515      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);516  517      // Set promotion to the Flipper518      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);519  520      // Caller calls Flipper521      await flipper.methods.flip().send({from: caller});522      expect(await flipper.methods.getValue().call()).to.be.true;523  524      // The contracts and caller balances have not changed525      const callerBalance = await helper.balance.getEthereum(caller);526      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);527      expect(callerBalance).to.be.equal(1000n * nominal);528      expect(1000n * nominal === contractBalanceAfter).to.be.true;529  530      // The pallet balance has decreased531      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);532      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;533    });534  });535  536  describe('stopSponsoringContract', () => {  537    itEth('should remove pallet address from contract sponsors', async ({helper}) => {538      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);539      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();540      const flipper = await helper.eth.deployFlipper(contractOwner);541      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);542      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);543  544      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});545      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);546      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);547  548      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  549      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  550      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({551        disabled: null,552      });553  554      await flipper.methods.flip().send({from: caller});555      expect(await flipper.methods.getValue().call()).to.be.true;556  557      const callerBalance = await helper.balance.getEthereum(caller);558      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);559  560      // caller payed for call561      expect(1000n * nominal > callerBalance).to.be.true;562      // todo:playgrounds look into. why did it work before with 1000n, and is now 100n?563      expect(contractBalanceAfter).to.be.equal(100n * nominal);564    });565  566    itEth('can not be called by non-admin', async ({helper}) => {567      const nonAdmin = accounts.pop()!;568      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();569      const flipper = await helper.eth.deployFlipper(contractOwner);570  571      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);572      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))573        .to.be.rejectedWith(/appPromotion\.NoPermission/);574    });575  576    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {577      const nonAdmin = accounts.pop()!;578      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();579      const flipper = await helper.eth.deployFlipper(contractOwner);580      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);581      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;582  583      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');584    });585  });586  587  describe('rewards', () => {588    itSub('can not be called by non admin', async ({helper}) => {589      const nonAdmin = accounts.pop()!;590      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');591    });592  593    itSub('should increase total staked', async ({helper}) => {594      const staker = accounts.pop()!;595      const totalStakedBefore = await helper.staking.getTotalStaked();596      await helper.staking.stake(staker, 100n * nominal);597  598      // Wait for rewards and pay599      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});600      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));601      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);602  603      const totalStakedAfter = await helper.staking.getTotalStaked();604      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);605      // staker can unstake606      await helper.staking.unstake(staker);607      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));608    });609  610    itSub('should credit 0.05% for staking period', async ({helper}) => {    611      const staker = accounts.pop()!;612  613      await waitPromotionPeriodDoesntEnd(helper);614        615      await helper.staking.stake(staker, 100n * nominal);616      await helper.staking.stake(staker, 200n * nominal);617  618      // wait rewards are available:619      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});620      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));621  622      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;623      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));624  625      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});626      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));627      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));628    });629  630    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {631      const staker = accounts.pop()!;632  633      await helper.staking.stake(staker, 100n * nominal);634      // wait for two rewards are available:635      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});636      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);637  638      await helper.admin.payoutStakers(palletAdmin, 100);639      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});640      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);641      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);642  643      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);644  645      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});646    });647    648    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {649      // staker unstakes before rewards has been payed650      const staker = accounts.pop()!;651      await helper.staking.stake(staker, 100n * nominal);652      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});653      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);654      await helper.staking.unstake(staker);655        656      // so he did not receive any rewards657      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);658      await helper.admin.payoutStakers(palletAdmin, 100);659      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);660  661      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);662    });663    664    itSub('should bring compound interest', async ({helper}) => {665      const staker = accounts.pop()!;666              667      await helper.staking.stake(staker, 100n * nominal);668  669      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});670      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));671        672      await helper.admin.payoutStakers(palletAdmin, 100);673      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});674      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));675        676      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);677      await helper.admin.payoutStakers(palletAdmin, 100);678      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});679      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));680    });681  682    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {683      // all other stakes should be unstaked684      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);685  686      // stakers stakes 10 times each687      for (let i = 0; i < 10; i++) {688        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));689      }690      await helper.wait.newBlocks(40);691      await helper.admin.payoutStakers(palletAdmin, 100);692    });693  694    itSub.skip('can handle 40.000 rewards', async ({helper}) => {695      const crowdStakes = async () => {696        // each account in the crowd stakes 2 times697        const crowd = await helper.arrange.createCrowd(500, 300n, donor);698        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));699        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));700        // 701      };702  703      for (let i = 0; i < 40; i++) {704        await crowdStakes();705      }706  707      // TODO pay rewards for some period708    });709  });710});711712function calculatePalleteAddress(palletId: any) {713  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));714  return encodeAddress(address);715}716717function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {718  const DAY = 7200n;719  const ACCURACY = 1_000_000_000n;720  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;721  722  if (iter > 1) {723    return calculateIncome(income, calcPeriod, iter - 1);724  } else return income;725}726727// Wait while promotion period less than specified block, to avoid boundary cases728// 0 if this should be the beginning of the period.729async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {730  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();731  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;732733  if (currentPeriodBlock > waitBlockLessThan) {734    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);735  }736}
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/playgrounds';19import {DevUniqueHelper} from './util/playgrounds/unique.dev';20import {itEth, expect, SponsoringMode} from './eth/util/playgrounds';2122let donor: IKeyringPair;23let palletAdmin: IKeyringPair;24let nominal: bigint;25let palletAddress: string;26let accounts: IKeyringPair[];27const LOCKING_PERIOD = 20n; // 20 blocks of relay28const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain29const rewardAvailableInBlock = (stakedInBlock: bigint) => {30  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + 20n;31  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);32};3334describe('App promotion', () => {35  before(async function () {36    await usingPlaygrounds(async (helper, privateKey) => {37      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);38      donor = await privateKey({filename: __filename});39      palletAddress = helper.arrange.calculatePalleteAddress('appstake');40      palletAdmin = await privateKey('//PromotionAdmin');41      nominal = helper.balance.getOneTokenNominal();42      await helper.balance.transferToSubstrate(donor, palletAdmin.address, 1000n * nominal);43      await helper.balance.transferToSubstrate(donor, palletAddress, 1000n * nominal);44      accounts = await helper.arrange.createCrowd(100, 1000n, donor); // create accounts-pool to speed up tests45    });46  });4748  describe('stake extrinsic', () => {  49    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {50      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];51      const totalStakedBefore = await helper.staking.getTotalStaked();52  53      // Minimum stake amount is 100:54      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;55      await helper.staking.stake(staker, 100n * nominal);56  57      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...58      // ...so he can not transfer 90059      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});60      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');61      62      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);63      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);64      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 65      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 66  67      68      await helper.staking.stake(staker, 200n * nominal);69      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);70      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});71      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);72      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);73    });74  75    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {76      const [staker] = await helper.arrange.createAccounts([2000n], donor);77      for (let i = 0; i < 10; i++) {78        await helper.staking.stake(staker, 100n * nominal);79      }80  81      // can have 10 stakes82      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);83      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);84  85      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');86  87      // After unstake can stake again88      await helper.staking.unstake(staker);89      await helper.staking.stake(staker, 100n * nominal);90      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);91    });92    93    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {94      const staker = accounts.pop()!;95  96      // Can't stake full balance because Alice needs to pay some fee97      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;98      await helper.staking.stake(staker, 500n * nominal);99  100      // Can't stake 500 tkn because Alice has Less than 500 transferable;101      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 102      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);103    });104    105    itSub('for different accounts in one block is possible', async ({helper}) => {106      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];107        108      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));109      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;110  111      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));112      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);113    });114  });115  116  describe('unstake extrinsic', () => {  117    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {118      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];119      const totalStakedBefore = await helper.staking.getTotalStaked();120      await helper.staking.stake(staker, 900n * nominal);121      await helper.staking.unstake(staker);122  123      // Right after unstake balance is reserved124      // Staker can not transfer 125      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});126      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');127      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);128      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);129      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);130    });131  132    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {133      const staker = accounts.pop()!;134      await helper.staking.stake(staker, 100n * nominal);135      await helper.staking.unstake(staker);136      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});137  138      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n139      await helper.wait.forParachainBlockNumber(pendingUnstake.block);140      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});141      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);142  143      // staker can transfer:144      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);145      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);146    });147  148    itSub('should successfully unstake multiple stakes', async ({helper}) => {149      const staker = accounts.pop()!;150      await helper.staking.stake(staker, 100n * nominal);151      await helper.staking.stake(staker, 200n * nominal);152      await helper.staking.stake(staker, 300n * nominal);153  154      // staked: [100, 200, 300]; unstaked: 0155      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});156      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});157      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});158      expect(totalPendingUnstake).to.be.deep.equal(0n);159      expect(pendingUnstake).to.be.deep.equal([]);160      expect(stakes[0].amount).to.equal(100n * nominal);161      expect(stakes[1].amount).to.equal(200n * nominal);162      expect(stakes[2].amount).to.equal(300n * nominal);163       164      // Can unstake multiple stakes165      await helper.staking.unstake(staker);166      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});167      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});168      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});169      expect(totalPendingUnstake).to.be.equal(600n * nominal);170      expect(stakes).to.be.deep.equal([]);171      expect(pendingUnstake[0].amount).to.equal(600n * nominal);172  173      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});174      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);175      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});176      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);177    });178  179    itSub('should not have any effects if no active stakes', async ({helper}) => {180      const staker = accounts.pop()!;181        182      // unstake has no effect if no stakes at all183      await helper.staking.unstake(staker);184      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);185      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper186  187      // TODO stake() unstake() waitUnstaked() unstake();188  189      // can't unstake if there are only pendingUnstakes190      await helper.staking.stake(staker, 100n * nominal);191      await helper.staking.unstake(staker);192      await helper.staking.unstake(staker);193  194      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);195      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);196    });197  198    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {199      const staker = accounts.pop()!;200      await helper.staking.stake(staker, 100n * nominal);201      await helper.staking.unstake(staker);202      await helper.staking.stake(staker, 120n * nominal);203      await helper.staking.unstake(staker);204  205      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});206      expect(unstakingPerBlock).has.length(2);207      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);208      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);209    });210  211    itSub('should be possible for different accounts in one block', async ({helper}) => {212      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];213  214      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));215      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));216  217      await Promise.all(stakers.map(async (staker) => {218        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);219        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);220      }));221    });222  });223  224  describe('collection sponsoring', () => {225    itSub('should actually sponsor transactions', async ({helper}) => {226      const api = helper.getApi();227      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];228      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});229      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});230      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));231      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);232  233      await token.transfer(tokenSender, {Substrate: receiver.address});234      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});235      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);236  237      // senders balance the same, transaction has sponsored238      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);239      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;240    });241  242    itSub('can not be set by non admin', async ({helper}) => {243      const api = helper.getApi();244      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];245  246      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});247        248      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;249      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');250    });251  252    itSub('should set pallet address as confirmed admin', async ({helper}) => {253      const api = helper.getApi();254      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];255        256      // Can set sponsoring for collection without sponsor257      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});258      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;259      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});260  261      // Can set sponsoring for collection with unconfirmed sponsor262      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});263      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});264      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;265      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});266  267      // Can set sponsoring for collection with confirmed sponsor268      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});269      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);270      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;271      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});272    });273  274    itSub('can be overwritten by collection owner', async ({helper}) => {    275      const api = helper.getApi();276      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];277      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});278      const collectionId = collection.collectionId;279        280      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;281        282      // Collection limits still can be changed by the owner283      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;284      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);285      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});286  287      // Collection sponsor can be changed too288      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;289      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});290    });291    292    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {293      const api = helper.getApi();294      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};295      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});296  297      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;298      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);299    });300    301    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {302      const api = helper.getApi();303      const collectionOwner = accounts.pop()!;304        305      // collection has never existed306      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;307      // collection has been burned308      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});309      await collection.burn(collectionOwner);310  311      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;312    });313  });314  315  describe('stopSponsoringCollection', () => {316    itSub('can not be called by non-admin', async ({helper}) => {317      const api = helper.getApi();318      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];319      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});320        321      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;322        323      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;324      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});325    });326  327    itSub('should set sponsoring as disabled', async ({helper}) => {328      const api = helper.getApi();329      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];330      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});331      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});332        333      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));334      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));335        336      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');337  338      // Transactions are not sponsored anymore:339      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);340      await token.transfer(collectionOwner, {Substrate: recepient.address});341      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);342      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);343    });344  345    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {346      const api = helper.getApi();347      const collectionOwner = accounts.pop()!;348      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});349      await collection.confirmSponsorship(collectionOwner);350        351      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;352        353      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});354    });355  356    itSub('should reject transaction if collection does not exist', async ({helper}) => {    357      const collectionOwner = accounts.pop()!;358      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});359        360      await collection.burn(collectionOwner);361      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');362      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');363    });364  });365  366  describe('contract sponsoring', () => {367    itEth('should set palletes address as a sponsor', async ({helper}) => {368      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();369      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);370      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);371  372      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);373      374      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  375      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  376      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({377        confirmed: {378          substrate: palletAddress,379        },380      });381    });382  383    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {384      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();385      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);386      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);387  388      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;389  390      // Contract is self sponsored391      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({392        confirmed: {393          ethereum: flipper.options.address.toLowerCase(),394        },395      });396  397      // set promotion sponsoring398      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);399  400      // new sponsor is pallet address401      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  402      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  403      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({404        confirmed: {405          substrate: palletAddress,406        },407      });408    });409  410    itEth('can be overwritten by contract owner', async ({helper}) => {411      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();412      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);413      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);414  415      // contract sponsored by pallet416      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);417  418      // owner sets self sponsoring419      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;420  421      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  422      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  423      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({424        confirmed: {425          ethereum: flipper.options.address.toLowerCase(),426        },427      });428    });429  430    itEth('can not be set by non admin', async ({helper}) => {431      const nonAdmin = accounts.pop()!;432      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();433      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);434      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);435  436      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;437  438      // nonAdmin calls sponsorContract439      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');440  441      // contract still self-sponsored 442      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({443        confirmed: {444          ethereum: flipper.options.address.toLowerCase(),445        },446      });447    });448  449    itEth('should actually sponsor transactions', async ({helper}) => {450      // Contract caller451      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);452      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);453          454      // Deploy flipper455      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();456      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);457      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);458      459      // Owner sets to sponsor every tx460      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});461      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});462      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);463  464      // Set promotion to the Flipper465      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);466  467      // Caller calls Flipper468      await flipper.methods.flip().send({from: caller});469      expect(await flipper.methods.getValue().call()).to.be.true;470  471      // The contracts and caller balances have not changed472      const callerBalance = await helper.balance.getEthereum(caller);473      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);474      expect(callerBalance).to.be.equal(1000n * nominal);475      expect(1000n * nominal === contractBalanceAfter).to.be.true;476  477      // The pallet balance has decreased478      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);479      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;480    });481  });482  483  describe('stopSponsoringContract', () => {  484    itEth('should remove pallet address from contract sponsors', async ({helper}) => {485      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);486      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();487      const flipper = await helper.eth.deployFlipper(contractOwner);488      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);489      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);490  491      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});492      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);493      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);494  495      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  496      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  497      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({498        disabled: null,499      });500  501      await flipper.methods.flip().send({from: caller});502      expect(await flipper.methods.getValue().call()).to.be.true;503  504      const callerBalance = await helper.balance.getEthereum(caller);505      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);506  507      // caller payed for call508      expect(1000n * nominal > callerBalance).to.be.true;509      // todo:playgrounds look into. why did it work before with 1000n, and is now 100n?510      expect(contractBalanceAfter).to.be.equal(100n * nominal);511    });512  513    itEth('can not be called by non-admin', async ({helper}) => {514      const nonAdmin = accounts.pop()!;515      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();516      const flipper = await helper.eth.deployFlipper(contractOwner);517  518      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);519      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))520        .to.be.rejectedWith(/appPromotion\.NoPermission/);521    });522  523    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {524      const nonAdmin = accounts.pop()!;525      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();526      const flipper = await helper.eth.deployFlipper(contractOwner);527      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);528      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;529  530      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');531    });532  });533  534  describe('rewards', () => {535    itSub('can not be called by non admin', async ({helper}) => {536      const nonAdmin = accounts.pop()!;537      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');538    });539  540    itSub('should increase total staked', async ({helper}) => {541      const staker = accounts.pop()!;542      const totalStakedBefore = await helper.staking.getTotalStaked();543      await helper.staking.stake(staker, 100n * nominal);544  545      // Wait for rewards and pay546      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});547      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));548      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);549  550      const totalStakedAfter = await helper.staking.getTotalStaked();551      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);552      // staker can unstake553      await helper.staking.unstake(staker);554      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));555    });556  557    itSub('should credit 0.05% for staking period', async ({helper}) => {    558      const staker = accounts.pop()!;559  560      await waitPromotionPeriodDoesntEnd(helper);561        562      await helper.staking.stake(staker, 100n * nominal);563      await helper.staking.stake(staker, 200n * nominal);564  565      // wait rewards are available:566      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});567      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));568  569      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;570      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));571  572      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});573      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));574      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));575    });576  577    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {578      const staker = accounts.pop()!;579  580      await helper.staking.stake(staker, 100n * nominal);581      // wait for two rewards are available:582      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});583      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);584  585      await helper.admin.payoutStakers(palletAdmin, 100);586      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});587      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);588      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);589  590      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);591  592      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});593    });594    595    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {596      // staker unstakes before rewards has been payed597      const staker = accounts.pop()!;598      await helper.staking.stake(staker, 100n * nominal);599      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});600      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);601      await helper.staking.unstake(staker);602        603      // so he did not receive any rewards604      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);605      await helper.admin.payoutStakers(palletAdmin, 100);606      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);607  608      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);609    });610    611    itSub('should bring compound interest', async ({helper}) => {612      const staker = accounts.pop()!;613              614      await helper.staking.stake(staker, 100n * nominal);615  616      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});617      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));618        619      await helper.admin.payoutStakers(palletAdmin, 100);620      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});621      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));622        623      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);624      await helper.admin.payoutStakers(palletAdmin, 100);625      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});626      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));627    });628  629    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {630      // all other stakes should be unstaked631      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);632  633      // stakers stakes 10 times each634      for (let i = 0; i < 10; i++) {635        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));636      }637      await helper.wait.newBlocks(40);638      await helper.admin.payoutStakers(palletAdmin, 100);639    });640  641    itSub.skip('can handle 40.000 rewards', async ({helper}) => {642      const crowdStakes = async () => {643        // each account in the crowd stakes 2 times644        const crowd = await helper.arrange.createCrowd(500, 300n, donor);645        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));646        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));647        // 648      };649  650      for (let i = 0; i < 40; i++) {651        await crowdStakes();652      }653  654      // TODO pay rewards for some period655    });656  });657});658659function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {660  const DAY = 7200n;661  const ACCURACY = 1_000_000_000n;662  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;663  664  if (iter > 1) {665    return calculateIncome(income, calcPeriod, iter - 1);666  } else return income;667}668669// Wait while promotion period less than specified block, to avoid boundary cases670// 0 if this should be the beginning of the period.671async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {672  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();673  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;674675  if (currentPeriodBlock > waitBlockLessThan) {676    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);677  }678}
modifiedtests/src/util/playgrounds/unique.dev.tsdiffbeforeafterboth
--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -1,7 +1,8 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 
-import {mnemonicGenerate} from '@polkadot/util-crypto';
+import {stringToU8a} from '@polkadot/util';
+import {encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';
 import {UniqueHelper} from './unique';
 import {ApiPromise, WsProvider} from '@polkadot/api';
 import * as defs from '../../interfaces/definitions';
@@ -243,6 +244,11 @@
     
     return balance;
   }
+
+  calculatePalleteAddress(palletId: any) {
+    const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));
+    return encodeAddress(address);
+  }
 }
 
 class WaitGroup {