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

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  normalizeAccountId,20  getModuleNames,21  Pallets,22} from './util/helpers';23import {itSub, usingPlaygrounds} from './util/playgrounds';24import {encodeAddress} from '@polkadot/util-crypto';25import {stringToU8a} from '@polkadot/util';26import {SponsoringMode} from './eth/util/helpers';27import {DevUniqueHelper} from './util/playgrounds/unique.dev';28import {itEth, expect} from './eth/util/playgrounds';2930let alice: IKeyringPair;31let palletAdmin: IKeyringPair;32let nominal: bigint;33const palletAddress = calculatePalleteAddress('appstake');34let accounts: IKeyringPair[] = [];35const LOCKING_PERIOD = 20n; // 20 blocks of relay36const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain37const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);3839describe('App promotion', () => {40  before(async function () {41    await usingPlaygrounds(async (helper, privateKey) => {42      if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();43      alice = privateKey('//Alice');44      palletAdmin = privateKey('//Charlie'); // TODO use custom address45      await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));46      nominal = helper.balance.getOneTokenNominal();47      await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);48      await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);49      accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests50    });51  });5253  describe('stake extrinsic', () => {  54    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {55      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];56      const totalStakedBefore = await helper.staking.getTotalStaked();57  58      // Minimum stake amount is 100:59      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;60      await helper.staking.stake(staker, 100n * nominal);61  62      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...63      // ...so he can not transfer 90064      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});65      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');66      67      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);68      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);69      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 70      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 71  72      73      await helper.staking.stake(staker, 200n * nominal);74      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);75      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});76      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);77      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);78    });79  80    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {81      const [staker] = await helper.arrange.createAccounts([2000n], alice);82      for (let i = 0; i < 10; i++) {83        await helper.staking.stake(staker, 100n * nominal);84      }85  86      // can have 10 stakes87      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);88      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);89  90      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');91  92      // After unstake can stake again93      await helper.staking.unstake(staker);94      await helper.staking.stake(staker, 100n * nominal);95      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);96    });97    98    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {99      const staker = accounts.pop()!;100  101      // Can't stake full balance because Alice needs to pay some fee102      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;103      await helper.staking.stake(staker, 500n * nominal);104  105      // Can't stake 500 tkn because Alice has Less than 500 transferable;106      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 107      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);108    });109    110    itSub('for different accounts in one block is possible', async ({helper}) => {111      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];112        113      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));114      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;115  116      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));117      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);118    });119  });120  121  describe('unstake extrinsic', () => {  122    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {123      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];124      const totalStakedBefore = await helper.staking.getTotalStaked();125      await helper.staking.stake(staker, 900n * nominal);126      await helper.staking.unstake(staker);127  128      // Right after unstake balance is reserved129      // Staker can not transfer 130      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});131      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');132      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);133      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);134      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);135    });136  137    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {138      const staker = accounts.pop()!;139      await helper.staking.stake(staker, 100n * nominal);140      await helper.staking.unstake(staker);141      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});142  143      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n144      await helper.wait.forParachainBlockNumber(pendingUnstake.block);145      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});146      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);147  148      // staker can transfer:149      await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);150      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);151    });152  153    itSub('should successfully unstake multiple stakes', async ({helper}) => {154      const staker = accounts.pop()!;155      await helper.staking.stake(staker, 100n * nominal);156      await helper.staking.stake(staker, 200n * nominal);157      await helper.staking.stake(staker, 300n * nominal);158  159      // staked: [100, 200, 300]; unstaked: 0160      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});161      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});162      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});163      expect(totalPendingUnstake).to.be.deep.equal(0n);164      expect(pendingUnstake).to.be.deep.equal([]);165      expect(stakes[0].amount).to.equal(100n * nominal);166      expect(stakes[1].amount).to.equal(200n * nominal);167      expect(stakes[2].amount).to.equal(300n * nominal);168       169      // Can unstake multiple stakes170      await helper.staking.unstake(staker);171      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});172      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});173      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});174      expect(totalPendingUnstake).to.be.equal(600n * nominal);175      expect(stakes).to.be.deep.equal([]);176      expect(pendingUnstake[0].amount).to.equal(600n * nominal);177  178      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});179      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);180      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});181      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);182    });183  184    itSub('should not have any effects if no active stakes', async ({helper}) => {185      const staker = accounts.pop()!;186        187      // unstake has no effect if no stakes at all188      await helper.staking.unstake(staker);189      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);190      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper191  192      // TODO stake() unstake() waitUnstaked() unstake();193  194      // can't unstake if there are only pendingUnstakes195      await helper.staking.stake(staker, 100n * nominal);196      await helper.staking.unstake(staker);197      await helper.staking.unstake(staker);198  199      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);200      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);201    });202  203    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {204      const staker = accounts.pop()!;205      await helper.staking.stake(staker, 100n * nominal);206      await helper.staking.unstake(staker);207      await helper.staking.stake(staker, 120n * nominal);208      await helper.staking.unstake(staker);209  210      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});211      expect(unstakingPerBlock).has.length(2);212      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);213      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);214    });215  216    itSub('should be possible for different accounts in one block', async ({helper}) => {217      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];218  219      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));220      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));221  222      await Promise.all(stakers.map(async (staker) => {223        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);224        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);225      }));226    });227  });228  229  describe('admin adress', () => {230    itSub('can be set by sudo only', async ({helper}) => {231      const nonAdmin = accounts.pop()!;232      // nonAdmin can not set admin not from himself nor as a sudo233      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;234      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;235  236      // Alice can237      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;238    });239    240    itSub('can be any valid CrossAccountId', async ({helper}) => {241      // We are not going to set an eth address as a sponsor,242      // but we do want to check, it doesn't break anything;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, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;247      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.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, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;252    });253  254    itSub('can be reassigned', async ({helper}) => {255      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];256      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});257        258      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.fulfilled;259      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.fulfilled;260      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;261        262      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;263    });264  });265  266  describe('collection sponsoring', () => {267    before(async function () {268      await usingPlaygrounds(async (helper) => {269        const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));270        await helper.signTransaction(alice, tx);271      });272    });273  274    itSub('should actually sponsor transactions', async ({helper}) => {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, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));279      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);280  281      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);284  285      // 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    });289  290    itSub('can not be set by non admin', async ({helper}) => {291      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];292  293      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});294        295      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;296      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');297    });298  299    itSub('should set pallet address as confirmed admin', async ({helper}) => {300      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];301        302      // Can set sponsoring for collection without sponsor303      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});304      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;305      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});306  307      // Can set sponsoring for collection with unconfirmed sponsor308      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});309      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});310      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;311      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});312  313      // Can set sponsoring for collection with confirmed sponsor314      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});315      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);316      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;317      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});318    });319  320    itSub('can be overwritten by collection owner', async ({helper}) => {    321      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];322      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});323      const collectionId = collection.collectionId;324        325      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;326        327      // Collection limits still can be changed by the owner328      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;329      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);330      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});331  332      // Collection sponsor can be changed too333      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;334      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});335    });336    337    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {338      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};339      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});340  341      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;342      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);343    });344    345    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {346      const collectionOwner = accounts.pop()!;347        348      // collection has never existed349      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;350      // collection has been burned351      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});352      await collection.burn(collectionOwner);353  354      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;355    });356  });357  358  describe('stopSponsoringCollection', () => {359    itSub('can not be called by non-admin', async ({helper}) => {    360      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];361      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});362        363      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;364        365      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;366      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});367    });368  369    itSub('should set sponsoring as disabled', async ({helper}) => {370      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];371      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});372      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});373        374      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));375      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));376        377      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');378  379      // Transactions are not sponsored anymore:380      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);381      await token.transfer(collectionOwner, {Substrate: recepient.address});382      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);383      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);384    });385  386    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {387      const collectionOwner = accounts.pop()!;388      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});389      await collection.confirmSponsorship(collectionOwner);390        391      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;392        393      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});394    });395  396    itSub('should reject transaction if collection does not exist', async ({helper}) => {    397      const collectionOwner = accounts.pop()!;398      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});399        400      await collection.burn(collectionOwner);401      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');402      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');403    });404  });405  406  describe('contract sponsoring', () => {407    itEth('should set palletes address as a sponsor', async ({helper}) => {408      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();409      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);410      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);411  412      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);413      414      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  415      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  416      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({417        confirmed: {418          substrate: palletAddress,419        },420      });421    });422  423    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {424      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();425      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);426      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);427  428      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;429  430      // Contract is self sponsored431      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({432        confirmed: {433          ethereum: flipper.options.address.toLowerCase(),434        },435      });436  437      // set promotion sponsoring438      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);439  440      // new sponsor is pallet address441      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  442      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  443      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({444        confirmed: {445          substrate: palletAddress,446        },447      });448    });449  450    itEth('can be overwritten by contract owner', async ({helper}) => {451      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();452      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);453      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);454  455      // contract sponsored by pallet456      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);457  458      // owner sets self sponsoring459      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;460  461      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  462      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  463      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({464        confirmed: {465          ethereum: flipper.options.address.toLowerCase(),466        },467      });468    });469  470    itEth('can not be set by non admin', async ({helper}) => {471      const nonAdmin = accounts.pop()!;472      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();473      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);474      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);475  476      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;477  478      // nonAdmin calls sponsorContract479      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');480  481      // contract still self-sponsored 482      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({483        confirmed: {484          ethereum: flipper.options.address.toLowerCase(),485        },486      });487    });488  489    itEth('should actually sponsor transactions', async ({helper}) => {490      // Contract caller491      const caller = await helper.eth.createAccountWithBalance(alice, 1000n);492      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);493          494      // Deploy flipper495      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();496      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);497      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);498      499      // Owner sets to sponsor every tx500      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});501      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});502      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);503  504      // Set promotion to the Flipper505      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorContract(flipper.options.address));506  507      // Caller calls Flipper508      await flipper.methods.flip().send({from: caller});509      expect(await flipper.methods.getValue().call()).to.be.true;510  511      // The contracts and caller balances have not changed512      const callerBalance = await helper.balance.getEthereum(caller);513      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);514      expect(callerBalance).to.be.equal(1000n * nominal);515      expect(1000n * nominal === contractBalanceAfter).to.be.true;516  517      // The pallet balance has decreased518      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);519      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;520    });521  });522  523  describe('stopSponsoringContract', () => {  524    itEth('should remove pallet address from contract sponsors', async ({helper}) => {525      const caller = await helper.eth.createAccountWithBalance(alice, 1000n);526      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();527      const flipper = await helper.eth.deployFlipper(contractOwner);528      await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address);529      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);530  531      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});532      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);533      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);534  535      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  536      expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  537      expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({538        disabled: null,539      });540  541      await flipper.methods.flip().send({from: caller});542      expect(await flipper.methods.getValue().call()).to.be.true;543  544      const callerBalance = await helper.balance.getEthereum(caller);545      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);546  547      // caller payed for call548      expect(1000n * nominal > callerBalance).to.be.true;549      expect(contractBalanceAfter).to.be.equal(1000n * nominal);550    });551  552    itEth('can not be called by non-admin', async ({helper}) => {553      const nonAdmin = accounts.pop()!;554      const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();555      const flipper = await helper.eth.deployFlipper(contractOwner);556  557      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);558      const stopSponsoringResult = await helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]);559      expect(stopSponsoringResult.status).to.equal('Fail');560      expect(stopSponsoringResult.moduleError).to.equal('appPromotion.NoPermission');561    });562  563    itEth('should not affect a contract which is not sponsored by pallete', 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      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);568      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;569  570      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');571    });572  });573  574  describe('rewards', () => {575    itSub('can not be called by non admin', async ({helper}) => {576      const nonAdmin = accounts.pop()!;577      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');578    });579  580    itSub('should increase total staked', async ({helper}) => {581      const staker = accounts.pop()!;582      const totalStakedBefore = await helper.staking.getTotalStaked();583      await helper.staking.stake(staker, 100n * nominal);584  585      // Wait for rewards and pay586      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});587      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));588      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);589  590      const totalStakedAfter = await helper.staking.getTotalStaked();591      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);592      // staker can unstake593      await helper.staking.unstake(staker);594      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));595    });596  597    itSub('should credit 0.05% for staking period', async ({helper}) => {    598      const staker = accounts.pop()!;599  600      await waitPromotionPeriodDoesntEnd(helper);601        602      await helper.staking.stake(staker, 100n * nominal);603      await helper.staking.stake(staker, 200n * nominal);604  605      // wait rewards are available:606      const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});607      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));608  609      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;610      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));611  612      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});613      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));614      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));615    });616  617    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {618      const staker = accounts.pop()!;619  620      await helper.staking.stake(staker, 100n * nominal);621      // wait for two rewards are available:622      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});623      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);624  625      await helper.admin.payoutStakers(palletAdmin, 100);626      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});627      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);628      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);629  630      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);631  632      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});633    });634    635    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {636      // staker unstakes before rewards has been payed637      const staker = accounts.pop()!;638      await helper.staking.stake(staker, 100n * nominal);639      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});640      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);641      await helper.staking.unstake(staker);642        643      // so he did not receive any rewards644      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);645      await helper.admin.payoutStakers(palletAdmin, 100);646      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);647  648      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);649    });650    651    itSub('should bring compound interest', async ({helper}) => {652      const staker = accounts.pop()!;653              654      await helper.staking.stake(staker, 100n * nominal);655  656      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});657      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));658        659      await helper.admin.payoutStakers(palletAdmin, 100);660      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});661      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));662        663      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);664      await helper.admin.payoutStakers(palletAdmin, 100);665      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});666      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));667    });668  669    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {670      // all other stakes should be unstaked671      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);672  673      // stakers stakes 10 times each674      for (let i = 0; i < 10; i++) {675        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));676      }677      await helper.wait.newBlocks(40);678      await helper.admin.payoutStakers(palletAdmin, 100);679    });680  681    itSub.skip('can handle 40.000 rewards', async ({helper}) => {682      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);683      const crowdStakes = async () => {684        // each account in the crowd stakes 2 times685        const crowd = await helper.arrange.createCrowd(500, 300n, donor);686        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));687        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));688        // 689      };690  691      for (let i = 0; i < 40; i++) {692        await crowdStakes();693      }694  695      // TODO pay rewards for some period696    });697  });698});699700function calculatePalleteAddress(palletId: any) {701  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));702  return encodeAddress(address);703}704705function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {706  const DAY = 7200n;707  const ACCURACY = 1_000_000_000n;708  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;709  710  if (iter > 1) {711    return calculateIncome(income, calcPeriod, iter - 1);712  } else return income;713}714715// Wait while promotion period less than specified block, to avoid boundary cases716// 0 if this should be the beginning of the period.717async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {718  const relayBlockNumber = (await helper.api!.query.parachainSystem.validationData()).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();719  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;720721  if (currentPeriodBlock > waitBlockLessThan) {722    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);723  }724}