git.delta.rocks / unique-network / refs/commits / 123bef5c2f2c

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 bob: IKeyringPair;37let palletAdmin: IKeyringPair;38let nominal: bigint;39let promotionStartBlock: number | null = null;40const palletAddress = calculatePalleteAddress('appstake');4142before(async function () {43  await usingPlaygrounds(async (helper, privateKeyWrapper) => {44    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();45    alice = privateKeyWrapper('//Alice');46    bob = privateKeyWrapper('//Bob');47    palletAdmin = privateKeyWrapper('//Charlie'); // TODO use custom address48    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})));49    nominal = helper.balance.getOneTokenNominal();50    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);51    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);52    if (!promotionStartBlock) {53      promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();54    }55    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!)));56  });57});5859after(async function () {60  await usingPlaygrounds(async (helper) => {61    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.stopAppPromotion()));62  });63});6465describe('app-promotions.stake extrinsic', () => {66  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {67    await usingPlaygrounds(async (helper) => {68      const totalStakedBefore = await helper.staking.getTotalStaked();69      const [staker, recepient] = await helper.arrange.createAccounts([400n, 0n], alice);7071      // Minimum stake amount is 100:72      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;73      await helper.staking.stake(staker, 100n * nominal);7475      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...76      // ...so he can not transfer 30077      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});78      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 300n * nominal)).to.be.rejected;79      80      // 100 -> 24 locked 100; staked 0; 24 => locked 100 staked 10081      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);82      // TODO should be 083      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);84      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(399n);85      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 86      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 8788      await helper.staking.stake(staker, 200n * nominal);89      90      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(300n * nominal);91      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);92      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);93    });94  });95  96  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {97    await usingPlaygrounds(async helper => { 98      const [staker] = await helper.arrange.createAccounts([300n], alice);99100      // Can't stake full balance because Alice needs to pay some fee101      await expect(helper.staking.stake(staker, 300n * nominal)).to.be.eventually.rejected;102      await helper.staking.stake(staker, 150n * nominal);103104      // Can't stake 150 tkn because Alice has Less than 150 free - frozen tokens;105      await expect(helper.staking.stake(staker, 150n * nominal)).to.be.eventually.rejected; 106      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(150n * nominal);107    });108  });109  110  it('for different accounts in one block is possible', async () => {111    await usingPlaygrounds(async helper => {112      const crowd = await helper.arrange.createAccounts([1000n, 1000n, 1000n, 1000n], alice);113      114      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));115      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;116117      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));118      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);119    });120  });121});122123describe('unstake balance extrinsic', () => {  124  it('should change balance state to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {125    await usingPlaygrounds(async helper => {126      const totalStakedBefore = await helper.staking.getTotalStaked();127      const [staker, recepient] = await helper.arrange.createAccounts([600n, 0n], alice);128      await helper.staking.stake(staker, 500n * nominal);129      await helper.staking.unstake(staker);130131      // balance state still132133      // Stakers balance now: {free: <100n, reserved: 500n, miscFrozen: 0, feeFrozen: 0};134      // Staker can not transfer 135      // TODO expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 500n * nominal, miscFrozen: 0n, feeFrozen: 0n});136      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;137138      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(500n * nominal);139      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);140      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);141    });142  });143144  it('should unlock balance after unlocking period ends and subtract it from "pendingUnstake"', async () => {145    await usingPlaygrounds(async (helper) => {146      const [staker] = await helper.arrange.createAccounts([1000n], alice);147      await helper.staking.stake(staker, 100n * nominal);148      await helper.staking.unstake(staker);149      await waitForRelayBlock(helper.api!, 20);150151      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n152      await waitForRelayBlock(helper.api!, 20);153      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n * nominal, miscFrozen: 0n, feeFrozen: 0n});154      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);155    });156  });157158  it('should successfully unstake multiple stakes', async () => {159    await usingPlaygrounds(async helper => {160      const [staker] = await helper.arrange.createAccounts([1000n], alice);161      await helper.staking.stake(staker, 100n * nominal);162      await helper.staking.stake(staker, 200n * nominal);163      await helper.staking.stake(staker, 300n * nominal);164165      // staked: [100, 200, 300]; unstaked: 0166      let pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});167      let unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);168      let stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);169      expect(pendingUnstake).to.be.deep.equal(0n);170      expect(unstakedPerBlock).to.be.deep.equal([]);171      expect(stakedPerBlock).to.be.deep.equal([100n * nominal, 200n * nominal, 300n * nominal]);172     173      // Can unstake multiple stakes174      await helper.staking.unstake(staker);175      pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});176      unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);177      stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);178      expect(pendingUnstake).to.be.equal(600n * nominal);179      expect(stakedPerBlock).to.be.deep.equal([]);180      expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]);181182      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 600n * nominal, miscFrozen: 600n * nominal});183      await waitForRelayBlock(helper.api!, 20);184      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});185      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);186    });187  });188189  it('should not have any effects if no active stakes', async () => {190    await usingPlaygrounds(async (helper) => {191      const [staker] = await helper.arrange.createAccounts([1000n], alice);192      193      // unstake has no effect if no stakes at all194      await helper.staking.unstake(staker);195      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);196      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(0n);197      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper198199      // TODO stake() unstake() waitUnstaked() unstake();200201      // can't unstake if there are only pendingUnstakes202      await helper.staking.stake(staker, 100n * nominal);203      await helper.staking.unstake(staker);204      await helper.staking.unstake(staker);205206      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);207      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);208      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);209    });210  });211212  it('should keep different unlocking block for each unlocking stake', async () => {213    await usingPlaygrounds(async (helper) => {214      const [staker] = await helper.arrange.createAccounts([1000n], alice);215      await helper.staking.stake(staker, 100n * nominal);216      await helper.staking.unstake(staker);217      await helper.staking.stake(staker, 120n * nominal);218      await helper.staking.unstake(staker);219220      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});221      expect(unstakingPerBlock).has.length(2);222      expect(unstakingPerBlock[0][1]).to.equal(100n * nominal);223      expect(unstakingPerBlock[1][1]).to.equal(120n * nominal);224    });225  });226227  it('should be possible for different accounts in one block', async () => {228    await usingPlaygrounds(async (helper) => {229      const stakers = await helper.arrange.createAccounts([200n, 200n, 200n, 200n, 200n], alice);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  });240241  // TODO for different accounts in one block is possible242});243244describe('Admin adress', () => {245  it('can be set by sudo only', async () => {246    await usingPlaygrounds(async (helper) => {247      // Bob can not set admin not from himself nor as a sudo248      await expect(helper.signTransaction(bob, helper.api!.tx.promotion.setAdminAddress({Substrate: bob.address}))).to.be.eventually.rejected;249      await expect(helper.signTransaction(bob, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: bob.address})))).to.be.eventually.rejected;250251      // Alice can252      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;253    });254  });255  256  it('can be any valid CrossAccountId', async () => {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    await usingPlaygrounds(async (helper) => {260      const [charlie] = await helper.arrange.createAccounts([10n], alice);261      const ethCharlie = helper.address.substrateToEth(charlie.address); 262      // Alice sets Ethereum address as a sudo. Then Substrate address back...263      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Ethereum: ethCharlie})))).to.be.eventually.fulfilled;264      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;265      266      // ...It doesn't break anything;267      const collection = await helper.nft.mintCollection(charlie, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});268      await expect(helper.signTransaction(charlie, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;269    });270  });271272  it('can be reassigned', async () => {273    await usingPlaygrounds(async (helper) => {274      const [oldAdmin, newAdmin, collectionOwner] = await helper.arrange.createAccounts([10n, 10n, 10n], alice);275      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});276      277      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;278      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;279      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;280      281      await expect(helper.signTransaction(newAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;282    });283  });284});285286describe('App-promotion collection sponsoring', () => {287  before(async function () {288    await usingPlaygrounds(async (helper) => {289      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress({Substrate: palletAdmin.address}));290      await helper.signTransaction(alice, tx);291    });292  });293294  it('should actually sponsor transactions', async () => {295    await usingPlaygrounds(async (helper) => {296      const [collectionOwner, tokenSender, receiver] = await helper.arrange.createAccounts([10n, 10n, 0n], alice);297      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});298      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});299      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));300      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);301302      await token.transfer(tokenSender, {Substrate: receiver.address});303      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});304      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);305306      // senders balance the same307      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(10n * nominal);308      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;309    });310  });311312  it('can not be set by non admin', async () => {313    await usingPlaygrounds(async (helper) => {314      const [collectionOwner, nonAdmin] = await helper.arrange.createAccounts([10n, 10n], alice);315316      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});317      318      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;319      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');320    });321  });322323  it('should set pallet address as confirmed admin', async () => {324    await usingPlaygrounds(async (helper) => {325      const [collectionOwner, oldSponsor] = await helper.arrange.createAccounts([20n, 20n], alice);326      327      // Can set sponsoring for collection without sponsor328      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});329      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;330      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});331332      // Can set sponsoring for collection with unconfirmed sponsor333      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});334      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});335      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;336      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});337338      // Can set sponsoring for collection with confirmed sponsor339      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});340      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);341      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;342      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});343    });344  });345346  it('can be overwritten by collection owner', async () => {    347    await usingPlaygrounds(async (helper) => {348      const [collectionOwner, newSponsor] = await helper.arrange.createAccounts([20n, 0n], alice);349      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});350      const collectionId = collection.collectionId;351      352      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;353      354      // Collection limits still can be changed by the owner355      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;356      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);357      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});358359      // Collection sponsor can be changed too360      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;361      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});362    });363  });364  365  it('should not overwrite collection limits set by the owner earlier', async () => {366    await usingPlaygrounds(async (helper) => {367      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};368      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});369370      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;371      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);372    });373  });374  375  it('should reject transaction if collection doesn\'t exist', async () => {376    await usingPlaygrounds(async (helper) => {377      const [collectionOwner] = await helper.arrange.createAccounts([10n], alice);378      379      // collection has never existed380      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected;381      // collection has been burned382      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});383      await collection.burn(collectionOwner);384385      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;386    });387  });388});389390describe('app-promotion stopSponsoringCollection', () => {391  it('can not be called by non-admin', async () => {    392    await usingPlaygrounds(async (helper) => {393      const [collectionOwner, nonAdmin] = await helper.arrange.createAccounts([10n, 10n], alice);394      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});395      396      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;397      398      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;399      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});400    });401  });402403  it('should set sponsoring as disabled', async () => {404    await usingPlaygrounds(async (helper) => {405      const [collectionOwner, recepient] = await helper.arrange.createAccounts([10n, 0n], alice);406      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});407      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});408      409      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId));410      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId));411      412      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');413414      // Transactions are not sponsored anymore:415      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);416      await token.transfer(collectionOwner, {Substrate: recepient.address});417      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);418      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);419    });420  });421422  it('should not affect collection which is not sponsored by pallete', async () => {423    await usingPlaygrounds(async (helper) => {424      const [collectionOwner] = await helper.arrange.createAccounts([10n, 10n], alice);425      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});426      await collection.confirmSponsorship(collectionOwner);427      428      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;429      430      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});431    });432  });433434  it('should reject transaction if collection does not exist', async () => {    435    await usingPlaygrounds(async (helper) => {436      const [collectionOwner] = await helper.arrange.createAccounts([10n], alice);437      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});438      439      await collection.burn(collectionOwner);440      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;441      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;442    });443  });444});445446describe('app-promotion contract sponsoring', () => {447  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {448    await usingPlaygrounds(async (helper) => {449      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();450      const flipper = await deployFlipper(web3, contractOwner);451      const contractMethods = contractHelpers(web3, contractOwner);452453      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));454      455      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  456      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  457      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({458        confirmed: {459          substrate: palletAddress,460        },461      });462    });463  });464465  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {466    await usingPlaygrounds(async (helper) => {467      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();468      const flipper = await deployFlipper(web3, contractOwner);469      const contractMethods = contractHelpers(web3, contractOwner);470471      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;472473      // Contract is self sponsored474      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({475        confirmed: {476          ethereum: flipper.options.address.toLowerCase(),477        },478      });479480      // set promotion sponsoring481      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));482483      // new sponsor is pallet address484      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  485      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  486      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({487        confirmed: {488          substrate: palletAddress,489        },490      });491    });492  });493494  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {495    await usingPlaygrounds(async (helper) => {      496      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();497      const flipper = await deployFlipper(web3, contractOwner);498      const contractMethods = contractHelpers(web3, contractOwner);499500      // contract sponsored by pallet501      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));502503      // owner sets self sponsoring504      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;505506      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  507      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  508      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({509        confirmed: {510          ethereum: flipper.options.address.toLowerCase(),511        },512      });513    });514  });515516  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {517    await usingPlaygrounds(async (helper) => {      518      const [nonAdmin] = await helper.arrange.createAccounts([50n], alice);519      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();520      const flipper = await deployFlipper(web3, contractOwner);521      const contractMethods = contractHelpers(web3, contractOwner);522523      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;524525      // nonAdmin calls sponsorConract526      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.sponsorConract(flipper.options.address))).to.be.rejected;527528      // contract still self-sponsored 529      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({530        confirmed: {531          ethereum: flipper.options.address.toLowerCase(),532        },533      });534    });535536    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {537      await usingPlaygrounds(async (helper) => {538539      });540    });541  });542543  itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => {544    await usingPlaygrounds(async (helper) => {      545      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);546      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();547      const flipper = await deployFlipper(web3, contractOwner);548      const contractHelper = contractHelpers(web3, contractOwner);549      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});550      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});551      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);552553      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));554      await flipper.methods.flip().send({from: caller});555      expect(await flipper.methods.getValue().call()).to.be.true;556557      const callerBalance = await helper.balance.getEthereum(caller);558      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);559560      expect(callerBalance).to.be.equal(1000n * nominal);561      expect(1000n * nominal > contractBalanceAfter).to.be.true;562    });563  });564});565566describe('app-promotion stopSponsoringContract', () => {  567  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {568    await usingPlaygrounds(async (helper) => {      569      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);570      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();571      const flipper = await deployFlipper(web3, contractOwner);572      await transferBalanceToEth(api, alice, flipper.options.address);573      const contractHelper = contractHelpers(web3, contractOwner);574      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});575      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));576      await helper.signTransaction(palletAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address));577578      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  579      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  580      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({581        disabled: null,582      });583584      await flipper.methods.flip().send({from: caller});585      expect(await flipper.methods.getValue().call()).to.be.true;586587      const callerBalance = await helper.balance.getEthereum(caller);588      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);589590      // caller payed for call591      expect(1000n * nominal > callerBalance).to.be.true;592      expect(contractBalanceAfter).to.be.equal(1000n * nominal);593    });594  });595596  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {597    await usingPlaygrounds(async (helper) => {      598      const [nonAdmin] = await helper.arrange.createAccounts([10n], alice);599      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();600      const flipper = await deployFlipper(web3, contractOwner);601602      await helper.signTransaction(palletAdmin, api.tx.promotion.sponsorConract(flipper.options.address));603      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;604    });605  });606607  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {608    await usingPlaygrounds(async (helper) => {      609      const [nonAdmin] = await helper.arrange.createAccounts([10n], alice);610      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();611      const flipper = await deployFlipper(web3, contractOwner);612      const contractHelper = contractHelpers(web3, contractOwner);613      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;614615      await expect(helper.signTransaction(nonAdmin, api.tx.promotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;616    });617  });618});619620describe('app-promotion rewards', () => {621  it('can not be called by non admin', async () => {622    await usingPlaygrounds(async (helper) => {623      const [nonAdmin] = await helper.arrange.createAccounts([10n], alice);624      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.promotion.payoutStakers(50))).to.be.rejected;625    });626  });627628  it('should credit 0.05% for staking period', async () => {    629    // TODO flaky test630    await usingPlaygrounds(async helper => {631      const [staker] = await helper.arrange.createAccounts([5000n], alice);632      633      await helper.staking.stake(staker, 100n * nominal);634      await helper.staking.stake(staker, 200n * nominal);635      await waitForRelayBlock(helper.api!, 30);636      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(50));637638      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);639      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);640    });641  });642643  it('shoud be paid for more than one period if payments was missed', async () => {644    await usingPlaygrounds(async (helper) => {645      const [staker] = await helper.arrange.createAccounts([400n], alice);646647      await helper.staking.stake(staker, 100n * nominal);648      await helper.staking.stake(staker, 200n * nominal);649650      await waitForRelayBlock(helper.api!, 55);651      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(50));652      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});653      expect(stakedPerBlock[0][1]).to.be.equal(calculateIncome(100n * nominal, 10n, 2));654      expect(stakedPerBlock[1][1]).to.be.equal(calculateIncome(200n * nominal, 10n, 2));655656      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);657      const frozenBalanceShouldBe = calculateIncome(300n * nominal, 10n, 2);658659      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});660    });661  });662  663  it('should not be credited for unstaked (reserved) balance', async () => {664    expect.fail('Test not implemented');665    await usingPlaygrounds(async helper => {666      const staker = await helper.arrange.createAccounts([1000n], alice);667    });668  });669  670  it('should bring compound interest', async () => {671    // TODO flaky test672    await usingPlaygrounds(async helper => {673      const [staker] = await helper.arrange.createAccounts([800n], alice);674            675      await helper.staking.stake(staker, 100n * nominal);676      await helper.staking.stake(staker, 200n * nominal);677      await helper.staking.stake(staker, 300n * nominal);678      679      await waitForRelayBlock(helper.api!, 34);680      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(50));681      let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);682      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n), calculateIncome(300n * nominal, 10n)]);683      684      await waitForRelayBlock(helper.api!, 20);685      await helper.signTransaction(palletAdmin, helper.api!.tx.promotion.payoutStakers(50));686      totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);687      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2), calculateIncome(200n * nominal, 10n, 2), calculateIncome(300n * nominal, 10n, 2)]);      688    });689  });690691  it.skip('can handle 40.000 rewards', async () => {692    await usingPlaygrounds(async (helper) => {693      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);694      const crowdStakes = async () => {695        // each account in the crowd stakes 2 times696        const crowd = await helper.arrange.createCrowd(500, 300n, donor);697        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));698        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));699        // 700      };701702      for (let i = 0; i < 40; i++) {703        await crowdStakes();704      }705706      // TODO pay rewards for some period707    });708  });709});710711async function waitForRelayBlock(api: ApiPromise, blocks = 1): Promise<void> {712  const current_block = (await api.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();713  return new Promise<void>(async (resolve, reject) => {714    const unsubscribe = await api.query.parachainSystem.validationData(async (data) => {715      // console.log(`${current_block} || ${data.value.relayParentNumber.toNumber()}`);716      if (data.value.relayParentNumber.toNumber() - current_block >= blocks) {717        unsubscribe();718        resolve();719      }720    });721  });722}723724function calculatePalleteAddress(palletId: any) {725  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));726  return encodeAddress(address);727}728729function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {730  const DAY = 7200n;731  const ACCURACY = 1_000_000_000n;732  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;733  734  if (iter > 1) {735    return calculateIncome(income, calcPeriod, iter - 1);736  } else return income;737}