git.delta.rocks / unique-network / refs/commits / 3833b2da5ea7

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