git.delta.rocks / unique-network / refs/commits / 4a2e26d0c0f3

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 {19  itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip, LOCKING_PERIOD, UNLOCKING_PERIOD,20} from '../../util';21import {DevUniqueHelper} from '../../util/playgrounds/unique.dev';22import {itEth, expect, SponsoringMode} from '../../eth/util';2324let donor: IKeyringPair;25let palletAdmin: IKeyringPair;26let nominal: bigint;27let palletAddress: string;28let accounts: IKeyringPair[];29// App promotion periods:30// LOCKING_PERIOD = 12 blocks of relay31// UNLOCKING_PERIOD = 6 blocks of parachain3233describe('App promotion', () => {34  before(async function () {35    await usingPlaygrounds(async (helper, privateKey) => {36      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);37      donor = await privateKey({filename: __filename});38      palletAddress = helper.arrange.calculatePalletAddress('appstake');39      palletAdmin = await privateKey('//PromotionAdmin');40      nominal = helper.balance.getOneTokenNominal();4142      const accountBalances = new Array(100);43      accountBalances.fill(1000n);44      accounts = await helper.arrange.createAccounts(accountBalances, 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();5253      // 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);5657      // 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      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: 100n * nominal, reasons: 'All'}]);61      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');6263      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);64      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);65      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo?66      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased676869      await helper.staking.stake(staker, 200n * nominal);70      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);71      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});72      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);73      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);74    });7576    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {77      const [staker] = await helper.arrange.createAccounts([2000n], donor);78      for (let i = 0; i < 10; i++) {79        await helper.staking.stake(staker, 100n * nominal);80      }8182      // can have 10 stakes83      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);84      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);8586      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');8788      // After unstake can stake again89      await helper.staking.unstake(staker);90      await helper.staking.stake(staker, 100n * nominal);91      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);92    });9394    itSub('should allow to stake() if balance is locked with different id', async ({helper}) => {95      const staker = accounts.pop()!;9697      // staker has tokens locked with vesting id:98      await helper.balance.vestedTransfer(donor, staker.address, {start: 0n, period: 1n, periodCount: 1n, perPeriod: 200n * nominal});99      expect(await helper.balance.getSubstrateFull(staker.address))100        .to.deep.contain({free: 1200n * nominal, miscFrozen: 200n * nominal, feeFrozen: 200n * nominal, reserved: 0n});101102      // Locked balance can be staked. staker can stake 1200 tokens (minus fee):103      await helper.staking.stake(staker, 1000n * nominal);104      await helper.staking.stake(staker, 199n * nominal);105      // check balances106      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'ormlvest', amount: 200n * nominal, reasons: 'All'}, {id: 'appstake', amount: 1199n * nominal, reasons: 'All'}]);107      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 1199n * nominal, feeFrozen: 1199n * nominal});108      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.eq(1199n);109      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.eq(1199n * nominal);110111      // staker can unstake112      await helper.staking.unstake(staker);113      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.eq(1199n * nominal);114      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});115      await helper.wait.forParachainBlockNumber(pendingUnstake.block);116117      // check balances118      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'ormlvest', amount: 200n * nominal, reasons: 'All'}]);119      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 200n * nominal, feeFrozen: 200n * nominal});120      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.eq(1199n);121      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.eq(0n);122123      // staker can transfer balances now124      await helper.balance.transferToSubstrate(staker, donor.address, 900n * nominal);125    });126127    itSub('should not allow to stake(), if stake amount is more than total free balance minus locked by staking', async ({helper}) => {128      const staker = accounts.pop()!;129130      // Can't stake full balance because Alice needs to pay some fee131      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected; // With('Arithmetic')132      await helper.staking.stake(staker, 500n * nominal);133134      // Can't stake 500 tkn because Alice has Less than 500 transferable;135      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejected; // With('Arithmetic');136      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);137    });138139    itSub('for different accounts in one block is possible', async ({helper}) => {140      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];141142      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));143      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;144145      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));146      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);147    });148  });149150  describe('unstake extrinsic', () => {151    itSub('should move tokens to "pendingUnstake" map and subtract it from totalStaked', async ({helper}) => {152      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];153      const totalStakedBefore = await helper.staking.getTotalStaked();154      await helper.staking.stake(staker, 900n * nominal);155      await helper.staking.unstake(staker);156157      // Right after unstake tokens are still locked158      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: 900n * nominal, reasons: 'All'}]);159      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 900n * nominal, feeFrozen: 900n * nominal});160      // Staker can not transfer161      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');162      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);163      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);164      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);165    });166167    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {168      const staker = accounts.pop()!;169      await helper.staking.stake(staker, 100n * nominal);170      await helper.staking.unstake(staker);171      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});172173      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n174      await helper.wait.forParachainBlockNumber(pendingUnstake.block);175      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});176      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);177178      // staker can transfer:179      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);180      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);181    });182183    itSub('should successfully unstake multiple stakes', async ({helper}) => {184      const staker = accounts.pop()!;185      await helper.staking.stake(staker, 100n * nominal);186      await helper.staking.stake(staker, 200n * nominal);187      await helper.staking.stake(staker, 300n * nominal);188189      // staked: [100, 200, 300]; unstaked: 0190      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});191      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});192      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});193      expect(totalPendingUnstake).to.be.deep.equal(0n);194      expect(pendingUnstake).to.be.deep.equal([]);195      expect(stakes[0].amount).to.equal(100n * nominal);196      expect(stakes[1].amount).to.equal(200n * nominal);197      expect(stakes[2].amount).to.equal(300n * nominal);198199      // Can unstake multiple stakes200      await helper.staking.unstake(staker);201      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});202      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});203      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});204      expect(totalPendingUnstake).to.be.equal(600n * nominal);205      expect(stakes).to.be.deep.equal([]);206      expect(pendingUnstake[0].amount).to.equal(600n * nominal);207208      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 600n * nominal, miscFrozen: 600n * nominal});209      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);210      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);211      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});212      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);213    });214215    itSub('should not have any effects if no active stakes', async ({helper}) => {216      const staker = accounts.pop()!;217218      // unstake has no effect if no stakes at all219      await helper.staking.unstake(staker);220      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);221      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper222223      // TODO stake() unstake() waitUnstaked() unstake();224225      // can't unstake if there are only pendingUnstakes226      await helper.staking.stake(staker, 100n * nominal);227      await helper.staking.unstake(staker);228      await helper.staking.unstake(staker);229230      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);231      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);232    });233234    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {235      const staker = accounts.pop()!;236      await helper.staking.stake(staker, 100n * nominal);237      await helper.staking.unstake(staker);238      await helper.staking.stake(staker, 120n * nominal);239      await helper.staking.unstake(staker);240241      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});242      expect(unstakingPerBlock).has.length(2);243      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);244      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);245    });246247    itSub('should be possible for 3 accounts in one block', async ({helper}) => {248      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];249250      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));251      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));252253      await Promise.all(stakers.map(async (staker) => {254        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);255        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);256      }));257    });258259    itSub('should not be possible for more than 3 accounts in one block', async ({helper}) => {260      if (!await helper.arrange.isDevNode()) {261        const stakers = await helper.arrange.createAccounts([200n,200n,200n,200n,200n,200n,200n,200n,200n,200n], donor);262263        await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));264        const unstakingResults = await Promise.allSettled(stakers.map(staker => helper.staking.unstake(staker)));265266        const successfulUnstakes = unstakingResults.filter(result => result.status === 'fulfilled');267        expect(successfulUnstakes).to.have.length(3);268      }269    });270  });271272  describe('collection sponsoring', () => {273    itSub('should actually sponsor transactions', async ({helper}) => {274      const api = helper.getApi();275      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];276      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});277      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});278      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));279      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);280281      await token.transfer(tokenSender, {Substrate: receiver.address});282      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});283      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);284285      // senders balance the same, transaction has sponsored286      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);287      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;288    });289290    itSub('can not be set by non admin', async ({helper}) => {291      const api = helper.getApi();292      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];293294      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});295296      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;297      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');298    });299300    itSub('should set pallet address as confirmed admin', async ({helper}) => {301      const api = helper.getApi();302      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];303304      // Can set sponsoring for collection without sponsor305      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});306      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;307      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});308309      // Can set sponsoring for collection with unconfirmed sponsor310      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});311      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});312      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;313      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});314315      // Can set sponsoring for collection with confirmed sponsor316      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});317      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);318      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;319      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});320    });321322    itSub('can be overwritten by collection owner', async ({helper}) => {323      const api = helper.getApi();324      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];325      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});326      const collectionId = collection.collectionId;327328      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;329330      // Collection limits still can be changed by the owner331      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;332      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);333      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});334335      // Collection sponsor can be changed too336      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;337      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});338    });339340    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {341      const api = helper.getApi();342      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};343      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});344345      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;346      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);347    });348349    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {350      const api = helper.getApi();351      const collectionOwner = accounts.pop()!;352353      // collection has never existed354      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;355      // collection has been burned356      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});357      await collection.burn(collectionOwner);358359      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;360    });361  });362363  describe('stopSponsoringCollection', () => {364    itSub('can not be called by non-admin', async ({helper}) => {365      const api = helper.getApi();366      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];367      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});368369      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;370371      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;372      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});373    });374375    itSub('should set sponsoring as disabled', async ({helper}) => {376      const api = helper.getApi();377      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];378      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});379      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});380381      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));382      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));383384      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');385386      // Transactions are not sponsored anymore:387      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);388      await token.transfer(collectionOwner, {Substrate: recepient.address});389      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);390      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);391    });392393    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {394      const api = helper.getApi();395      const collectionOwner = accounts.pop()!;396      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});397      await collection.confirmSponsorship(collectionOwner);398399      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;400401      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});402    });403404    itSub('should reject transaction if collection does not exist', async ({helper}) => {405      const collectionOwner = accounts.pop()!;406      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});407408      await collection.burn(collectionOwner);409      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');410      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');411    });412  });413414  describe('contract sponsoring', () => {415    itEth('should set palletes address as a sponsor', async ({helper}) => {416      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();417      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);418      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);419420      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);421422      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;423      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);424      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({425        confirmed: {426          substrate: palletAddress,427        },428      });429    });430431    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {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 = await helper.ethNativeContract.contractHelpers(contractOwner);435436      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;437438      // Contract is self sponsored439      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({440        confirmed: {441          ethereum: flipper.options.address.toLowerCase(),442        },443      });444445      // set promotion sponsoring446      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);447448      // new sponsor is pallet address449      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;450      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);451      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({452        confirmed: {453          substrate: palletAddress,454        },455      });456    });457458    itEth('can be overwritten by contract owner', async ({helper}) => {459      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();460      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);461      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);462463      // contract sponsored by pallet464      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);465466      // owner sets self sponsoring467      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;468469      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;470      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);471      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({472        confirmed: {473          ethereum: flipper.options.address.toLowerCase(),474        },475      });476    });477478    itEth('can not be set by non admin', async ({helper}) => {479      const nonAdmin = accounts.pop()!;480      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();481      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);482      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);483484      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;485486      // nonAdmin calls sponsorContract487      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');488489      // contract still self-sponsored490      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({491        confirmed: {492          ethereum: flipper.options.address.toLowerCase(),493        },494      });495    });496497    itEth('should actually sponsor transactions', async ({helper}) => {498      // Contract caller499      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);500      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);501502      // Deploy flipper503      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();504      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);505      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);506507      // Owner sets to sponsor every tx508      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});509      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});510      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);511512      // Set promotion to the Flipper513      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);514515      // Caller calls Flipper516      await flipper.methods.flip().send({from: caller});517      expect(await flipper.methods.getValue().call()).to.be.true;518519      // The contracts and caller balances have not changed520      const callerBalance = await helper.balance.getEthereum(caller);521      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);522      expect(callerBalance).to.be.equal(1000n * nominal);523      expect(1000n * nominal === contractBalanceAfter).to.be.true;524525      // The pallet balance has decreased526      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);527      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;528    });529  });530531  describe('stopSponsoringContract', () => {532    itEth('should remove pallet address from contract sponsors', async ({helper}) => {533      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);534      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();535      const flipper = await helper.eth.deployFlipper(contractOwner);536      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);537      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);538539      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});540      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);541      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);542543      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;544      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);545      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({546        disabled: null,547      });548549      await flipper.methods.flip().send({from: caller});550      expect(await flipper.methods.getValue().call()).to.be.true;551552      const callerBalance = await helper.balance.getEthereum(caller);553      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);554555      // caller payed for call556      expect(1000n * nominal > callerBalance).to.be.true;557      expect(contractBalanceAfter).to.be.equal(100n * nominal);558    });559560    itEth('can not be called by non-admin', async ({helper}) => {561      const nonAdmin = accounts.pop()!;562      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();563      const flipper = await helper.eth.deployFlipper(contractOwner);564565      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);566      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))567        .to.be.rejectedWith(/appPromotion\.NoPermission/);568    });569570    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {571      const nonAdmin = accounts.pop()!;572      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();573      const flipper = await helper.eth.deployFlipper(contractOwner);574      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);575      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;576577      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');578    });579  });580581  describe('payoutStakers', () => {582    itSub('can not be called by non admin', async ({helper}) => {583      const nonAdmin = accounts.pop()!;584      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');585    });586587    itSub('should increase total staked', async ({helper}) => {588      const staker = accounts.pop()!;589      const totalStakedBefore = await helper.staking.getTotalStaked();590      await helper.staking.stake(staker, 100n * nominal);591592      // Wait for rewards and pay593      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});594      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));595      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);596597      const totalStakedAfter = await helper.staking.getTotalStaked();598      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);599      // staker can unstake600      await helper.staking.unstake(staker);601      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal));602    });603604    itSub('should credit 0.05% for staking period', async ({helper}) => {605      const staker = accounts.pop()!;606607      await waitPromotionPeriodDoesntEnd(helper);608609      await helper.staking.stake(staker, 100n * nominal);610      await helper.staking.stake(staker, 200n * nominal);611612      // wait rewards are available:613      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});614      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));615616      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;617      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal));618619      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});620      const income1 = calculateIncome(100n * nominal);621      const income2 = calculateIncome(200n * nominal);622      expect(totalStakedPerBlock[0].amount).to.equal(income1);623      expect(totalStakedPerBlock[1].amount).to.equal(income2);624625      const stakerBalance = await helper.balance.getSubstrateFull(staker.address);626      expect(stakerBalance).to.contain({miscFrozen: income1 + income2, feeFrozen: income1 + income2, reserved: 0n});627      expect(stakerBalance.free / nominal).to.eq(999n);628    });629630    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {631      const staker = accounts.pop()!;632633      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);637638      await helper.admin.payoutStakers(palletAdmin, 100);639      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});640      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);641      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);642643      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);644645      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});646    });647648    itSub('should not be credited for pending-unstaked tokens', async ({helper}) => {649      // staker unstakes before rewards 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);655656      // 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);660661      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);662    });663664    itSub('should bring compound interest', async ({helper}) => {665      const staker = accounts.pop()!;666667      await helper.staking.stake(staker, 100n * nominal);668669      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});670      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));671672      await helper.admin.payoutStakers(palletAdmin, 100);673      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});674      expect(stake.amount).to.equal(calculateIncome(100n * nominal));675676      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, 2));680    });681682    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);685686      // 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    });693694    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      };702703      for (let i = 0; i < 40; i++) {704        await crowdStakes();705      }706707      // TODO pay rewards for some period708    });709  });710});711712function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {713  const DAY = 7200n;714  const ACCURACY = 1_000_000_000n;715  // 5n / 10_000n = 0.05% p/day716  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;717718  if (iter > 1) {719    return calculateIncome(income, iter - 1, calcPeriod);720  } else return income;721}722723function rewardAvailableInBlock(stakedInBlock: bigint) {724  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;725  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);726}727728// Wait while promotion period less than specified block, to avoid boundary cases729// 0 if this should be the beginning of the period.730async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {731  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();732  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;733734  if (currentPeriodBlock > waitBlockLessThan) {735    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);736  }737}