git.delta.rocks / unique-network / refs/commits / 5b36ad8fb241

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 {usingPlaygrounds} from './util/playgrounds';2728import {encodeAddress} from '@polkadot/util-crypto';29import {stringToU8a} from '@polkadot/util';30import {ApiPromise} from '@polkadot/api';31import {SponsoringMode, contractHelpers, createEthAccountWithBalance, deployFlipper, itWeb3, transferBalanceToEth} from './eth/util/helpers';32chai.use(chaiAsPromised);33const expect = chai.expect;3435let alice: IKeyringPair;36let palletAdmin: IKeyringPair;37let nominal: bigint;38const palletAddress = calculatePalleteAddress('appstake');39let accounts: IKeyringPair[] = [];4041before(async function () {42  await usingPlaygrounds(async (helper, privateKeyWrapper) => {43    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();44    alice = privateKeyWrapper('//Alice');45    palletAdmin = privateKeyWrapper('//Charlie'); // TODO use custom address46    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})));47    nominal = helper.balance.getOneTokenNominal();48    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);49    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);50    if (!promotionStartBlock) {51      promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();52    }53    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!)));54    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests55  });56});5758after(async function () {59  await usingPlaygrounds(async (helper) => {60  });61});6263describe('app-promotions.stake extrinsic', () => {64  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {65    await usingPlaygrounds(async (helper) => {66      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];67      const totalStakedBefore = await helper.staking.getTotalStaked();6869      // Minimum stake amount is 100:70      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;71      await helper.staking.stake(staker, 100n * nominal);7273      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...74      // ...so he can not transfer 90075      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});76      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;77      78      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);79      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);80      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);81      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 82      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 8384      85      await helper.staking.stake(staker, 200n * nominal);86      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(300n * nominal);87      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);88      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);89    });90  });9192  it('should allow to create maximum 10 stakes for account', async () => {93    await usingPlaygrounds(async (helper) => {94      const [staker] = await helper.arrange.createAccounts([2000n], alice);95      console.log(staker.address);96      for (let i = 0; i < 10; i++) {97        await helper.staking.stake(staker, 100n * nominal);98      }99100      // can have 10 stakes101      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);102      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);103104      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;105106      // After unstake can stake again107      await helper.staking.unstake(staker);108      await helper.staking.stake(staker, 100n * nominal);109      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);110    });111  });112  113  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {114    await usingPlaygrounds(async helper => { 115      const staker = accounts.pop()!;116117      // Can't stake full balance because Alice needs to pay some fee118      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;119      await helper.staking.stake(staker, 500n * nominal);120121      // Can't stake 500 tkn because Alice has Less than 500 transferable;122      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 123      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);124    });125  });126  127  it('for different accounts in one block is possible', async () => {128    await usingPlaygrounds(async helper => {129      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];130      131      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));132      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;133134      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));135      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);136    });137  });138});139140describe('unstake balance extrinsic', () => {  141  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {142    await usingPlaygrounds(async helper => {143      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];144      const totalStakedBefore = await helper.staking.getTotalStaked();145      await helper.staking.stake(staker, 900n * nominal);146      await helper.staking.unstake(staker);147148      // Right after unstake balance is reserved149      // Staker can not transfer 150      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});151      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;152      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);153      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);154      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);155    });156  });157158  it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => {159    // TODO Flaky test160    await usingPlaygrounds(async (helper) => {161      const staker = accounts.pop()!;162      await helper.staking.stake(staker, 100n * nominal);163      await helper.staking.unstake(staker);164165      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n166      await waitForRelayBlock(helper.api!, 20);167      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});168      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);169170      // staker can transfer:171      await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);172      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);173    });174  });175176  it('should successfully unstake multiple stakes', async () => {177    await usingPlaygrounds(async helper => {178      const staker = accounts.pop()!;179      await helper.staking.stake(staker, 100n * nominal);180      await helper.staking.stake(staker, 200n * nominal);181      await helper.staking.stake(staker, 300n * nominal);182183      // staked: [100, 200, 300]; unstaked: 0184      let pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});185      let unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);186      let stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);187      expect(pendingUnstake).to.be.deep.equal(0n);188      expect(unstakedPerBlock).to.be.deep.equal([]);189      expect(stakedPerBlock).to.be.deep.equal([100n * nominal, 200n * nominal, 300n * nominal]);190     191      // Can unstake multiple stakes192      await helper.staking.unstake(staker);193      pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});194      unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);195      stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);196      expect(pendingUnstake).to.be.equal(600n * nominal);197      expect(stakedPerBlock).to.be.deep.equal([]);198      expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]);199200      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});201      await waitForRelayBlock(helper.api!, 20);202      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});203      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);204    });205  });206207  it('should not have any effects if no active stakes', async () => {208    await usingPlaygrounds(async (helper) => {209      const staker = accounts.pop()!;210      211      // unstake has no effect if no stakes at all212      await helper.staking.unstake(staker);213      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);214      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(0n);215      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper216217      // TODO stake() unstake() waitUnstaked() unstake();218219      // can't unstake if there are only pendingUnstakes220      await helper.staking.stake(staker, 100n * nominal);221      await helper.staking.unstake(staker);222      await helper.staking.unstake(staker);223224      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);225      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);226      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);227    });228  });229230  it('should keep different unlocking block for each unlocking stake', async () => {231    await usingPlaygrounds(async (helper) => {232      const staker = accounts.pop()!;233      await helper.staking.stake(staker, 100n * nominal);234      await helper.staking.unstake(staker);235      await helper.staking.stake(staker, 120n * nominal);236      await helper.staking.unstake(staker);237238      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});239      expect(unstakingPerBlock).has.length(2);240      expect(unstakingPerBlock[0][1]).to.equal(100n * nominal);241      expect(unstakingPerBlock[1][1]).to.equal(120n * nominal);242    });243  });244245  it('should be possible for different accounts in one block', async () => {246    await usingPlaygrounds(async (helper) => {247      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];248249      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));250      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));251252      await Promise.all(stakers.map(async (staker) => {253        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);254        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);255      }));256    });257  });258259  // TODO for different accounts in one block is possible260});261262describe('Admin adress', () => {263  it('can be set by sudo only', async () => {264    await usingPlaygrounds(async (helper) => {265      const nonAdmin = accounts.pop()!;266      // nonAdmin can not set admin not from himself nor as a sudo267      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;268      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;269270      // Alice can271      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;272    });273  });274  275  it('can be any valid CrossAccountId', async () => {276    // We are not going to set an eth address as a sponsor,277    // but we do want to check, it doesn't break anything;278    await usingPlaygrounds(async (helper) => {279      const account = accounts.pop()!;280      const ethAccount = helper.address.substrateToEth(account.address); 281      // Alice sets Ethereum address as a sudo. Then Substrate address back...282      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;283      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;284      285      // ...It doesn't break anything;286      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});287      await expect(helper.signTransaction(account, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;288    });289  });290291  it('can be reassigned', async () => {292    await usingPlaygrounds(async (helper) => {293      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];294      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});295      296      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;297      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;298      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;299      300      await expect(helper.signTransaction(newAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;301    });302  });303});304305describe('App-promotion collection sponsoring', () => {306  before(async function () {307    await usingPlaygrounds(async (helper) => {308      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address}));309      await helper.signTransaction(alice, tx);310    });311  });312313  it('should actually sponsor transactions', async () => {314    await usingPlaygrounds(async (helper) => {315      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];316      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});317      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});318      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));319      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);320321      await token.transfer(tokenSender, {Substrate: receiver.address});322      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});323      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);324325      // senders balance the same, transaction has sponsored326      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);327      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;328    });329  });330331  it('can not be set by non admin', async () => {332    await usingPlaygrounds(async (helper) => {333      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];334335      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});336      337      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;338      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');339    });340  });341342  it('should set pallet address as confirmed admin', async () => {343    await usingPlaygrounds(async (helper) => {344      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];345      346      // Can set sponsoring for collection without sponsor347      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});348      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;349      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});350351      // Can set sponsoring for collection with unconfirmed sponsor352      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});353      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});354      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;355      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});356357      // Can set sponsoring for collection with confirmed sponsor358      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});359      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);360      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;361      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});362    });363  });364365  it('can be overwritten by collection owner', async () => {    366    await usingPlaygrounds(async (helper) => {367      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];368      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});369      const collectionId = collection.collectionId;370      371      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;372      373      // Collection limits still can be changed by the owner374      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;375      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);376      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});377378      // Collection sponsor can be changed too379      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;380      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});381    });382  });383  384  it('should not overwrite collection limits set by the owner earlier', async () => {385    await usingPlaygrounds(async (helper) => {386      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};387      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});388389      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;390      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);391    });392  });393  394  it('should reject transaction if collection doesn\'t exist', async () => {395    await usingPlaygrounds(async (helper) => {396      const collectionOwner = accounts.pop()!;397      398      // collection has never existed399      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected;400      // collection has been burned401      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});402      await collection.burn(collectionOwner);403404      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;405    });406  });407});408409describe('app-promotion stopSponsoringCollection', () => {410  it('can not be called by non-admin', async () => {    411    await usingPlaygrounds(async (helper) => {412      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];413      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});414      415      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;416      417      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;418      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});419    });420  });421422  it('should set sponsoring as disabled', async () => {423    await usingPlaygrounds(async (helper) => {424      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];425      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});426      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});427      428      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));429      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId));430      431      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');432433      // Transactions are not sponsored anymore:434      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);435      await token.transfer(collectionOwner, {Substrate: recepient.address});436      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);437      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);438    });439  });440441  it('should not affect collection which is not sponsored by pallete', async () => {442    await usingPlaygrounds(async (helper) => {443      const collectionOwner = accounts.pop()!;444      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});445      await collection.confirmSponsorship(collectionOwner);446      447      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;448      449      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});450    });451  });452453  it('should reject transaction if collection does not exist', async () => {    454    await usingPlaygrounds(async (helper) => {455      const collectionOwner = accounts.pop()!;456      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});457      458      await collection.burn(collectionOwner);459      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;460      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;461    });462  });463});464465describe('app-promotion contract sponsoring', () => {466  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {467    await usingPlaygrounds(async (helper) => {468      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();469      const flipper = await deployFlipper(web3, contractOwner);470      const contractMethods = contractHelpers(web3, contractOwner);471472      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));473      474      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  475      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  476      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({477        confirmed: {478          substrate: palletAddress,479        },480      });481    });482  });483484  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {485    await usingPlaygrounds(async (helper) => {486      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();487      const flipper = await deployFlipper(web3, contractOwner);488      const contractMethods = contractHelpers(web3, contractOwner);489490      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;491492      // Contract is self sponsored493      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({494        confirmed: {495          ethereum: flipper.options.address.toLowerCase(),496        },497      });498499      // set promotion sponsoring500      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));501502      // new sponsor is pallet address503      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  504      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  505      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({506        confirmed: {507          substrate: palletAddress,508        },509      });510    });511  });512513  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {514    await usingPlaygrounds(async (helper) => {      515      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();516      const flipper = await deployFlipper(web3, contractOwner);517      const contractMethods = contractHelpers(web3, contractOwner);518519      // contract sponsored by pallet520      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));521522      // owner sets self sponsoring523      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;524525      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  526      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  527      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({528        confirmed: {529          ethereum: flipper.options.address.toLowerCase(),530        },531      });532    });533  });534535  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {536    await usingPlaygrounds(async (helper) => {      537      const nonAdmin = accounts.pop()!;538      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();539      const flipper = await deployFlipper(web3, contractOwner);540      const contractMethods = contractHelpers(web3, contractOwner);541542      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;543544      // nonAdmin calls sponsorConract545      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.sponsorConract(flipper.options.address))).to.be.rejected;546547      // contract still self-sponsored 548      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({549        confirmed: {550          ethereum: flipper.options.address.toLowerCase(),551        },552      });553    });554555    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {556      await usingPlaygrounds(async (helper) => {557558      });559    });560  });561562  itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => {563    await usingPlaygrounds(async (helper) => {      564      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);565      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();566      const flipper = await deployFlipper(web3, contractOwner);567      const contractHelper = contractHelpers(web3, contractOwner);568      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});569      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});570      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);571572      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));573      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      expect(callerBalance).to.be.equal(1000n * nominal);580      expect(1000n * nominal > contractBalanceAfter).to.be.true;581    });582  });583});584585describe('app-promotion stopSponsoringContract', () => {  586  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {587    await usingPlaygrounds(async (helper) => {      588      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);589      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();590      const flipper = await deployFlipper(web3, contractOwner);591      await transferBalanceToEth(api, alice, flipper.options.address);592      const contractHelper = contractHelpers(web3, contractOwner);593      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});594      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));595      await helper.signTransaction(palletAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address));596597      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  598      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  599      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({600        disabled: null,601      });602603      await flipper.methods.flip().send({from: caller});604      expect(await flipper.methods.getValue().call()).to.be.true;605606      const callerBalance = await helper.balance.getEthereum(caller);607      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);608609      // caller payed for call610      expect(1000n * nominal > callerBalance).to.be.true;611      expect(contractBalanceAfter).to.be.equal(1000n * nominal);612    });613  });614615  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {616    await usingPlaygrounds(async (helper) => {      617      const nonAdmin = accounts.pop()!;618      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();619      const flipper = await deployFlipper(web3, contractOwner);620621      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));622      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;623    });624  });625626  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {627    await usingPlaygrounds(async (helper) => {      628      const nonAdmin = accounts.pop()!;629      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();630      const flipper = await deployFlipper(web3, contractOwner);631      const contractHelper = contractHelpers(web3, contractOwner);632      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;633634      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;635    });636  });637});638639describe('app-promotion rewards', () => {640  it('can not be called by non admin', async () => {641    await usingPlaygrounds(async (helper) => {642      const nonAdmin = accounts.pop()!;643      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.payoutStakers(100))).to.be.rejected;644    });645  });646647  it('should credit 0.05% for staking period', async () => {    648    // TODO flaky test649    await usingPlaygrounds(async helper => {650      const staker = accounts.pop()!;651      652      await helper.staking.stake(staker, 100n * nominal);653      await helper.staking.stake(staker, 200n * nominal);654      await waitForRelayBlock(helper.api!, 30);655      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));656657      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);658      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);659    });660  });661662  it('shoud be paid for more than one period if payments was missed', async () => {663    // TODO flaky test664    await usingPlaygrounds(async (helper) => {665      const staker = accounts.pop()!;666667      await helper.staking.stake(staker, 100n * nominal);668      await helper.staking.stake(staker, 200n * nominal);669670      await waitForRelayBlock(helper.api!, 55);671      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));672      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});673      expect(stakedPerBlock[0][1]).to.be.equal(calculateIncome(100n * nominal, 10n, 2));674      expect(stakedPerBlock[1][1]).to.be.equal(calculateIncome(200n * nominal, 10n, 2));675676      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);677      const frozenBalanceShouldBe = calculateIncome(300n * nominal, 10n, 2);678679      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});680    });681  });682  683  it('should not be credited for unstaked (reserved) balance', async () => {684    await usingPlaygrounds(async helper => {685      // staker unstakes before rewards has been initialized686      const staker = accounts.pop()!;687      await helper.staking.stake(staker, 100n * nominal);688      await waitForRelayBlock(helper.api!, 40);689      await helper.staking.unstake(staker);690      691      // so he did not receive any rewards692      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);693      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));694      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);695696      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);697    });698  });699  700  it('should bring compound interest', async () => {701    // TODO flaky test702    await usingPlaygrounds(async helper => {703      const staker = accounts.pop()!;704            705      await helper.staking.stake(staker, 100n * nominal);706      await helper.staking.stake(staker, 200n * nominal);707      await helper.staking.stake(staker, 300n * nominal);708      709      await waitForRelayBlock(helper.api!, 34);710      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));711      let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);712      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n), calculateIncome(300n * nominal, 10n)]);713      714      await waitForRelayBlock(helper.api!, 20);715      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(100));716      totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);717      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2), calculateIncome(200n * nominal, 10n, 2), calculateIncome(300n * nominal, 10n, 2)]);      718    });719  });720721  it.skip('can handle 40.000 rewards', async () => {722    await usingPlaygrounds(async (helper) => {723      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);724      const crowdStakes = async () => {725        // each account in the crowd stakes 2 times726        const crowd = await helper.arrange.createCrowd(500, 300n, donor);727        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));728        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));729        // 730      };731732      for (let i = 0; i < 40; i++) {733        await crowdStakes();734      }735736      // TODO pay rewards for some period737    });738  });739});740741async function waitForRelayBlock(api: ApiPromise, blocks = 1): Promise<void> {742  const current_block = (await api.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();743  return new Promise<void>(async (resolve, reject) => {744    const unsubscribe = await api.query.parachainSystem.validationData(async (data) => {745      // console.log(`${current_block} || ${data.value.relayParentNumber.toNumber()}`);746      if (data.value.relayParentNumber.toNumber() - current_block >= blocks) {747        unsubscribe();748        resolve();749      }750    });751  });752}753754function calculatePalleteAddress(palletId: any) {755  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));756  return encodeAddress(address);757}758759function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {760  const DAY = 7200n;761  const ACCURACY = 1_000_000_000n;762  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;763  764  if (iter > 1) {765    return calculateIncome(income, calcPeriod, iter - 1);766  } else return income;767}