git.delta.rocks / unique-network / refs/commits / 7586abb798e7

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';2324import chai from 'chai';25import chaiAsPromised from 'chai-as-promised';26import {itSub, usingPlaygrounds} from './util/playgrounds';2728import {encodeAddress} from '@polkadot/util-crypto';29import {stringToU8a} from '@polkadot/util';30import {SponsoringMode, contractHelpers, createEthAccountWithBalance, deployFlipper, itWeb3, transferBalanceToEth} from './eth/util/helpers';31import {DevUniqueHelper} from './util/playgrounds/unique.dev';32chai.use(chaiAsPromised);33const expect = chai.expect;3435let alice: IKeyringPair;36let palletAdmin: IKeyringPair;37let nominal: bigint;38const palletAddress = calculatePalleteAddress('appstake');39let accounts: IKeyringPair[] = [];40const LOCKING_PERIOD = 20n; // 20 blocks of relay41const UNLOCKING_PERIOD = 10n; // 20 blocks of parachain42const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);4344const beforeEach = async (context: Mocha.Context) => {45  await usingPlaygrounds(async (helper, privateKey) => {46    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) context.skip();47    alice = privateKey('//Alice');48    palletAdmin = privateKey('//Charlie'); // TODO use custom address49    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));50    nominal = helper.balance.getOneTokenNominal();51    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);52    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);53    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests54  });55};5657describe('app-promotions.stake extrinsic', () => {58  before(async function () {59    await beforeEach(this);60  });6162  itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {63    const [staker, recepient] = [accounts.pop()!, accounts.pop()!];64    const totalStakedBefore = await helper.staking.getTotalStaked();6566    // Minimum stake amount is 100:67    await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;68    await helper.staking.stake(staker, 100n * nominal);6970    // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...71    // ...so he can not transfer 90072    expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});73    await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;74    75    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);76    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);77    // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 78    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 7980    81    await helper.staking.stake(staker, 200n * nominal);82    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);83    const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});84    expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);85    expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);86  });8788  itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {89    const [staker] = await helper.arrange.createAccounts([2000n], alice);90    for (let i = 0; i < 10; i++) {91      await helper.staking.stake(staker, 100n * nominal);92    }9394    // can have 10 stakes95    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);96    expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);9798    await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;99100    // After unstake can stake again101    await helper.staking.unstake(staker);102    await helper.staking.stake(staker, 100n * nominal);103    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);104  });105  106  itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {107    const staker = accounts.pop()!;108109    // Can't stake full balance because Alice needs to pay some fee110    await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;111    await helper.staking.stake(staker, 500n * nominal);112113    // Can't stake 500 tkn because Alice has Less than 500 transferable;114    await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 115    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);116  });117  118  itSub('for different accounts in one block is possible', async ({helper}) => {119    const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];120      121    const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));122    await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;123124    const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));125    expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);126  });127});128129describe('unstake balance extrinsic', () => {  130  before(async function () {131    await beforeEach(this);132  });133134  itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {135    const [staker, recepient] = [accounts.pop()!, accounts.pop()!];136    const totalStakedBefore = await helper.staking.getTotalStaked();137    await helper.staking.stake(staker, 900n * nominal);138    await helper.staking.unstake(staker);139140    // Right after unstake balance is reserved141    // Staker can not transfer 142    expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});143    await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;144    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);145    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);146    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);147  });148149  itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {150    const staker = accounts.pop()!;151    await helper.staking.stake(staker, 100n * nominal);152    await helper.staking.unstake(staker);153    const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});154155    // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n156    await helper.wait.forParachainBlockNumber(pendingUnstake.block);157    expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});158    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);159160    // staker can transfer:161    await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);162    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);163  });164165  itSub('should successfully unstake multiple stakes', async ({helper}) => {166    const staker = accounts.pop()!;167    await helper.staking.stake(staker, 100n * nominal);168    await helper.staking.stake(staker, 200n * nominal);169    await helper.staking.stake(staker, 300n * nominal);170171    // staked: [100, 200, 300]; unstaked: 0172    let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});173    let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});174    let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});175    expect(totalPendingUnstake).to.be.deep.equal(0n);176    expect(pendingUnstake).to.be.deep.equal([]);177    expect(stakes[0].amount).to.equal(100n * nominal);178    expect(stakes[1].amount).to.equal(200n * nominal);179    expect(stakes[2].amount).to.equal(300n * nominal);180     181    // Can unstake multiple stakes182    await helper.staking.unstake(staker);183    pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});184    totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});185    stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});186    expect(totalPendingUnstake).to.be.equal(600n * nominal);187    expect(stakes).to.be.deep.equal([]);188    expect(pendingUnstake[0].amount).to.equal(600n * nominal);189190    expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});191    await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);192    expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});193    expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);194  });195196  itSub('should not have any effects if no active stakes', async ({helper}) => {197    const staker = accounts.pop()!;198      199    // unstake has no effect if no stakes at all200    await helper.staking.unstake(staker);201    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);202    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper203204    // TODO stake() unstake() waitUnstaked() unstake();205206    // can't unstake if there are only pendingUnstakes207    await helper.staking.stake(staker, 100n * nominal);208    await helper.staking.unstake(staker);209    await helper.staking.unstake(staker);210211    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);212    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);213  });214215  itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {216    const staker = accounts.pop()!;217    await helper.staking.stake(staker, 100n * nominal);218    await helper.staking.unstake(staker);219    await helper.staking.stake(staker, 120n * nominal);220    await helper.staking.unstake(staker);221222    const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});223    expect(unstakingPerBlock).has.length(2);224    expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);225    expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);226  });227228  itSub('should be possible for different accounts in one block', async ({helper}) => {229    const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];230231    await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));232    await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));233234    await Promise.all(stakers.map(async (staker) => {235      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);236      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);237    }));238  });239});240241describe('Admin adress', () => {242  before(async function () {243    await beforeEach(this);244  });245246  itSub('can be set by sudo only', async ({helper}) => {247    const nonAdmin = accounts.pop()!;248    // nonAdmin can not set admin not from himself nor as a sudo249    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;250    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;251252    // Alice can253    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;254  });255  256  itSub('can be any valid CrossAccountId', async ({helper}) => {257    // We are not going to set an eth address as a sponsor,258    // but we do want to check, it doesn't break anything;259    const account = accounts.pop()!;260    const ethAccount = helper.address.substrateToEth(account.address); 261    // Alice sets Ethereum address as a sudo. Then Substrate address back...262    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;263    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;264      265    // ...It doesn't break anything;266    const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});267    await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;268  });269270  itSub('can be reassigned', async ({helper}) => {271    const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];272    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});273      274    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;275    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;276    await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;277      278    await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;279  });280});281282describe('App-promotion collection sponsoring', () => {283  before(async function () {284    await beforeEach(this);285    await usingPlaygrounds(async (helper) => {286      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));287      await helper.signTransaction(alice, tx);288    });289  });290291  itSub('should actually sponsor transactions', async ({helper}) => {292    const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];293    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});294    const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});295    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));296    const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);297298    await token.transfer(tokenSender, {Substrate: receiver.address});299    expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});300    const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);301302    // senders balance the same, transaction has sponsored303    expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);304    expect (palletBalanceBefore > palletBalanceAfter).to.be.true;305  });306307  itSub('can not be set by non admin', async ({helper}) => {308    const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];309310    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});311      312    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;313    expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');314  });315316  itSub('should set pallet address as confirmed admin', async ({helper}) => {317    const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];318      319    // Can set sponsoring for collection without sponsor320    const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});321    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;322    expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});323324    // Can set sponsoring for collection with unconfirmed sponsor325    const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});326    expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});327    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;328    expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});329330    // Can set sponsoring for collection with confirmed sponsor331    const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});332    await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);333    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;334    expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});335  });336337  itSub('can be overwritten by collection owner', async ({helper}) => {    338    const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];339    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});340    const collectionId = collection.collectionId;341      342    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;343      344    // Collection limits still can be changed by the owner345    expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;346    expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);347    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});348349    // Collection sponsor can be changed too350    expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;351    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});352  });353  354  itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {355    const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};356    const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});357358    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;359    expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);360  });361  362  itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {363    const collectionOwner = accounts.pop()!;364      365    // collection has never existed366    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;367    // collection has been burned368    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});369    await collection.burn(collectionOwner);370371    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;372  });373});374375describe('app-promotion stopSponsoringCollection', () => {376  before(async function () {377    await beforeEach(this);378  });379380  itSub('can not be called by non-admin', async ({helper}) => {    381    const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];382    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});383      384    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;385      386    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;387    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});388  });389390  itSub('should set sponsoring as disabled', async ({helper}) => {391    const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];392    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});393    const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});394      395    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));396    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));397      398    expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');399400    // Transactions are not sponsored anymore:401    const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);402    await token.transfer(collectionOwner, {Substrate: recepient.address});403    const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);404    expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);405  });406407  itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {408    const collectionOwner = accounts.pop()!;409    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});410    await collection.confirmSponsorship(collectionOwner);411      412    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;413      414    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});415  });416417  itSub('should reject transaction if collection does not exist', async ({helper}) => {    418    const collectionOwner = accounts.pop()!;419    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});420      421    await collection.burn(collectionOwner);422    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;423    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;424  });425});426427describe('app-promotion contract sponsoring', () => {428  before(async function () {429    await beforeEach(this);430  });431432  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {433    await usingPlaygrounds(async (helper) => {434      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();435      const flipper = await deployFlipper(web3, contractOwner);436      const contractMethods = contractHelpers(web3, contractOwner);437438      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));439      440      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  441      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  442      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({443        confirmed: {444          substrate: palletAddress,445        },446      });447    });448  });449450  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {451    await usingPlaygrounds(async (helper) => {452      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();453      const flipper = await deployFlipper(web3, contractOwner);454      const contractMethods = contractHelpers(web3, contractOwner);455456      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;457458      // Contract is self sponsored459      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({460        confirmed: {461          ethereum: flipper.options.address.toLowerCase(),462        },463      });464465      // set promotion sponsoring466      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));467468      // new sponsor is pallet address469      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  470      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  471      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({472        confirmed: {473          substrate: palletAddress,474        },475      });476    });477  });478479  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {480    await usingPlaygrounds(async (helper) => {      481      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();482      const flipper = await deployFlipper(web3, contractOwner);483      const contractMethods = contractHelpers(web3, contractOwner);484485      // contract sponsored by pallet486      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));487488      // owner sets self sponsoring489      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;490491      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  492      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  493      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({494        confirmed: {495          ethereum: flipper.options.address.toLowerCase(),496        },497      });498    });499  });500501  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {502    await usingPlaygrounds(async (helper) => {      503      const nonAdmin = accounts.pop()!;504      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();505      const flipper = await deployFlipper(web3, contractOwner);506      const contractMethods = contractHelpers(web3, contractOwner);507508      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;509510      // nonAdmin calls sponsorContract511      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address))).to.be.rejected;512513      // contract still self-sponsored 514      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({515        confirmed: {516          ethereum: flipper.options.address.toLowerCase(),517        },518      });519    });520521    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {522      await usingPlaygrounds(async (helper) => {523524      });525    });526  });527528  itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => {529    await usingPlaygrounds(async (helper) => {      530      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);531      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();532      const flipper = await deployFlipper(web3, contractOwner);533      const contractHelper = contractHelpers(web3, contractOwner);534      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});535      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});536      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);537538      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));539      await flipper.methods.flip().send({from: caller});540      expect(await flipper.methods.getValue().call()).to.be.true;541542      const callerBalance = await helper.balance.getEthereum(caller);543      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);544545      expect(callerBalance).to.be.equal(1000n * nominal);546      expect(1000n * nominal > contractBalanceAfter).to.be.true;547    });548  });549});550551describe('app-promotion stopSponsoringContract', () => {  552  before(async function () {553    await beforeEach(this);554  });555556  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {557    await usingPlaygrounds(async (helper) => {      558      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);559      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();560      const flipper = await deployFlipper(web3, contractOwner);561      await transferBalanceToEth(api, alice, flipper.options.address);562      const contractHelper = contractHelpers(web3, contractOwner);563      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});564      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));565      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));566567      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  568      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  569      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({570        disabled: null,571      });572573      await flipper.methods.flip().send({from: caller});574      expect(await flipper.methods.getValue().call()).to.be.true;575576      const callerBalance = await helper.balance.getEthereum(caller);577      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);578579      // caller payed for call580      expect(1000n * nominal > callerBalance).to.be.true;581      expect(contractBalanceAfter).to.be.equal(1000n * nominal);582    });583  });584585  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {586    await usingPlaygrounds(async (helper) => {      587      const nonAdmin = accounts.pop()!;588      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();589      const flipper = await deployFlipper(web3, contractOwner);590591      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));592      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;593    });594  });595596  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {597    await usingPlaygrounds(async (helper) => {      598      const nonAdmin = accounts.pop()!;599      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();600      const flipper = await deployFlipper(web3, contractOwner);601      const contractHelper = contractHelpers(web3, contractOwner);602      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;603604      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;605    });606  });607});608609describe('app-promotion rewards', () => {610  before(async function () {611    await beforeEach(this);612  });613614  itSub('can not be called by non admin', async ({helper}) => {615    const nonAdmin = accounts.pop()!;616    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;617  });618619  itSub('should increase total staked', async ({helper}) => {620    const staker = accounts.pop()!;621    const totalStakedBefore = await helper.staking.getTotalStaked();622    await helper.staking.stake(staker, 100n * nominal);623624    // Wait for rewards and pay625    const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});626    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));627    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));628629    const totalStakedAfter = await helper.staking.getTotalStaked();630    expect(totalStakedAfter >= totalStakedBefore + calculateIncome(100n * nominal, 10n)).to.be.true;631632    // staker can unstake633    await helper.staking.unstake(staker);634    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));635  });636637  itSub('should credit 0.05% for staking period', async ({helper}) => {    638    const staker = accounts.pop()!;639640    await waitPromotionPeriodDoesntEnd(helper);641      642    await helper.staking.stake(staker, 100n * nominal);643    await helper.staking.stake(staker, 200n * nominal);644645    // wait rewards are available:646    const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});647    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));648649    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));650651    const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});652    expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));653    expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));654  });655656  itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {657    const staker = accounts.pop()!;658659    await helper.staking.stake(staker, 100n * nominal);660    // wait for two rewards are available:661    let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});662    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);663664    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));665    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});666    const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);667    expect(stake.amount).to.be.equal(frozenBalanceShouldBe);668669    const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);670671    expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});672  });673  674  itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {675    // staker unstakes before rewards has been payed676    const staker = accounts.pop()!;677    await helper.staking.stake(staker, 100n * nominal);678    const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});679    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);680    await helper.staking.unstake(staker);681      682    // so he did not receive any rewards683    const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);684    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));685    const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);686687    expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);688  });689  690  itSub('should bring compound interest', async ({helper}) => {691    const staker = accounts.pop()!;692            693    await helper.staking.stake(staker, 100n * nominal);694695    let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});696    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));697      698    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));699    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});700    expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));701      702    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);703    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));704    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});705    expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));706  });707708  itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {709    // all other stakes should be unstaked710    const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);711712    // stakers stakes 10 times each713    for (let i = 0; i < 10; i++) {714      await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));715    }716    await helper.wait.newBlocks(40);717    const result = await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));718  });719720  itSub.skip('can handle 40.000 rewards', async ({helper}) => {721    const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);722    const crowdStakes = async () => {723      // each account in the crowd stakes 2 times724      const crowd = await helper.arrange.createCrowd(500, 300n, donor);725      await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));726      await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));727      // 728    };729730    for (let i = 0; i < 40; i++) {731      await crowdStakes();732    }733734    // TODO pay rewards for some period735  });736});737738function calculatePalleteAddress(palletId: any) {739  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));740  return encodeAddress(address);741}742743function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {744  const DAY = 7200n;745  const ACCURACY = 1_000_000_000n;746  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;747  748  if (iter > 1) {749    return calculateIncome(income, calcPeriod, iter - 1);750  } else return income;751}752753// Wait while promotion period less than specified block, to avoid boundary cases754// 0 if this should be the beginning of the period.755async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {756  const relayBlockNumber = (await helper.api!.query.parachainSystem.validationData()).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();757  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;758759  if (currentPeriodBlock > waitBlockLessThan) {760    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);761  }762}