git.delta.rocks / unique-network / refs/commits / d1851d8ede93

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 alice: IKeyringPair;25let palletAdmin: IKeyringPair;26let nominal: bigint;27const palletAddress = calculatePalleteAddress('appstake');28let accounts: IKeyringPair[] = [];29const LOCKING_PERIOD = 20n; // 20 blocks of relay30const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain31const rewardAvailableInBlock = (stakedInBlock: bigint) => {32  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + 20n;33  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);34};3536describe('App promotion', () => {37  before(async function () {38    await usingPlaygrounds(async (helper, privateKey) => {39      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);40      alice = await privateKey({filename: __filename});41      [palletAdmin] = await helper.arrange.createAccounts([100n], alice);42      const api = helper.getApi();43      await helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));44      nominal = helper.balance.getOneTokenNominal();45      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);46      await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);47      accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests48    });49  });5051  describe('stake extrinsic', () => {  52    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {53      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];54      const totalStakedBefore = await helper.staking.getTotalStaked();55  56      // Minimum stake amount is 100:57      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;58      await helper.staking.stake(staker, 100n * nominal);59  60      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...61      // ...so he can not transfer 90062      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});63      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');64      65      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);66      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);67      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 68      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 69  70      71      await helper.staking.stake(staker, 200n * nominal);72      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);73      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});74      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);75      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);76    });77  78    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {79      const [staker] = await helper.arrange.createAccounts([2000n], alice);80      for (let i = 0; i < 10; i++) {81        await helper.staking.stake(staker, 100n * nominal);82      }83  84      // can have 10 stakes85      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);86      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);87  88      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');89  90      // After unstake can stake again91      await helper.staking.unstake(staker);92      await helper.staking.stake(staker, 100n * nominal);93      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);94    });95    96    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {97      const staker = accounts.pop()!;98  99      // Can't stake full balance because Alice needs to pay some fee100      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;101      await helper.staking.stake(staker, 500n * nominal);102  103      // Can't stake 500 tkn because Alice has Less than 500 transferable;104      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 105      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);106    });107    108    itSub('for different accounts in one block is possible', async ({helper}) => {109      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];110        111      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));112      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;113  114      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));115      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);116    });117  });118  119  describe('unstake extrinsic', () => {  120    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {121      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];122      const totalStakedBefore = await helper.staking.getTotalStaked();123      await helper.staking.stake(staker, 900n * nominal);124      await helper.staking.unstake(staker);125  126      // Right after unstake balance is reserved127      // Staker can not transfer 128      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});129      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');130      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);131      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);132      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);133    });134  135    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {136      const staker = accounts.pop()!;137      await helper.staking.stake(staker, 100n * nominal);138      await helper.staking.unstake(staker);139      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});140  141      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n142      await helper.wait.forParachainBlockNumber(pendingUnstake.block);143      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});144      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);145  146      // staker can transfer:147      await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);148      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);149    });150  151    itSub('should successfully unstake multiple stakes', async ({helper}) => {152      const staker = accounts.pop()!;153      await helper.staking.stake(staker, 100n * nominal);154      await helper.staking.stake(staker, 200n * nominal);155      await helper.staking.stake(staker, 300n * nominal);156  157      // staked: [100, 200, 300]; unstaked: 0158      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});159      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});160      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});161      expect(totalPendingUnstake).to.be.deep.equal(0n);162      expect(pendingUnstake).to.be.deep.equal([]);163      expect(stakes[0].amount).to.equal(100n * nominal);164      expect(stakes[1].amount).to.equal(200n * nominal);165      expect(stakes[2].amount).to.equal(300n * nominal);166       167      // Can unstake multiple stakes168      await helper.staking.unstake(staker);169      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});170      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});171      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});172      expect(totalPendingUnstake).to.be.equal(600n * nominal);173      expect(stakes).to.be.deep.equal([]);174      expect(pendingUnstake[0].amount).to.equal(600n * nominal);175  176      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});177      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);178      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});179      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);180    });181  182    itSub('should not have any effects if no active stakes', async ({helper}) => {183      const staker = accounts.pop()!;184        185      // unstake has no effect if no stakes at all186      await helper.staking.unstake(staker);187      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);188      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper189  190      // TODO stake() unstake() waitUnstaked() unstake();191  192      // can't unstake if there are only pendingUnstakes193      await helper.staking.stake(staker, 100n * nominal);194      await helper.staking.unstake(staker);195      await helper.staking.unstake(staker);196  197      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);198      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);199    });200  201    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {202      const staker = accounts.pop()!;203      await helper.staking.stake(staker, 100n * nominal);204      await helper.staking.unstake(staker);205      await helper.staking.stake(staker, 120n * nominal);206      await helper.staking.unstake(staker);207  208      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});209      expect(unstakingPerBlock).has.length(2);210      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);211      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);212    });213  214    itSub('should be possible for different accounts in one block', async ({helper}) => {215      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];216  217      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));218      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));219  220      await Promise.all(stakers.map(async (staker) => {221        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);222        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);223      }));224    });225  });226  227  describe('admin adress', () => {228    itSub('can be set by sudo only', async ({helper}) => {229      const api = helper.getApi();230      const nonAdmin = accounts.pop()!;231      // nonAdmin can not set admin not from himself nor as a sudo232      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;233      await expect(helper.signTransaction(nonAdmin, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;234  235      // Alice can236      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;237    });238    239    itSub('can be any valid CrossAccountId', async ({helper}) => {240      // We are not going to set an eth address as a sponsor,241      // but we do want to check, it doesn't break anything;242      const api = helper.getApi();243      const account = accounts.pop()!;244      const ethAccount = helper.address.substrateToEth(account.address); 245      // Alice sets Ethereum address as a sudo. Then Substrate address back...246      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;247      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;248        249      // ...It doesn't break anything;250      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});251      await expect(helper.signTransaction(account, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;252    });253  254    itSub('can be reassigned', async ({helper}) => {255      const api = helper.getApi();256      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];257      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});258        259      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: oldAdmin.address})))).to.be.fulfilled;260      await expect(helper.signTransaction(alice, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: newAdmin.address})))).to.be.fulfilled;261      await expect(helper.signTransaction(oldAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;262        263      await expect(helper.signTransaction(newAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;264    });265  });266  267  describe('collection sponsoring', () => {268    before(async function () {269      await usingPlaygrounds(async (helper) => {270        const api = helper.getApi();271        const tx = api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));272        await helper.signTransaction(alice, tx);273      });274    });275  276    itSub('should actually sponsor transactions', async ({helper}) => {277      const api = helper.getApi();278      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];279      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});280      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});281      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));282      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);283  284      await token.transfer(tokenSender, {Substrate: receiver.address});285      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});286      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);287  288      // senders balance the same, transaction has sponsored289      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);290      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;291    });292  293    itSub('can not be set by non admin', async ({helper}) => {294      const api = helper.getApi();295      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];296  297      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});298        299      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;300      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');301    });302  303    itSub('should set pallet address as confirmed admin', async ({helper}) => {304      const api = helper.getApi();305      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];306        307      // Can set sponsoring for collection without sponsor308      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});309      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;310      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});311  312      // Can set sponsoring for collection with unconfirmed sponsor313      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});314      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});315      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;316      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});317  318      // Can set sponsoring for collection with confirmed sponsor319      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});320      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);321      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;322      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});323    });324  325    itSub('can be overwritten by collection owner', async ({helper}) => {    326      const api = helper.getApi();327      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];328      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});329      const collectionId = collection.collectionId;330        331      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;332        333      // Collection limits still can be changed by the owner334      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;335      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);336      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});337  338      // Collection sponsor can be changed too339      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;340      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});341    });342    343    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {344      const api = helper.getApi();345      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};346      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});347  348      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;349      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);350    });351    352    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {353      const api = helper.getApi();354      const collectionOwner = accounts.pop()!;355        356      // collection has never existed357      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;358      // collection has been burned359      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});360      await collection.burn(collectionOwner);361  362      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;363    });364  });365  366  describe('stopSponsoringCollection', () => {367    itSub('can not be called by non-admin', async ({helper}) => {368      const api = helper.getApi();369      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];370      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});371        372      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;373        374      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;375      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});376    });377  378    itSub('should set sponsoring as disabled', async ({helper}) => {379      const api = helper.getApi();380      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];381      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});382      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});383        384      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));385      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));386        387      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');388  389      // Transactions are not sponsored anymore:390      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);391      await token.transfer(collectionOwner, {Substrate: recepient.address});392      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);393      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);394    });395  396    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {397      const api = helper.getApi();398      const collectionOwner = accounts.pop()!;399      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});400      await collection.confirmSponsorship(collectionOwner);401        402      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;403        404      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});405    });406  407    itSub('should reject transaction if collection does not exist', async ({helper}) => {    408      const collectionOwner = accounts.pop()!;409      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});410        411      await collection.burn(collectionOwner);412      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');413      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');414    });415  });416  417  describe('contract sponsoring', () => {418    itEth('should set palletes address as a sponsor', async ({helper}) => {419      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();420      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);421      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);422  423      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);424      425      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  426      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  427      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({428        confirmed: {429          substrate: palletAddress,430        },431      });432    });433  434    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {435      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();436      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);437      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);438  439      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;440  441      // Contract is self sponsored442      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({443        confirmed: {444          ethereum: flipper.options.address.toLowerCase(),445        },446      });447  448      // set promotion sponsoring449      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);450  451      // new sponsor is pallet address452      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  453      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  454      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({455        confirmed: {456          substrate: palletAddress,457        },458      });459    });460  461    itEth('can be overwritten by contract owner', async ({helper}) => {462      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();463      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);464      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);465  466      // contract sponsored by pallet467      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);468  469      // owner sets self sponsoring470      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;471  472      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  473      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  474      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({475        confirmed: {476          ethereum: flipper.options.address.toLowerCase(),477        },478      });479    });480  481    itEth('can not be set by non admin', async ({helper}) => {482      const nonAdmin = accounts.pop()!;483      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();484      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);485      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);486  487      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;488  489      // nonAdmin calls sponsorContract490      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');491  492      // contract still self-sponsored 493      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({494        confirmed: {495          ethereum: flipper.options.address.toLowerCase(),496        },497      });498    });499  500    itEth('should actually sponsor transactions', async ({helper}) => {501      // Contract caller502      const caller = await helper.eth.createAccountWithBalance(alice, 1000n);503      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);504          505      // Deploy flipper506      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();507      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);508      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);509      510      // Owner sets to sponsor every tx511      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});512      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});513      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);514  515      // Set promotion to the Flipper516      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);517  518      // Caller calls Flipper519      await flipper.methods.flip().send({from: caller});520      expect(await flipper.methods.getValue().call()).to.be.true;521  522      // The contracts and caller balances have not changed523      const callerBalance = await helper.balance.getEthereum(caller);524      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);525      expect(callerBalance).to.be.equal(1000n * nominal);526      expect(1000n * nominal === contractBalanceAfter).to.be.true;527  528      // The pallet balance has decreased529      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);530      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;531    });532  });533  534  describe('stopSponsoringContract', () => {  535    itEth('should remove pallet address from contract sponsors', async ({helper}) => {536      const caller = await helper.eth.createAccountWithBalance(alice, 1000n);537      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();538      const flipper = await helper.eth.deployFlipper(contractOwner);539      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address);540      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);541  542      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});543      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);544      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);545  546      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  547      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  548      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({549        disabled: null,550      });551  552      await flipper.methods.flip().send({from: caller});553      expect(await flipper.methods.getValue().call()).to.be.true;554  555      const callerBalance = await helper.balance.getEthereum(caller);556      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);557  558      // caller payed for call559      expect(1000n * nominal > callerBalance).to.be.true;560      expect(contractBalanceAfter).to.be.equal(1000n * nominal);561    });562  563    itEth('can not be called by non-admin', async ({helper}) => {564      const nonAdmin = accounts.pop()!;565      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();566      const flipper = await helper.eth.deployFlipper(contractOwner);567  568      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);569      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))570        .to.be.rejectedWith(/appPromotion\.NoPermission/);571    });572  573    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {574      const nonAdmin = accounts.pop()!;575      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();576      const flipper = await helper.eth.deployFlipper(contractOwner);577      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);578      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;579  580      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');581    });582  });583  584  describe('rewards', () => {585    itSub('can not be called by non admin', async ({helper}) => {586      const nonAdmin = accounts.pop()!;587      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');588    });589  590    itSub('should increase total staked', async ({helper}) => {591      const staker = accounts.pop()!;592      const totalStakedBefore = await helper.staking.getTotalStaked();593      await helper.staking.stake(staker, 100n * nominal);594  595      // Wait for rewards and pay596      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});597      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));598      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);599  600      const totalStakedAfter = await helper.staking.getTotalStaked();601      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);602      // staker can unstake603      await helper.staking.unstake(staker);604      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));605    });606  607    itSub('should credit 0.05% for staking period', async ({helper}) => {    608      const staker = accounts.pop()!;609  610      await waitPromotionPeriodDoesntEnd(helper);611        612      await helper.staking.stake(staker, 100n * nominal);613      await helper.staking.stake(staker, 200n * nominal);614  615      // wait rewards are available:616      const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});617      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));618  619      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;620      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));621  622      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});623      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));624      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));625    });626  627    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {628      const staker = accounts.pop()!;629  630      await helper.staking.stake(staker, 100n * nominal);631      // wait for two rewards are available:632      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});633      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);634  635      await helper.admin.payoutStakers(palletAdmin, 100);636      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});637      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);638      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);639  640      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);641  642      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});643    });644    645    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {646      // staker unstakes before rewards has been payed647      const staker = accounts.pop()!;648      await helper.staking.stake(staker, 100n * nominal);649      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});650      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);651      await helper.staking.unstake(staker);652        653      // so he did not receive any rewards654      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);655      await helper.admin.payoutStakers(palletAdmin, 100);656      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);657  658      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);659    });660    661    itSub('should bring compound interest', async ({helper}) => {662      const staker = accounts.pop()!;663              664      await helper.staking.stake(staker, 100n * nominal);665  666      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});667      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));668        669      await helper.admin.payoutStakers(palletAdmin, 100);670      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});671      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));672        673      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);674      await helper.admin.payoutStakers(palletAdmin, 100);675      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});676      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));677    });678  679    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {680      // all other stakes should be unstaked681      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);682  683      // stakers stakes 10 times each684      for (let i = 0; i < 10; i++) {685        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));686      }687      await helper.wait.newBlocks(40);688      await helper.admin.payoutStakers(palletAdmin, 100);689    });690  691    itSub.skip('can handle 40.000 rewards', async ({helper}) => {692      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);693      const crowdStakes = async () => {694        // each account in the crowd stakes 2 times695        const crowd = await helper.arrange.createCrowd(500, 300n, donor);696        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));697        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));698        // 699      };700  701      for (let i = 0; i < 40; i++) {702        await crowdStakes();703      }704  705      // TODO pay rewards for some period706    });707  });708});709710function calculatePalleteAddress(palletId: any) {711  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));712  return encodeAddress(address);713}714715function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {716  const DAY = 7200n;717  const ACCURACY = 1_000_000_000n;718  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;719  720  if (iter > 1) {721    return calculateIncome(income, calcPeriod, iter - 1);722  } else return income;723}724725// Wait while promotion period less than specified block, to avoid boundary cases726// 0 if this should be the beginning of the period.727async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {728  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();729  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;730731  if (currentPeriodBlock > waitBlockLessThan) {732    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);733  }734}