git.delta.rocks / unique-network / refs/commits / 9a57db1ccb4e

difftreelog

Merge pull request #645 from UniqueNetwork/tests/feed-alices-promotion

Farhad Hakimov2022-10-12parents: #8a971f8 #7af2e99.patch.diff
in: master
Split promotion tests to sequential and parallel

6 files changed

modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -21,21 +21,22 @@
   },
   "mocha": {
     "timeout": 9999999,
-    "require": "ts-node/register"
+    "require": ["ts-node/register", "./src/util/playgrounds/globalSetup.ts"]
   },
   "scripts": {
     "lint": "eslint --ext .ts,.js src/",
     "fix": "eslint --ext .ts,.js src/ --fix",
-    "feedAlices": "ts-node ./src/util/playgrounds/feedAlices.ts",
 
-    "test": "yarn feedAlices && mocha --parallel --timeout 9999999 -r ts-node/register './src/**/*.test.ts'",
-    "testSequential": "yarn feedAlices && mocha --timeout 9999999 -r ts-node/register './src/**/*.seqtest.ts'",
-    "testStructure": "yarn feedAlices && mocha --parallel --timeout 9999999 -r ts-node/register ./**/nesting/**.test.ts",
-    "testEth": "yarn feedAlices && mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/**/*.test.ts'",
-    "testEthNesting": "yarn feedAlices && mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/nesting/**/*.test.ts'",
-    "testEthFractionalizer": "yarn feedAlices && mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/fractionalizer/**/*.test.ts'",
-    "testEthMarketplace": "yarn feedAlices && mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/marketplace/**/*.test.ts'",
-    "testEvent": "yarn feedAlices && mocha --parallel --timeout 9999999 -r ts-node/register ./src/check-event/*.test.ts",
+    "test": "yarn testParallel && yarn testSequential",
+    "testParallel": "mocha --parallel --timeout 9999999 -r ts-node/register './src/**/*.test.ts'",
+    "testSequential": "mocha --timeout 9999999 -r ts-node/register './src/**/*.seqtest.ts'",
+    "testDevnode": "mocha --timeout 9999999 -r ts-node/register './src/**/*test.ts'",
+    "testStructure": "mocha --parallel --timeout 9999999 -r ts-node/register ./**/nesting/**.test.ts",
+    "testEth": "mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/**/*.test.ts'",
+    "testEthNesting": "mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/nesting/**/*.test.ts'",
+    "testEthFractionalizer": "mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/fractionalizer/**/*.test.ts'",
+    "testEthMarketplace": "mocha --parallel --timeout 9999999 -r ts-node/register './**/eth/marketplace/**/*.test.ts'",
+    "testEvent": "mocha --parallel --timeout 9999999 -r ts-node/register ./src/check-event/*.test.ts",
     "testRmrk": "mocha --timeout 9999999 -r ts-node/register ./**/rmrk/**test.ts",
 
     "testEthPayable": "mocha --timeout 9999999 -r ts-node/register './**/eth/payable.test.ts'",
addedtests/src/app-promotion.seqtest.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/app-promotion.seqtest.ts
@@ -0,0 +1,74 @@
+// 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;
+
+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});
+      palletAdmin = await privateKey('//PromotionAdmin');
+      const api = helper.getApi();
+      await helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));
+    });
+  });
+
+  describe('admin adress', () => {
+    itSub('can be set by sudo only', async ({helper}) => {
+      const api = helper.getApi();
+      const [nonAdmin] = await helper.arrange.createAccounts([10n], donor);
+      // 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] = await helper.arrange.createAccounts([10n], donor);
+      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] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
+      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      accounts = await helper.arrange.createCrowd(100, 1000n, donor); // create accounts-pool to speed up tests43    });44  });4546  describe('stake extrinsic', () => {  47    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {48      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];49      const totalStakedBefore = await helper.staking.getTotalStaked();50  51      // Minimum stake amount is 100:52      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;53      await helper.staking.stake(staker, 100n * nominal);54  55      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...56      // ...so he can not transfer 90057      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});58      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');59      60      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);61      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);62      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 63      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 64  65      66      await helper.staking.stake(staker, 200n * nominal);67      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);68      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});69      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);70      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);71    });72  73    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {74      const [staker] = await helper.arrange.createAccounts([2000n], donor);75      for (let i = 0; i < 10; i++) {76        await helper.staking.stake(staker, 100n * nominal);77      }78  79      // can have 10 stakes80      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);81      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);82  83      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');84  85      // After unstake can stake again86      await helper.staking.unstake(staker);87      await helper.staking.stake(staker, 100n * nominal);88      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);89    });90    91    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {92      const staker = accounts.pop()!;93  94      // Can't stake full balance because Alice needs to pay some fee95      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;96      await helper.staking.stake(staker, 500n * nominal);97  98      // Can't stake 500 tkn because Alice has Less than 500 transferable;99      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 100      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);101    });102    103    itSub('for different accounts in one block is possible', async ({helper}) => {104      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];105        106      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));107      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;108  109      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));110      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);111    });112  });113  114  describe('unstake extrinsic', () => {  115    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {116      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];117      const totalStakedBefore = await helper.staking.getTotalStaked();118      await helper.staking.stake(staker, 900n * nominal);119      await helper.staking.unstake(staker);120  121      // Right after unstake balance is reserved122      // Staker can not transfer 123      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});124      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');125      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);126      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);127      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);128    });129  130    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {131      const staker = accounts.pop()!;132      await helper.staking.stake(staker, 100n * nominal);133      await helper.staking.unstake(staker);134      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});135  136      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n137      await helper.wait.forParachainBlockNumber(pendingUnstake.block);138      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});139      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);140  141      // staker can transfer:142      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);143      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);144    });145  146    itSub('should successfully unstake multiple stakes', async ({helper}) => {147      const staker = accounts.pop()!;148      await helper.staking.stake(staker, 100n * nominal);149      await helper.staking.stake(staker, 200n * nominal);150      await helper.staking.stake(staker, 300n * nominal);151  152      // staked: [100, 200, 300]; unstaked: 0153      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});154      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});155      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});156      expect(totalPendingUnstake).to.be.deep.equal(0n);157      expect(pendingUnstake).to.be.deep.equal([]);158      expect(stakes[0].amount).to.equal(100n * nominal);159      expect(stakes[1].amount).to.equal(200n * nominal);160      expect(stakes[2].amount).to.equal(300n * nominal);161       162      // Can unstake multiple stakes163      await helper.staking.unstake(staker);164      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});165      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});166      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});167      expect(totalPendingUnstake).to.be.equal(600n * nominal);168      expect(stakes).to.be.deep.equal([]);169      expect(pendingUnstake[0].amount).to.equal(600n * nominal);170  171      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});172      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);173      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});174      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);175    });176  177    itSub('should not have any effects if no active stakes', async ({helper}) => {178      const staker = accounts.pop()!;179        180      // unstake has no effect if no stakes at all181      await helper.staking.unstake(staker);182      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);183      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper184  185      // TODO stake() unstake() waitUnstaked() unstake();186  187      // can't unstake if there are only pendingUnstakes188      await helper.staking.stake(staker, 100n * nominal);189      await helper.staking.unstake(staker);190      await helper.staking.unstake(staker);191  192      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);193      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);194    });195  196    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {197      const staker = accounts.pop()!;198      await helper.staking.stake(staker, 100n * nominal);199      await helper.staking.unstake(staker);200      await helper.staking.stake(staker, 120n * nominal);201      await helper.staking.unstake(staker);202  203      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});204      expect(unstakingPerBlock).has.length(2);205      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);206      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);207    });208  209    itSub('should be possible for different accounts in one block', async ({helper}) => {210      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];211  212      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));213      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));214  215      await Promise.all(stakers.map(async (staker) => {216        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);217        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);218      }));219    });220  });221  222  describe('collection sponsoring', () => {223    itSub('should actually sponsor transactions', async ({helper}) => {224      const api = helper.getApi();225      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];226      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});227      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});228      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));229      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);230  231      await token.transfer(tokenSender, {Substrate: receiver.address});232      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});233      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);234  235      // senders balance the same, transaction has sponsored236      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);237      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;238    });239  240    itSub('can not be set by non admin', async ({helper}) => {241      const api = helper.getApi();242      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];243  244      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});245        246      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;247      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');248    });249  250    itSub('should set pallet address as confirmed admin', async ({helper}) => {251      const api = helper.getApi();252      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];253        254      // Can set sponsoring for collection without sponsor255      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});256      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;257      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});258  259      // Can set sponsoring for collection with unconfirmed sponsor260      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});261      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});262      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;263      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});264  265      // Can set sponsoring for collection with confirmed sponsor266      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});267      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);268      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;269      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});270    });271  272    itSub('can be overwritten by collection owner', async ({helper}) => {    273      const api = helper.getApi();274      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];275      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});276      const collectionId = collection.collectionId;277        278      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;279        280      // Collection limits still can be changed by the owner281      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;282      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);283      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});284  285      // Collection sponsor can be changed too286      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;287      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});288    });289    290    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {291      const api = helper.getApi();292      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};293      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});294  295      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;296      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);297    });298    299    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {300      const api = helper.getApi();301      const collectionOwner = accounts.pop()!;302        303      // collection has never existed304      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;305      // collection has been burned306      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});307      await collection.burn(collectionOwner);308  309      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;310    });311  });312  313  describe('stopSponsoringCollection', () => {314    itSub('can not be called by non-admin', async ({helper}) => {315      const api = helper.getApi();316      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];317      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});318        319      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;320        321      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;322      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});323    });324  325    itSub('should set sponsoring as disabled', async ({helper}) => {326      const api = helper.getApi();327      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];328      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});329      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});330        331      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));332      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));333        334      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');335  336      // Transactions are not sponsored anymore:337      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);338      await token.transfer(collectionOwner, {Substrate: recepient.address});339      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);340      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);341    });342  343    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {344      const api = helper.getApi();345      const collectionOwner = accounts.pop()!;346      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});347      await collection.confirmSponsorship(collectionOwner);348        349      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;350        351      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});352    });353  354    itSub('should reject transaction if collection does not exist', async ({helper}) => {    355      const collectionOwner = accounts.pop()!;356      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});357        358      await collection.burn(collectionOwner);359      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');360      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');361    });362  });363  364  describe('contract sponsoring', () => {365    itEth('should set palletes address as a sponsor', async ({helper}) => {366      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();367      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);368      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);369  370      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);371      372      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  373      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  374      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({375        confirmed: {376          substrate: palletAddress,377        },378      });379    });380  381    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {382      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();383      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);384      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);385  386      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;387  388      // Contract is self sponsored389      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({390        confirmed: {391          ethereum: flipper.options.address.toLowerCase(),392        },393      });394  395      // set promotion sponsoring396      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);397  398      // new sponsor is pallet address399      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          substrate: palletAddress,404        },405      });406    });407  408    itEth('can be overwritten by contract owner', async ({helper}) => {409      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();410      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);411      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);412  413      // contract sponsored by pallet414      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);415  416      // owner sets self sponsoring417      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;418  419      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  420      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  421      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({422        confirmed: {423          ethereum: flipper.options.address.toLowerCase(),424        },425      });426    });427  428    itEth('can not be set by non admin', async ({helper}) => {429      const nonAdmin = accounts.pop()!;430      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();431      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);432      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);433  434      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;435  436      // nonAdmin calls sponsorContract437      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');438  439      // contract still self-sponsored 440      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({441        confirmed: {442          ethereum: flipper.options.address.toLowerCase(),443        },444      });445    });446  447    itEth('should actually sponsor transactions', async ({helper}) => {448      // Contract caller449      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);450      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);451          452      // Deploy flipper453      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();454      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);455      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);456      457      // Owner sets to sponsor every tx458      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});459      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});460      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);461  462      // Set promotion to the Flipper463      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);464  465      // Caller calls Flipper466      await flipper.methods.flip().send({from: caller});467      expect(await flipper.methods.getValue().call()).to.be.true;468  469      // The contracts and caller balances have not changed470      const callerBalance = await helper.balance.getEthereum(caller);471      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);472      expect(callerBalance).to.be.equal(1000n * nominal);473      expect(1000n * nominal === contractBalanceAfter).to.be.true;474  475      // The pallet balance has decreased476      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);477      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;478    });479  });480  481  describe('stopSponsoringContract', () => {  482    itEth('should remove pallet address from contract sponsors', async ({helper}) => {483      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);484      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();485      const flipper = await helper.eth.deployFlipper(contractOwner);486      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);487      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);488  489      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});490      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);491      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);492  493      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  494      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  495      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({496        disabled: null,497      });498  499      await flipper.methods.flip().send({from: caller});500      expect(await flipper.methods.getValue().call()).to.be.true;501  502      const callerBalance = await helper.balance.getEthereum(caller);503      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);504  505      // caller payed for call506      expect(1000n * nominal > callerBalance).to.be.true;507      // todo:playgrounds look into. why did it work before with 1000n, and is now 100n?508      expect(contractBalanceAfter).to.be.equal(100n * nominal);509    });510  511    itEth('can not be called by non-admin', async ({helper}) => {512      const nonAdmin = accounts.pop()!;513      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();514      const flipper = await helper.eth.deployFlipper(contractOwner);515  516      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);517      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))518        .to.be.rejectedWith(/appPromotion\.NoPermission/);519    });520  521    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {522      const nonAdmin = accounts.pop()!;523      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();524      const flipper = await helper.eth.deployFlipper(contractOwner);525      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);526      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;527  528      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');529    });530  });531  532  describe('rewards', () => {533    itSub('can not be called by non admin', async ({helper}) => {534      const nonAdmin = accounts.pop()!;535      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');536    });537  538    itSub('should increase total staked', async ({helper}) => {539      const staker = accounts.pop()!;540      const totalStakedBefore = await helper.staking.getTotalStaked();541      await helper.staking.stake(staker, 100n * nominal);542  543      // Wait for rewards and pay544      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});545      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));546      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);547  548      const totalStakedAfter = await helper.staking.getTotalStaked();549      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);550      // staker can unstake551      await helper.staking.unstake(staker);552      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));553    });554  555    itSub('should credit 0.05% for staking period', async ({helper}) => {    556      const staker = accounts.pop()!;557  558      await waitPromotionPeriodDoesntEnd(helper);559        560      await helper.staking.stake(staker, 100n * nominal);561      await helper.staking.stake(staker, 200n * nominal);562  563      // wait rewards are available:564      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});565      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));566  567      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;568      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));569  570      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});571      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));572      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));573    });574  575    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {576      const staker = accounts.pop()!;577  578      await helper.staking.stake(staker, 100n * nominal);579      // wait for two rewards are available:580      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});581      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);582  583      await helper.admin.payoutStakers(palletAdmin, 100);584      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});585      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);586      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);587  588      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);589  590      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});591    });592    593    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {594      // staker unstakes before rewards has been payed595      const staker = accounts.pop()!;596      await helper.staking.stake(staker, 100n * nominal);597      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});598      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);599      await helper.staking.unstake(staker);600        601      // so he did not receive any rewards602      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);603      await helper.admin.payoutStakers(palletAdmin, 100);604      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);605  606      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);607    });608    609    itSub('should bring compound interest', async ({helper}) => {610      const staker = accounts.pop()!;611              612      await helper.staking.stake(staker, 100n * nominal);613  614      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});615      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));616        617      await helper.admin.payoutStakers(palletAdmin, 100);618      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});619      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));620        621      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);622      await helper.admin.payoutStakers(palletAdmin, 100);623      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});624      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));625    });626  627    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {628      // all other stakes should be unstaked629      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);630  631      // stakers stakes 10 times each632      for (let i = 0; i < 10; i++) {633        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));634      }635      await helper.wait.newBlocks(40);636      await helper.admin.payoutStakers(palletAdmin, 100);637    });638  639    itSub.skip('can handle 40.000 rewards', async ({helper}) => {640      const crowdStakes = async () => {641        // each account in the crowd stakes 2 times642        const crowd = await helper.arrange.createCrowd(500, 300n, donor);643        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));644        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));645        // 646      };647  648      for (let i = 0; i < 40; i++) {649        await crowdStakes();650      }651  652      // TODO pay rewards for some period653    });654  });655});656657function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {658  const DAY = 7200n;659  const ACCURACY = 1_000_000_000n;660  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;661  662  if (iter > 1) {663    return calculateIncome(income, calcPeriod, iter - 1);664  } else return income;665}666667// Wait while promotion period less than specified block, to avoid boundary cases668// 0 if this should be the beginning of the period.669async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {670  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();671  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;672673  if (currentPeriodBlock > waitBlockLessThan) {674    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);675  }676}
deletedtests/src/util/playgrounds/feedAlices.tsdiffbeforeafterboth
--- a/tests/src/util/playgrounds/feedAlices.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// SPDX-License-Identifier: Apache-2.0
-
-import * as path from 'path';
-import {promises as fs} from 'fs';
-import {usingPlaygrounds} from '.';
-
-async function getFiles(rootPath: string): Promise<string[]> {
-  const files = await fs.readdir(rootPath, {withFileTypes: true});
-  const filenames: string[] = [];
-  for (const entry of files) {
-    const res = path.resolve(rootPath, entry.name);
-    if (entry.isDirectory()) {
-      filenames.push(...await getFiles(res));
-    } else {
-      filenames.push(res);
-    }
-  }
-  return filenames;
-}
-
-const fundFilenames = async () => {
-  await usingPlaygrounds(async (helper, privateKey) => {
-    const oneToken = helper.balance.getOneTokenNominal();
-    const alice = await privateKey('//Alice');
-    const nonce = await helper.chain.getNonce(alice.address);
-    const filenames = await getFiles(path.resolve(__dirname, '../..'));
-
-    // batching is actually undesired, it takes away the time while all the transactions actually succeed
-    const batchSize = 300;
-    let balanceGrantedCounter = 0;
-    for (let b = 0; b < filenames.length; b += batchSize) {
-      const tx = [];
-      let batchBalanceGrantedCounter = 0;
-      for (let i = 0; batchBalanceGrantedCounter < batchSize && b + i < filenames.length; i++) {
-        const f = filenames[b + i];
-        if (!f.endsWith('.test.ts') || f.includes('.outdated')) continue;
-        const account = await privateKey({filename: f, ignoreFundsPresence: true});
-        const aliceBalance = await helper.balance.getSubstrate(account.address);
-
-        if (aliceBalance < 100_000n * oneToken) {
-          tx.push(helper.executeExtrinsic(
-            alice, 
-            'api.tx.balances.transfer',
-            [account.address, 1_000_000n * oneToken],
-            true,
-            {nonce: nonce + balanceGrantedCounter++},
-          ).then(() => true).catch(() => {console.error(`Transaction to ${path.basename(f)} registered as failed. Strange.`); return false;}));
-          batchBalanceGrantedCounter++;
-        }
-      }
-
-      if(tx.length > 0) {
-        console.log(`Granting funds to ${batchBalanceGrantedCounter} filename accounts.`);
-        const result = await Promise.all(tx);
-        if (result && result.lastIndexOf(false) > -1) throw new Error('The transactions actually probably succeeded, should check the balances.');
-      }
-    }
-
-    if (balanceGrantedCounter == 0) console.log('No account needs additional funding.');
-  });
-};
-
-const fundFilenamesWithRetries = async (retriesLeft: number): Promise<boolean> => {
-  if (retriesLeft <= 0) return Promise.resolve(false);
-  return fundFilenames()
-    .then(() => Promise.resolve(true))
-    .catch(e => {
-      console.error(e);
-      console.error(`Some transactions might have failed. ${retriesLeft > 1 ? 'Retrying...' : 'Something is wrong.'}\n`);
-      return fundFilenamesWithRetries(--retriesLeft);
-    });
-};
-
-fundFilenamesWithRetries(3).then((result) => process.exit(result ? 0 : 1)).catch(e => {
-  console.error(e);
-  process.exit(1);
-});
addedtests/src/util/playgrounds/globalSetup.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/util/playgrounds/globalSetup.ts
@@ -0,0 +1,102 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+import {usingPlaygrounds, Pallets} from './index';
+import * as path from 'path';
+import {promises as fs} from 'fs';
+
+// This file is used in the mocha package.json section
+export async function mochaGlobalSetup() {
+  await usingPlaygrounds(async (helper, privateKey) => {
+    try {
+      // 1. Create donors
+      await fundFilenamesWithRetries(3)
+        .then((result) => {
+          if (!result) process.exit(1);
+        });
+
+      // 2. 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);
+      }
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+}
+
+async function getFiles(rootPath: string): Promise<string[]> {
+  const files = await fs.readdir(rootPath, {withFileTypes: true});
+  const filenames: string[] = [];
+  for (const entry of files) {
+    const res = path.resolve(rootPath, entry.name);
+    if (entry.isDirectory()) {
+      filenames.push(...await getFiles(res));
+    } else {
+      filenames.push(res);
+    }
+  }
+  return filenames;
+}
+
+const fundFilenames = async () => {
+  await usingPlaygrounds(async (helper, privateKey) => {
+    const oneToken = helper.balance.getOneTokenNominal();
+    const alice = await privateKey('//Alice');
+    const nonce = await helper.chain.getNonce(alice.address);
+    const filenames = await getFiles(path.resolve(__dirname, '../..'));
+
+    // batching is actually undesired, it takes away the time while all the transactions actually succeed
+    const batchSize = 300;
+    let balanceGrantedCounter = 0;
+    for (let b = 0; b < filenames.length; b += batchSize) {
+      const tx = [];
+      let batchBalanceGrantedCounter = 0;
+      for (let i = 0; batchBalanceGrantedCounter < batchSize && b + i < filenames.length; i++) {
+        const f = filenames[b + i];
+        if (!f.endsWith('.test.ts') && !f.endsWith('seqtest.ts') || f.includes('.outdated')) continue;
+        const account = await privateKey({filename: f, ignoreFundsPresence: true});
+        const aliceBalance = await helper.balance.getSubstrate(account.address);
+
+        if (aliceBalance < 100_000n * oneToken) {
+          tx.push(helper.executeExtrinsic(
+            alice, 
+            'api.tx.balances.transfer',
+            [account.address, 1_000_000n * oneToken],
+            true,
+            {nonce: nonce + balanceGrantedCounter++},
+          ).then(() => true).catch(() => {console.error(`Transaction to ${path.basename(f)} registered as failed. Strange.`); return false;}));
+          batchBalanceGrantedCounter++;
+        }
+      }
+
+      if(tx.length > 0) {
+        console.log(`Granting funds to ${batchBalanceGrantedCounter} filename accounts.`);
+        const result = await Promise.all(tx);
+        if (result && result.lastIndexOf(false) > -1) throw new Error('The transactions actually probably succeeded, should check the balances.');
+      }
+    }
+
+    if (balanceGrantedCounter == 0) console.log('No account needs additional funding.');
+  });
+};
+
+const fundFilenamesWithRetries = async (retriesLeft: number): Promise<boolean> => {
+  if (retriesLeft <= 0) return Promise.resolve(false);
+  return fundFilenames()
+    .then(() => Promise.resolve(true))
+    .catch(e => {
+      console.error(e);
+      console.error(`Some transactions might have failed. ${retriesLeft > 1 ? 'Retrying...' : 'Something is wrong.'}\n`);
+      return fundFilenamesWithRetries(--retriesLeft);
+    });
+};
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 {