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

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[] = [];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);4344before(async function () {45  await usingPlaygrounds(async (helper, privateKeyWrapper) => {46    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();47    alice = privateKeyWrapper('//Alice');48    palletAdmin = privateKeyWrapper('//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  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {59    await usingPlaygrounds(async (helper) => {60      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];61      const totalStakedBefore = await helper.staking.getTotalStaked();6263      // Minimum stake amount is 100:64      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;65      await helper.staking.stake(staker, 100n * nominal);6667      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...68      // ...so he can not transfer 90069      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});70      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;71      72      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);73      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);74      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 75      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 7677      78      await helper.staking.stake(staker, 200n * nominal);79      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);80      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);81    });82  });8384  it('should allow to create maximum 10 stakes for account', async () => {85    await usingPlaygrounds(async (helper) => {86      const [staker] = await helper.arrange.createAccounts([2000n], alice);87      for (let i = 0; i < 10; i++) {88        await helper.staking.stake(staker, 100n * nominal);89      }9091      // can have 10 stakes92      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);93      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);9495      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;9697      // After unstake can stake again98      await helper.staking.unstake(staker);99      await helper.staking.stake(staker, 100n * nominal);100      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);101    });102  });103  104  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {105    await usingPlaygrounds(async helper => { 106      const staker = accounts.pop()!;107108      // Can't stake full balance because Alice needs to pay some fee109      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;110      await helper.staking.stake(staker, 500n * nominal);111112      // Can't stake 500 tkn because Alice has Less than 500 transferable;113      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 114      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);115    });116  });117  118  it('for different accounts in one block is possible', async () => {119    await usingPlaygrounds(async helper => {120      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];121      122      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));123      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;124125      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));126      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);127    });128  });129});130131describe('unstake balance extrinsic', () => {  132  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {133    await usingPlaygrounds(async helper => {134      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];135      const totalStakedBefore = await helper.staking.getTotalStaked();136      await helper.staking.stake(staker, 900n * nominal);137      await helper.staking.unstake(staker);138139      // Right after unstake balance is reserved140      // Staker can not transfer 141      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});142      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;143      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);144      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);145      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);146    });147  });148149  it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => {150    await usingPlaygrounds(async (helper) => {151      const staker = accounts.pop()!;152      await helper.staking.stake(staker, 100n * nominal);153      await helper.staking.unstake(staker);154      const unstakedInBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];155156      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n157      await helper.wait.forParachainBlockNumber(unstakedInBlock);158      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});159      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);160161      // staker can transfer:162      await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);163      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);164    });165  });166167  it('should successfully unstake multiple stakes', async () => {168    await usingPlaygrounds(async helper => {169      const staker = accounts.pop()!;170      await helper.staking.stake(staker, 100n * nominal);171      await helper.staking.stake(staker, 200n * nominal);172      await helper.staking.stake(staker, 300n * nominal);173174      // staked: [100, 200, 300]; unstaked: 0175      let pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});176      let unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);177      let stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);178      expect(pendingUnstake).to.be.deep.equal(0n);179      expect(unstakedPerBlock).to.be.deep.equal([]);180      expect(stakedPerBlock).to.be.deep.equal([100n * nominal, 200n * nominal, 300n * nominal]);181     182      // Can unstake multiple stakes183      await helper.staking.unstake(staker);184      const unstakingBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];185      pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});186      unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);187      stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);188      expect(pendingUnstake).to.be.equal(600n * nominal);189      expect(stakedPerBlock).to.be.deep.equal([]);190      expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]);191192      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});193      await helper.wait.forParachainBlockNumber(unstakingBlock);194      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});195      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);196    });197  });198199  it('should not have any effects if no active stakes', async () => {200    await usingPlaygrounds(async (helper) => {201      const staker = accounts.pop()!;202      203      // unstake has no effect if no stakes at all204      await helper.staking.unstake(staker);205      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);206      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper207208      // TODO stake() unstake() waitUnstaked() unstake();209210      // can't unstake if there are only pendingUnstakes211      await helper.staking.stake(staker, 100n * nominal);212      await helper.staking.unstake(staker);213      await helper.staking.unstake(staker);214215      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);216      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);217    });218  });219220  it('should keep different unlocking block for each unlocking stake', async () => {221    await usingPlaygrounds(async (helper) => {222      const staker = accounts.pop()!;223      await helper.staking.stake(staker, 100n * nominal);224      await helper.staking.unstake(staker);225      await helper.staking.stake(staker, 120n * nominal);226      await helper.staking.unstake(staker);227228      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});229      expect(unstakingPerBlock).has.length(2);230      expect(unstakingPerBlock[0][1]).to.equal(100n * nominal);231      expect(unstakingPerBlock[1][1]).to.equal(120n * nominal);232    });233  });234235  it('should be possible for different accounts in one block', async () => {236    await usingPlaygrounds(async (helper) => {237      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];238239      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));240      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));241242      await Promise.all(stakers.map(async (staker) => {243        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);244        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);245      }));246    });247  });248});249250describe('Admin adress', () => {251  it('can be set by sudo only', async () => {252    await usingPlaygrounds(async (helper) => {253      const nonAdmin = accounts.pop()!;254      // nonAdmin can not set admin not from himself nor as a sudo255      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;256      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;257258      // Alice can259      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;260    });261  });262  263  it('can be any valid CrossAccountId', async () => {264    // We are not going to set an eth address as a sponsor,265    // but we do want to check, it doesn't break anything;266    await usingPlaygrounds(async (helper) => {267      const account = accounts.pop()!;268      const ethAccount = helper.address.substrateToEth(account.address); 269      // Alice sets Ethereum address as a sudo. Then Substrate address back...270      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;271      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;272      273      // ...It doesn't break anything;274      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});275      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;276    });277  });278279  it('can be reassigned', async () => {280    await usingPlaygrounds(async (helper) => {281      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];282      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});283      284      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;285      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;286      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;287      288      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;289    });290  });291});292293describe('App-promotion collection sponsoring', () => {294  before(async function () {295    await usingPlaygrounds(async (helper) => {296      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));297      await helper.signTransaction(alice, tx);298    });299  });300301  it('should actually sponsor transactions', async () => {302    await usingPlaygrounds(async (helper) => {303      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];304      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});305      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});306      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));307      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);308309      await token.transfer(tokenSender, {Substrate: receiver.address});310      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});311      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);312313      // senders balance the same, transaction has sponsored314      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);315      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;316    });317  });318319  it('can not be set by non admin', async () => {320    await usingPlaygrounds(async (helper) => {321      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];322323      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});324      325      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;326      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');327    });328  });329330  it('should set pallet address as confirmed admin', async () => {331    await usingPlaygrounds(async (helper) => {332      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];333      334      // Can set sponsoring for collection without sponsor335      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});336      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;337      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});338339      // Can set sponsoring for collection with unconfirmed sponsor340      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});341      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});342      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;343      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});344345      // Can set sponsoring for collection with confirmed sponsor346      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});347      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);348      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;349      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});350    });351  });352353  it('can be overwritten by collection owner', async () => {    354    await usingPlaygrounds(async (helper) => {355      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];356      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});357      const collectionId = collection.collectionId;358      359      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;360      361      // Collection limits still can be changed by the owner362      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;363      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);364      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});365366      // Collection sponsor can be changed too367      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;368      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});369    });370  });371  372  it('should not overwrite collection limits set by the owner earlier', async () => {373    await usingPlaygrounds(async (helper) => {374      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};375      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});376377      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;378      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);379    });380  });381  382  it('should reject transaction if collection doesn\'t exist', async () => {383    await usingPlaygrounds(async (helper) => {384      const collectionOwner = accounts.pop()!;385      386      // collection has never existed387      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;388      // collection has been burned389      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});390      await collection.burn(collectionOwner);391392      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;393    });394  });395});396397describe('app-promotion stopSponsoringCollection', () => {398  it('can not be called by non-admin', async () => {    399    await usingPlaygrounds(async (helper) => {400      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];401      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});402      403      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;404      405      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;406      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});407    });408  });409410  it('should set sponsoring as disabled', async () => {411    await usingPlaygrounds(async (helper) => {412      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];413      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});414      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});415      416      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));417      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));418      419      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');420421      // Transactions are not sponsored anymore:422      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);423      await token.transfer(collectionOwner, {Substrate: recepient.address});424      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);425      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);426    });427  });428429  it('should not affect collection which is not sponsored by pallete', async () => {430    await usingPlaygrounds(async (helper) => {431      const collectionOwner = accounts.pop()!;432      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});433      await collection.confirmSponsorship(collectionOwner);434      435      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;436      437      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});438    });439  });440441  it('should reject transaction if collection does not exist', 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'});445      446      await collection.burn(collectionOwner);447      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;448      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;449    });450  });451});452453describe('app-promotion contract sponsoring', () => {454  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {455    await usingPlaygrounds(async (helper) => {456      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();457      const flipper = await deployFlipper(web3, contractOwner);458      const contractMethods = contractHelpers(web3, contractOwner);459460      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));461      462      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  463      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  464      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({465        confirmed: {466          substrate: palletAddress,467        },468      });469    });470  });471472  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {473    await usingPlaygrounds(async (helper) => {474      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();475      const flipper = await deployFlipper(web3, contractOwner);476      const contractMethods = contractHelpers(web3, contractOwner);477478      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;479480      // Contract is self sponsored481      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({482        confirmed: {483          ethereum: flipper.options.address.toLowerCase(),484        },485      });486487      // set promotion sponsoring488      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));489490      // new sponsor is pallet address491      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          substrate: palletAddress,496        },497      });498    });499  });500501  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {502    await usingPlaygrounds(async (helper) => {      503      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();504      const flipper = await deployFlipper(web3, contractOwner);505      const contractMethods = contractHelpers(web3, contractOwner);506507      // contract sponsored by pallet508      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));509510      // owner sets self sponsoring511      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;512513      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  514      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  515      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({516        confirmed: {517          ethereum: flipper.options.address.toLowerCase(),518        },519      });520    });521  });522523  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {524    await usingPlaygrounds(async (helper) => {      525      const nonAdmin = accounts.pop()!;526      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();527      const flipper = await deployFlipper(web3, contractOwner);528      const contractMethods = contractHelpers(web3, contractOwner);529530      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;531532      // nonAdmin calls sponsorContract533      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address))).to.be.rejected;534535      // contract still self-sponsored 536      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({537        confirmed: {538          ethereum: flipper.options.address.toLowerCase(),539        },540      });541    });542543    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {544      await usingPlaygrounds(async (helper) => {545546      });547    });548  });549550  itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => {551    await usingPlaygrounds(async (helper) => {      552      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);553      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();554      const flipper = await deployFlipper(web3, contractOwner);555      const contractHelper = contractHelpers(web3, contractOwner);556      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});557      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});558      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);559560      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));561      await flipper.methods.flip().send({from: caller});562      expect(await flipper.methods.getValue().call()).to.be.true;563564      const callerBalance = await helper.balance.getEthereum(caller);565      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);566567      expect(callerBalance).to.be.equal(1000n * nominal);568      expect(1000n * nominal > contractBalanceAfter).to.be.true;569    });570  });571});572573describe('app-promotion stopSponsoringContract', () => {  574  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {575    await usingPlaygrounds(async (helper) => {      576      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);577      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();578      const flipper = await deployFlipper(web3, contractOwner);579      await transferBalanceToEth(api, alice, flipper.options.address);580      const contractHelper = contractHelpers(web3, contractOwner);581      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});582      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));583      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));584585      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  586      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  587      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({588        disabled: null,589      });590591      await flipper.methods.flip().send({from: caller});592      expect(await flipper.methods.getValue().call()).to.be.true;593594      const callerBalance = await helper.balance.getEthereum(caller);595      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);596597      // caller payed for call598      expect(1000n * nominal > callerBalance).to.be.true;599      expect(contractBalanceAfter).to.be.equal(1000n * nominal);600    });601  });602603  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {604    await usingPlaygrounds(async (helper) => {      605      const nonAdmin = accounts.pop()!;606      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();607      const flipper = await deployFlipper(web3, contractOwner);608609      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));610      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;611    });612  });613614  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {615    await usingPlaygrounds(async (helper) => {      616      const nonAdmin = accounts.pop()!;617      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();618      const flipper = await deployFlipper(web3, contractOwner);619      const contractHelper = contractHelpers(web3, contractOwner);620      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;621622      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;623    });624  });625});626627describe('app-promotion rewards', () => {628  it('can not be called by non admin', async () => {629    await usingPlaygrounds(async (helper) => {630      const nonAdmin = accounts.pop()!;631      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;632    });633  });634635  it('should credit 0.05% for staking period', async () => {    636    await usingPlaygrounds(async helper => {637      const staker = accounts.pop()!;638      639      await helper.staking.stake(staker, 100n * nominal);640      await helper.staking.stake(staker, 200n * nominal);641642      // wair rewards are available:643      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[1][0];644      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));645646      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));647648      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);649      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);650    });651  });652653  it('shoud be paid for more than one period if payments was missed', async () => {654    await usingPlaygrounds(async (helper) => {655      const staker = accounts.pop()!;656657      await helper.staking.stake(staker, 100n * nominal);658      // wait for two rewards are available:659      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];660      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);661662      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));663      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});664      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);665      expect(stakedPerBlock[0][1]).to.be.equal(frozenBalanceShouldBe);666667      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);668669      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});670    });671  });672  673  it('should not be credited for unstaked (reserved) balance', async () => {674    await usingPlaygrounds(async helper => {675      // staker unstakes before rewards has been payed676      const staker = accounts.pop()!;677      await helper.staking.stake(staker, 100n * nominal);678      await waitForRelayBlock(helper.api!, 40);679      await helper.staking.unstake(staker);680      681      // so he did not receive any rewards682      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);683      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));684      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);685686      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);687    });688  });689  690  it('should bring compound interest', async () => {691    // TODO flaky test692    await usingPlaygrounds(async helper => {693      const staker = accounts.pop()!;694            695      await helper.staking.stake(staker, 100n * nominal);696      await helper.staking.stake(staker, 200n * nominal);697      await helper.staking.stake(staker, 300n * nominal);698      699      await waitForRelayBlock(helper.api!, 34);700      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));701      let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);702      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n), calculateIncome(300n * nominal, 10n)]);703      704      await waitForRelayBlock(helper.api!, 20);705      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));706      totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);707      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2), calculateIncome(200n * nominal, 10n, 2), calculateIncome(300n * nominal, 10n, 2)]);      708    });709  });710711  it('can be paid 1000 rewards in a time', async () => {712    await usingPlaygrounds(async (helper) => {713      expect.fail('Test not implemented');714    });715  });716717  it.skip('can handle 40.000 rewards', async () => {718    await usingPlaygrounds(async (helper) => {719      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);720      const crowdStakes = async () => {721        // each account in the crowd stakes 2 times722        const crowd = await helper.arrange.createCrowd(500, 300n, donor);723        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));724        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));725        // 726      };727728      for (let i = 0; i < 40; i++) {729        await crowdStakes();730      }731732      // TODO pay rewards for some period733    });734  });735});736737async function waitForRelayBlock(api: ApiPromise, blocks = 1): Promise<void> {738  const current_block = (await api.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();739  return new Promise<void>(async (resolve, reject) => {740    const unsubscribe = await api.query.parachainSystem.validationData(async (data) => {741      // console.log(`${current_block} || ${data.value.relayParentNumber.toNumber()}`);742      if (data.value.relayParentNumber.toNumber() - current_block >= blocks) {743        unsubscribe();744        resolve();745      }746    });747  });748}749750function calculatePalleteAddress(palletId: any) {751  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));752  return encodeAddress(address);753}754755function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {756  const DAY = 7200n;757  const ACCURACY = 1_000_000_000n;758  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;759  760  if (iter > 1) {761    return calculateIncome(income, calcPeriod, iter - 1);762  } else return income;763}