git.delta.rocks / unique-network / refs/commits / 1dbc03134213

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 {SponsoringMode, contractHelpers, createEthAccountWithBalance, deployFlipper, itWeb3, transferBalanceToEth} from './eth/util/helpers';31chai.use(chaiAsPromised);32const expect = chai.expect;3334let alice: IKeyringPair;35let palletAdmin: IKeyringPair;36let nominal: bigint;37const palletAddress = calculatePalleteAddress('appstake');38let accounts: IKeyringPair[] = [];39const LOCKING_PERIOD = 20n; // 20 blocks of relay40const UNLOCKING_PERIOD = 10n; // 20 blocks of parachain41const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);4243before(async function () {44  await usingPlaygrounds(async (helper, privateKey) => {45    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();46    alice = privateKey('//Alice');47    palletAdmin = privateKey('//Charlie'); // TODO use custom address48    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.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    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests53  });54});5556describe('app-promotions.stake extrinsic', () => {57  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {58    await usingPlaygrounds(async (helper) => {59      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];60      const totalStakedBefore = await helper.staking.getTotalStaked();6162      // Minimum stake amount is 100:63      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;64      await helper.staking.stake(staker, 100n * nominal);6566      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...67      // ...so he can not transfer 90068      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});69      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;70      71      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);72      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);73      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 74      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 7576      77      await helper.staking.stake(staker, 200n * nominal);78      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);79      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);80    });81  });8283  it('should allow to create maximum 10 stakes for account', async () => {84    await usingPlaygrounds(async (helper) => {85      const [staker] = await helper.arrange.createAccounts([2000n], alice);86      for (let i = 0; i < 10; i++) {87        await helper.staking.stake(staker, 100n * nominal);88      }8990      // can have 10 stakes91      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);92      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);9394      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;9596      // After unstake can stake again97      await helper.staking.unstake(staker);98      await helper.staking.stake(staker, 100n * nominal);99      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);100    });101  });102  103  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {104    await usingPlaygrounds(async helper => { 105      const staker = accounts.pop()!;106107      // Can't stake full balance because Alice needs to pay some fee108      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;109      await helper.staking.stake(staker, 500n * nominal);110111      // Can't stake 500 tkn because Alice has Less than 500 transferable;112      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 113      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);114    });115  });116  117  it('for different accounts in one block is possible', async () => {118    await usingPlaygrounds(async helper => {119      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];120      121      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));122      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;123124      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));125      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);126    });127  });128});129130describe('unstake balance extrinsic', () => {  131  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {132    await usingPlaygrounds(async helper => {133      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];134      const totalStakedBefore = await helper.staking.getTotalStaked();135      await helper.staking.stake(staker, 900n * nominal);136      await helper.staking.unstake(staker);137138      // Right after unstake balance is reserved139      // Staker can not transfer 140      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});141      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;142      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);143      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);144      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);145    });146  });147148  it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => {149    await usingPlaygrounds(async (helper) => {150      const staker = accounts.pop()!;151      await helper.staking.stake(staker, 100n * nominal);152      await helper.staking.unstake(staker);153      const unstakedInBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];154155      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n156      await helper.wait.forParachainBlockNumber(unstakedInBlock);157      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});158      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);159160      // staker can transfer:161      await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);162      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);163    });164  });165166  it('should successfully unstake multiple stakes', async () => {167    await usingPlaygrounds(async helper => {168      const staker = accounts.pop()!;169      await helper.staking.stake(staker, 100n * nominal);170      await helper.staking.stake(staker, 200n * nominal);171      await helper.staking.stake(staker, 300n * nominal);172173      // staked: [100, 200, 300]; unstaked: 0174      let pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});175      let unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);176      let stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);177      expect(pendingUnstake).to.be.deep.equal(0n);178      expect(unstakedPerBlock).to.be.deep.equal([]);179      expect(stakedPerBlock).to.be.deep.equal([100n * nominal, 200n * nominal, 300n * nominal]);180     181      // Can unstake multiple stakes182      await helper.staking.unstake(staker);183      const unstakingBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];184      pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});185      unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);186      stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);187      expect(pendingUnstake).to.be.equal(600n * nominal);188      expect(stakedPerBlock).to.be.deep.equal([]);189      expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]);190191      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});192      await helper.wait.forParachainBlockNumber(unstakingBlock);193      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});194      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);195    });196  });197198  it('should not have any effects if no active stakes', async () => {199    await usingPlaygrounds(async (helper) => {200      const staker = accounts.pop()!;201      202      // unstake has no effect if no stakes at all203      await helper.staking.unstake(staker);204      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);205      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper206207      // TODO stake() unstake() waitUnstaked() unstake();208209      // can't unstake if there are only pendingUnstakes210      await helper.staking.stake(staker, 100n * nominal);211      await helper.staking.unstake(staker);212      await helper.staking.unstake(staker);213214      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);215      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);216    });217  });218219  it('should keep different unlocking block for each unlocking stake', async () => {220    await usingPlaygrounds(async (helper) => {221      const staker = accounts.pop()!;222      await helper.staking.stake(staker, 100n * nominal);223      await helper.staking.unstake(staker);224      await helper.staking.stake(staker, 120n * nominal);225      await helper.staking.unstake(staker);226227      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});228      expect(unstakingPerBlock).has.length(2);229      expect(unstakingPerBlock[0][1]).to.equal(100n * nominal);230      expect(unstakingPerBlock[1][1]).to.equal(120n * nominal);231    });232  });233234  it('should be possible for different accounts in one block', async () => {235    await usingPlaygrounds(async (helper) => {236      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];237238      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));239      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));240241      await Promise.all(stakers.map(async (staker) => {242        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);243        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);244      }));245    });246  });247});248249describe('Admin adress', () => {250  it('can be set by sudo only', async () => {251    await usingPlaygrounds(async (helper) => {252      const nonAdmin = accounts.pop()!;253      // nonAdmin can not set admin not from himself nor as a sudo254      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;255      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;256257      // Alice can258      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;259    });260  });261  262  it('can be any valid CrossAccountId', async () => {263    // We are not going to set an eth address as a sponsor,264    // but we do want to check, it doesn't break anything;265    await usingPlaygrounds(async (helper) => {266      const account = accounts.pop()!;267      const ethAccount = helper.address.substrateToEth(account.address); 268      // Alice sets Ethereum address as a sudo. Then Substrate address back...269      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;270      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;271      272      // ...It doesn't break anything;273      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});274      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;275    });276  });277278  it('can be reassigned', async () => {279    await usingPlaygrounds(async (helper) => {280      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];281      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});282      283      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;284      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;285      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;286      287      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;288    });289  });290});291292describe('App-promotion collection sponsoring', () => {293  before(async function () {294    await usingPlaygrounds(async (helper) => {295      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));296      await helper.signTransaction(alice, tx);297    });298  });299300  it('should actually sponsor transactions', async () => {301    await usingPlaygrounds(async (helper) => {302      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];303      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});304      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});305      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));306      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);307308      await token.transfer(tokenSender, {Substrate: receiver.address});309      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});310      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);311312      // senders balance the same, transaction has sponsored313      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);314      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;315    });316  });317318  it('can not be set by non admin', async () => {319    await usingPlaygrounds(async (helper) => {320      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];321322      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});323      324      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;325      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');326    });327  });328329  it('should set pallet address as confirmed admin', async () => {330    await usingPlaygrounds(async (helper) => {331      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];332      333      // Can set sponsoring for collection without sponsor334      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});335      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;336      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});337338      // Can set sponsoring for collection with unconfirmed sponsor339      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});340      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});341      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;342      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});343344      // Can set sponsoring for collection with confirmed sponsor345      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});346      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);347      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;348      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});349    });350  });351352  it('can be overwritten by collection owner', async () => {    353    await usingPlaygrounds(async (helper) => {354      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];355      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});356      const collectionId = collection.collectionId;357      358      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;359      360      // Collection limits still can be changed by the owner361      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;362      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);363      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});364365      // Collection sponsor can be changed too366      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;367      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});368    });369  });370  371  it('should not overwrite collection limits set by the owner earlier', async () => {372    await usingPlaygrounds(async (helper) => {373      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};374      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});375376      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;377      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);378    });379  });380  381  it('should reject transaction if collection doesn\'t exist', async () => {382    await usingPlaygrounds(async (helper) => {383      const collectionOwner = accounts.pop()!;384      385      // collection has never existed386      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;387      // collection has been burned388      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});389      await collection.burn(collectionOwner);390391      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;392    });393  });394});395396describe('app-promotion stopSponsoringCollection', () => {397  it('can not be called by non-admin', async () => {    398    await usingPlaygrounds(async (helper) => {399      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];400      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});401      402      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;403      404      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;405      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});406    });407  });408409  it('should set sponsoring as disabled', async () => {410    await usingPlaygrounds(async (helper) => {411      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];412      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});413      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});414      415      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));416      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));417      418      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');419420      // Transactions are not sponsored anymore:421      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);422      await token.transfer(collectionOwner, {Substrate: recepient.address});423      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);424      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);425    });426  });427428  it('should not affect collection which is not sponsored by pallete', async () => {429    await usingPlaygrounds(async (helper) => {430      const collectionOwner = accounts.pop()!;431      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});432      await collection.confirmSponsorship(collectionOwner);433      434      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;435      436      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});437    });438  });439440  it('should reject transaction if collection does not exist', async () => {    441    await usingPlaygrounds(async (helper) => {442      const collectionOwner = accounts.pop()!;443      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});444      445      await collection.burn(collectionOwner);446      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;447      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;448    });449  });450});451452describe('app-promotion contract sponsoring', () => {453  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {454    await usingPlaygrounds(async (helper) => {455      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();456      const flipper = await deployFlipper(web3, contractOwner);457      const contractMethods = contractHelpers(web3, contractOwner);458459      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));460      461      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  462      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  463      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({464        confirmed: {465          substrate: palletAddress,466        },467      });468    });469  });470471  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {472    await usingPlaygrounds(async (helper) => {473      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();474      const flipper = await deployFlipper(web3, contractOwner);475      const contractMethods = contractHelpers(web3, contractOwner);476477      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;478479      // Contract is self sponsored480      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({481        confirmed: {482          ethereum: flipper.options.address.toLowerCase(),483        },484      });485486      // set promotion sponsoring487      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));488489      // new sponsor is pallet address490      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  491      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  492      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({493        confirmed: {494          substrate: palletAddress,495        },496      });497    });498  });499500  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {501    await usingPlaygrounds(async (helper) => {      502      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();503      const flipper = await deployFlipper(web3, contractOwner);504      const contractMethods = contractHelpers(web3, contractOwner);505506      // contract sponsored by pallet507      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));508509      // owner sets self sponsoring510      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;511512      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  513      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  514      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({515        confirmed: {516          ethereum: flipper.options.address.toLowerCase(),517        },518      });519    });520  });521522  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {523    await usingPlaygrounds(async (helper) => {      524      const nonAdmin = accounts.pop()!;525      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();526      const flipper = await deployFlipper(web3, contractOwner);527      const contractMethods = contractHelpers(web3, contractOwner);528529      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;530531      // nonAdmin calls sponsorContract532      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address))).to.be.rejected;533534      // contract still self-sponsored 535      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({536        confirmed: {537          ethereum: flipper.options.address.toLowerCase(),538        },539      });540    });541542    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {543      await usingPlaygrounds(async (helper) => {544545      });546    });547  });548549  itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => {550    await usingPlaygrounds(async (helper) => {      551      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);552      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();553      const flipper = await deployFlipper(web3, contractOwner);554      const contractHelper = contractHelpers(web3, contractOwner);555      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});556      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});557      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);558559      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));560      await flipper.methods.flip().send({from: caller});561      expect(await flipper.methods.getValue().call()).to.be.true;562563      const callerBalance = await helper.balance.getEthereum(caller);564      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);565566      expect(callerBalance).to.be.equal(1000n * nominal);567      expect(1000n * nominal > contractBalanceAfter).to.be.true;568    });569  });570});571572describe('app-promotion stopSponsoringContract', () => {  573  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {574    await usingPlaygrounds(async (helper) => {      575      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);576      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();577      const flipper = await deployFlipper(web3, contractOwner);578      await transferBalanceToEth(api, alice, flipper.options.address);579      const contractHelper = contractHelpers(web3, contractOwner);580      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});581      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));582      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));583584      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  585      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  586      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({587        disabled: null,588      });589590      await flipper.methods.flip().send({from: caller});591      expect(await flipper.methods.getValue().call()).to.be.true;592593      const callerBalance = await helper.balance.getEthereum(caller);594      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);595596      // caller payed for call597      expect(1000n * nominal > callerBalance).to.be.true;598      expect(contractBalanceAfter).to.be.equal(1000n * nominal);599    });600  });601602  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {603    await usingPlaygrounds(async (helper) => {      604      const nonAdmin = accounts.pop()!;605      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();606      const flipper = await deployFlipper(web3, contractOwner);607608      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));609      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;610    });611  });612613  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {614    await usingPlaygrounds(async (helper) => {      615      const nonAdmin = accounts.pop()!;616      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();617      const flipper = await deployFlipper(web3, contractOwner);618      const contractHelper = contractHelpers(web3, contractOwner);619      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;620621      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;622    });623  });624});625626describe('app-promotion rewards', () => {627  it('can not be called by non admin', async () => {628    await usingPlaygrounds(async (helper) => {629      const nonAdmin = accounts.pop()!;630      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;631    });632  });633634  it('should credit 0.05% for staking period', async () => {    635    await usingPlaygrounds(async helper => {636      const staker = accounts.pop()!;637      638      await helper.staking.stake(staker, 100n * nominal);639      await helper.staking.stake(staker, 200n * nominal);640641      // wair rewards are available:642      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[1][0];643      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));644645      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));646647      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);648      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);649    });650  });651652  it('shoud be paid for more than one period if payments was missed', async () => {653    await usingPlaygrounds(async (helper) => {654      const staker = accounts.pop()!;655656      await helper.staking.stake(staker, 100n * nominal);657      // wait for two rewards are available:658      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];659      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);660661      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));662      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});663      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);664      expect(stakedPerBlock[0][1]).to.be.equal(frozenBalanceShouldBe);665666      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);667668      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});669    });670  });671  672  it('should not be credited for unstaked (reserved) balance', async () => {673    await usingPlaygrounds(async helper => {674      // staker unstakes before rewards has been payed675      const staker = accounts.pop()!;676      await helper.staking.stake(staker, 100n * nominal);677      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];678      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);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);696697      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];698      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));699      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)]);703      704      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);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)]);      708    });709  });710711  it.skip('can be paid 1000 rewards in a time', async () => {712    // all other stakes should be unstaked713    await usingPlaygrounds(async (helper) => {714      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);715716      // stakers stakes 10 times each717      for (let i = 0; i < 10; i++) {718        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));719      }720      await helper.wait.newBlocks(40);721      const result = await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));722    });723  });724725  it.skip('can handle 40.000 rewards', async () => {726    await usingPlaygrounds(async (helper) => {727      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);728      const crowdStakes = async () => {729        // each account in the crowd stakes 2 times730        const crowd = await helper.arrange.createCrowd(500, 300n, donor);731        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));732        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));733        // 734      };735736      for (let i = 0; i < 40; i++) {737        await crowdStakes();738      }739740      // TODO pay rewards for some period741    });742  });743});744745function calculatePalleteAddress(palletId: any) {746  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));747  return encodeAddress(address);748}749750function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {751  const DAY = 7200n;752  const ACCURACY = 1_000_000_000n;753  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;754  755  if (iter > 1) {756    return calculateIncome(income, calcPeriod, iter - 1);757  } else return income;758}