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

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';31import {DevUniqueHelper} from './util/playgrounds/unique.dev';32chai.use(chaiAsPromised);33const expect = chai.expect;3435let alice: IKeyringPair;36let palletAdmin: IKeyringPair;37let nominal: bigint;38const palletAddress = calculatePalleteAddress('appstake');39let accounts: IKeyringPair[] = [];40const LOCKING_PERIOD = 20n; // 20 blocks of relay41const UNLOCKING_PERIOD = 10n; // 20 blocks of parachain42const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);4344const beforeEach = async (context: Mocha.Context) => {45  await usingPlaygrounds(async (helper, privateKey) => {46    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) context.skip();47    alice = privateKey('//Alice');48    palletAdmin = privateKey('//Charlie'); // TODO use custom address49    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));50    nominal = helper.balance.getOneTokenNominal();51    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);52    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);53    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests54  });55};5657describe('app-promotions.stake extrinsic', () => {58  before(async function () {59    await beforeEach(this);60  });6162  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {63    await usingPlaygrounds(async (helper) => {64      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];65      const totalStakedBefore = await helper.staking.getTotalStaked();6667      // Minimum stake amount is 100:68      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected;69      await helper.staking.stake(staker, 100n * nominal);7071      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...72      // ...so he can not transfer 90073      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});74      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;75      76      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);77      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);78      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 79      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 8081      82      await helper.staking.stake(staker, 200n * nominal);83      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);84      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});85      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);86      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);87    });88  });8990  it('should allow to create maximum 10 stakes for account', async () => {91    await usingPlaygrounds(async (helper) => {92      const [staker] = await helper.arrange.createAccounts([2000n], alice);93      for (let i = 0; i < 10; i++) {94        await helper.staking.stake(staker, 100n * nominal);95      }9697      // can have 10 stakes98      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);99      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);100101      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected;102103      // After unstake can stake again104      await helper.staking.unstake(staker);105      await helper.staking.stake(staker, 100n * nominal);106      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);107    });108  });109  110  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {111    await usingPlaygrounds(async helper => { 112      const staker = accounts.pop()!;113114      // Can't stake full balance because Alice needs to pay some fee115      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;116      await helper.staking.stake(staker, 500n * nominal);117118      // Can't stake 500 tkn because Alice has Less than 500 transferable;119      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 120      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);121    });122  });123  124  it('for different accounts in one block is possible', async () => {125    await usingPlaygrounds(async helper => {126      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];127      128      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));129      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;130131      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));132      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);133    });134  });135});136137describe('unstake balance extrinsic', () => {  138  before(async function () {139    await beforeEach(this);140  });141142  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {143    await usingPlaygrounds(async helper => {144      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];145      const totalStakedBefore = await helper.staking.getTotalStaked();146      await helper.staking.stake(staker, 900n * nominal);147      await helper.staking.unstake(staker);148149      // Right after unstake balance is reserved150      // Staker can not transfer 151      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});152      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;153      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);154      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);155      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);156    });157  });158159  it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => {160    await usingPlaygrounds(async (helper) => {161      const staker = accounts.pop()!;162      await helper.staking.stake(staker, 100n * nominal);163      await helper.staking.unstake(staker);164      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});165166      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n167      await helper.wait.forParachainBlockNumber(pendingUnstake.block);168      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});169      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);170171      // staker can transfer:172      await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);173      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);174    });175  });176177  it('should successfully unstake multiple stakes', async () => {178    await usingPlaygrounds(async helper => {179      const staker = accounts.pop()!;180      await helper.staking.stake(staker, 100n * nominal);181      await helper.staking.stake(staker, 200n * nominal);182      await helper.staking.stake(staker, 300n * nominal);183184      // staked: [100, 200, 300]; unstaked: 0185      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});186      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});187      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});188      expect(totalPendingUnstake).to.be.deep.equal(0n);189      expect(pendingUnstake).to.be.deep.equal([]);190      expect(stakes[0].amount).to.equal(100n * nominal);191      expect(stakes[1].amount).to.equal(200n * nominal);192      expect(stakes[2].amount).to.equal(300n * nominal);193     194      // Can unstake multiple stakes195      await helper.staking.unstake(staker);196      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});197      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});198      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});199      expect(totalPendingUnstake).to.be.equal(600n * nominal);200      expect(stakes).to.be.deep.equal([]);201      expect(pendingUnstake[0].amount).to.equal(600n * nominal);202203      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});204      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);205      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});206      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);207    });208  });209210  it('should not have any effects if no active stakes', async () => {211    await usingPlaygrounds(async (helper) => {212      const staker = accounts.pop()!;213      214      // unstake has no effect if no stakes at all215      await helper.staking.unstake(staker);216      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);217      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper218219      // TODO stake() unstake() waitUnstaked() unstake();220221      // can't unstake if there are only pendingUnstakes222      await helper.staking.stake(staker, 100n * nominal);223      await helper.staking.unstake(staker);224      await helper.staking.unstake(staker);225226      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);227      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);228    });229  });230231  it('should keep different unlocking block for each unlocking stake', async () => {232    await usingPlaygrounds(async (helper) => {233      const staker = accounts.pop()!;234      await helper.staking.stake(staker, 100n * nominal);235      await helper.staking.unstake(staker);236      await helper.staking.stake(staker, 120n * nominal);237      await helper.staking.unstake(staker);238239      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});240      expect(unstakingPerBlock).has.length(2);241      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);242      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);243    });244  });245246  it('should be possible for different accounts in one block', async () => {247    await usingPlaygrounds(async (helper) => {248      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];249250      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));251      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));252253      await Promise.all(stakers.map(async (staker) => {254        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);255        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);256      }));257    });258  });259});260261describe('Admin adress', () => {262  before(async function () {263    await beforeEach(this);264  });265266  it('can be set by sudo only', async () => {267    await usingPlaygrounds(async (helper) => {268      const nonAdmin = accounts.pop()!;269      // nonAdmin can not set admin not from himself nor as a sudo270      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;271      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;272273      // Alice can274      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;275    });276  });277  278  it('can be any valid CrossAccountId', async () => {279    // We are not going to set an eth address as a sponsor,280    // but we do want to check, it doesn't break anything;281    await usingPlaygrounds(async (helper) => {282      const account = accounts.pop()!;283      const ethAccount = helper.address.substrateToEth(account.address); 284      // Alice sets Ethereum address as a sudo. Then Substrate address back...285      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;286      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;287      288      // ...It doesn't break anything;289      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});290      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;291    });292  });293294  it('can be reassigned', async () => {295    await usingPlaygrounds(async (helper) => {296      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];297      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});298      299      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;300      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;301      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;302      303      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;304    });305  });306});307308describe('App-promotion collection sponsoring', () => {309  before(async function () {310    await beforeEach(this);311    await usingPlaygrounds(async (helper) => {312      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));313      await helper.signTransaction(alice, tx);314    });315  });316317  it('should actually sponsor transactions', async () => {318    await usingPlaygrounds(async (helper) => {319      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];320      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});321      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});322      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));323      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);324325      await token.transfer(tokenSender, {Substrate: receiver.address});326      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});327      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);328329      // senders balance the same, transaction has sponsored330      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);331      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;332    });333  });334335  it('can not be set by non admin', async () => {336    await usingPlaygrounds(async (helper) => {337      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];338339      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});340      341      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;342      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');343    });344  });345346  it('should set pallet address as confirmed admin', async () => {347    await usingPlaygrounds(async (helper) => {348      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];349      350      // Can set sponsoring for collection without sponsor351      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});352      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;353      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});354355      // Can set sponsoring for collection with unconfirmed sponsor356      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});357      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});358      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;359      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});360361      // Can set sponsoring for collection with confirmed sponsor362      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});363      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);364      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;365      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});366    });367  });368369  it('can be overwritten by collection owner', async () => {    370    await usingPlaygrounds(async (helper) => {371      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];372      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});373      const collectionId = collection.collectionId;374      375      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;376      377      // Collection limits still can be changed by the owner378      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;379      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);380      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});381382      // Collection sponsor can be changed too383      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;384      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});385    });386  });387  388  it('should not overwrite collection limits set by the owner earlier', async () => {389    await usingPlaygrounds(async (helper) => {390      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};391      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});392393      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;394      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);395    });396  });397  398  it('should reject transaction if collection doesn\'t exist', async () => {399    await usingPlaygrounds(async (helper) => {400      const collectionOwner = accounts.pop()!;401      402      // collection has never existed403      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;404      // collection has been burned405      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});406      await collection.burn(collectionOwner);407408      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;409    });410  });411});412413describe('app-promotion stopSponsoringCollection', () => {414  before(async function () {415    await beforeEach(this);416  });417418  it('can not be called by non-admin', async () => {    419    await usingPlaygrounds(async (helper) => {420      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];421      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});422      423      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;424      425      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;426      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});427    });428  });429430  it('should set sponsoring as disabled', async () => {431    await usingPlaygrounds(async (helper) => {432      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];433      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});434      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});435      436      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));437      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));438      439      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');440441      // Transactions are not sponsored anymore:442      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);443      await token.transfer(collectionOwner, {Substrate: recepient.address});444      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);445      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);446    });447  });448449  it('should not affect collection which is not sponsored by pallete', async () => {450    await usingPlaygrounds(async (helper) => {451      const collectionOwner = accounts.pop()!;452      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});453      await collection.confirmSponsorship(collectionOwner);454      455      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;456      457      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});458    });459  });460461  it('should reject transaction if collection does not exist', async () => {    462    await usingPlaygrounds(async (helper) => {463      const collectionOwner = accounts.pop()!;464      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});465      466      await collection.burn(collectionOwner);467      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;468      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;469    });470  });471});472473describe('app-promotion contract sponsoring', () => {474  before(async function () {475    await beforeEach(this);476  });477478  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {479    await usingPlaygrounds(async (helper) => {480      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();481      const flipper = await deployFlipper(web3, contractOwner);482      const contractMethods = contractHelpers(web3, contractOwner);483484      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));485      486      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  487      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  488      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({489        confirmed: {490          substrate: palletAddress,491        },492      });493    });494  });495496  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {497    await usingPlaygrounds(async (helper) => {498      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();499      const flipper = await deployFlipper(web3, contractOwner);500      const contractMethods = contractHelpers(web3, contractOwner);501502      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;503504      // Contract is self sponsored505      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({506        confirmed: {507          ethereum: flipper.options.address.toLowerCase(),508        },509      });510511      // set promotion sponsoring512      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));513514      // new sponsor is pallet address515      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  516      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  517      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({518        confirmed: {519          substrate: palletAddress,520        },521      });522    });523  });524525  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {526    await usingPlaygrounds(async (helper) => {      527      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();528      const flipper = await deployFlipper(web3, contractOwner);529      const contractMethods = contractHelpers(web3, contractOwner);530531      // contract sponsored by pallet532      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));533534      // owner sets self sponsoring535      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;536537      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  538      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  539      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({540        confirmed: {541          ethereum: flipper.options.address.toLowerCase(),542        },543      });544    });545  });546547  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {548    await usingPlaygrounds(async (helper) => {      549      const nonAdmin = accounts.pop()!;550      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();551      const flipper = await deployFlipper(web3, contractOwner);552      const contractMethods = contractHelpers(web3, contractOwner);553554      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;555556      // nonAdmin calls sponsorContract557      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address))).to.be.rejected;558559      // contract still self-sponsored 560      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({561        confirmed: {562          ethereum: flipper.options.address.toLowerCase(),563        },564      });565    });566567    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {568      await usingPlaygrounds(async (helper) => {569570      });571    });572  });573574  itWeb3('should actually sponsor transactions', 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      const contractHelper = contractHelpers(web3, contractOwner);580      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});581      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});582      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);583584      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));585      await flipper.methods.flip().send({from: caller});586      expect(await flipper.methods.getValue().call()).to.be.true;587588      const callerBalance = await helper.balance.getEthereum(caller);589      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);590591      expect(callerBalance).to.be.equal(1000n * nominal);592      expect(1000n * nominal > contractBalanceAfter).to.be.true;593    });594  });595});596597describe('app-promotion stopSponsoringContract', () => {  598  before(async function () {599    await beforeEach(this);600  });601602  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {603    await usingPlaygrounds(async (helper) => {      604      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);605      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();606      const flipper = await deployFlipper(web3, contractOwner);607      await transferBalanceToEth(api, alice, flipper.options.address);608      const contractHelper = contractHelpers(web3, contractOwner);609      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});610      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));611      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));612613      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  614      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  615      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({616        disabled: null,617      });618619      await flipper.methods.flip().send({from: caller});620      expect(await flipper.methods.getValue().call()).to.be.true;621622      const callerBalance = await helper.balance.getEthereum(caller);623      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);624625      // caller payed for call626      expect(1000n * nominal > callerBalance).to.be.true;627      expect(contractBalanceAfter).to.be.equal(1000n * nominal);628    });629  });630631  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {632    await usingPlaygrounds(async (helper) => {      633      const nonAdmin = accounts.pop()!;634      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();635      const flipper = await deployFlipper(web3, contractOwner);636637      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));638      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;639    });640  });641642  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {643    await usingPlaygrounds(async (helper) => {      644      const nonAdmin = accounts.pop()!;645      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();646      const flipper = await deployFlipper(web3, contractOwner);647      const contractHelper = contractHelpers(web3, contractOwner);648      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;649650      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;651    });652  });653});654655describe('app-promotion rewards', () => {656  before(async function () {657    await beforeEach(this);658  });659660  it('can not be called by non admin', async () => {661    await usingPlaygrounds(async (helper) => {662      const nonAdmin = accounts.pop()!;663      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;664    });665  });666667  it('should increase total staked', async () => {668    await usingPlaygrounds(async (helper) => {669      const staker = accounts.pop()!;670      const totalStakedBefore = await helper.staking.getTotalStaked();671      await helper.staking.stake(staker, 100n * nominal);672673      // Wait for rewards and pay674      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});675      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));676      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));677678      const totalStakedAfter = await helper.staking.getTotalStaked();679      expect(totalStakedAfter >= totalStakedBefore + calculateIncome(100n * nominal, 10n)).to.be.true;680681      // staker can unstake682      await helper.staking.unstake(staker);683      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));684    });685  });686687  it('should credit 0.05% for staking period', async () => {    688    await usingPlaygrounds(async helper => {689      const staker = accounts.pop()!;690691      await waitPromotionPeriodDoesntEnd(helper);692      693      await helper.staking.stake(staker, 100n * nominal);694      await helper.staking.stake(staker, 200n * nominal);695696      // wait rewards are available:697      const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});698      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));699700      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));701702      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});703      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));704      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));705    });706  });707708  it('shoud be paid for more than one period if payments was missed', async () => {709    await usingPlaygrounds(async (helper) => {710      const staker = accounts.pop()!;711712      await helper.staking.stake(staker, 100n * nominal);713      // wait for two rewards are available:714      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});715      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);716717      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));718      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});719      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);720      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);721722      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);723724      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});725    });726  });727  728  it('should not be credited for unstaked (reserved) balance', async () => {729    await usingPlaygrounds(async helper => {730      // staker unstakes before rewards has been payed731      const staker = accounts.pop()!;732      await helper.staking.stake(staker, 100n * nominal);733      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});734      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);735      await helper.staking.unstake(staker);736      737      // so he did not receive any rewards738      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);739      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));740      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);741742      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);743    });744  });745  746  it('should bring compound interest', async () => {747    await usingPlaygrounds(async helper => {748      const staker = accounts.pop()!;749            750      await helper.staking.stake(staker, 100n * nominal);751752      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});753      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));754      755      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));756      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});757      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));758      759      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);760      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));761      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});762      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));763    });764  });765766  it.skip('can be paid 1000 rewards in a time', async () => {767    // all other stakes should be unstaked768    await usingPlaygrounds(async (helper) => {769      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);770771      // stakers stakes 10 times each772      for (let i = 0; i < 10; i++) {773        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));774      }775      await helper.wait.newBlocks(40);776      const result = await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));777    });778  });779780  it.skip('can handle 40.000 rewards', async () => {781    await usingPlaygrounds(async (helper) => {782      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);783      const crowdStakes = async () => {784        // each account in the crowd stakes 2 times785        const crowd = await helper.arrange.createCrowd(500, 300n, donor);786        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));787        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));788        // 789      };790791      for (let i = 0; i < 40; i++) {792        await crowdStakes();793      }794795      // TODO pay rewards for some period796    });797  });798});799800function calculatePalleteAddress(palletId: any) {801  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));802  return encodeAddress(address);803}804805function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {806  const DAY = 7200n;807  const ACCURACY = 1_000_000_000n;808  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;809  810  if (iter > 1) {811    return calculateIncome(income, calcPeriod, iter - 1);812  } else return income;813}814815// Wait while promotion period less than specified block, to avoid boundary cases816// 0 if this should be the beginning of the period.817async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {818  const relayBlockNumber = (await helper.api!.query.parachainSystem.validationData()).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();819  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;820821  if (currentPeriodBlock > waitBlockLessThan) {822    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);823  }824}