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

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  itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip, LOCKING_PERIOD, UNLOCKING_PERIOD,20} from '../../util';21import {DevUniqueHelper} from '../../util/playgrounds/unique.dev';22import {itEth, expect, SponsoringMode} from '../../eth/util';2324let donor: IKeyringPair;25let palletAdmin: IKeyringPair;26let nominal: bigint;27let palletAddress: string;28let accounts: IKeyringPair[];29// App promotion periods:30// LOCKING_PERIOD = 12 blocks of relay31// UNLOCKING_PERIOD = 6 blocks of parachain3233describe('App promotion', () => {34  before(async function () {35    await usingPlaygrounds(async (helper, privateKey) => {36      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);37      donor = await privateKey({filename: __filename});38      palletAddress = helper.arrange.calculatePalletAddress('appstake');39      palletAdmin = await privateKey('//PromotionAdmin');40      nominal = helper.balance.getOneTokenNominal();4142      const accountBalances = new Array(100);43      accountBalances.fill(1000n);44      accounts = await helper.arrange.createAccounts(accountBalances, donor); // create accounts-pool to speed up tests45    });46  });4748  describe('stake extrinsic', () => {49    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {50      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];51      const totalStakedBefore = await helper.staking.getTotalStaked();5253      // Minimum stake amount is 100:54      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;55      await helper.staking.stake(staker, 100n * nominal);5657      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...58      // ...so he can not transfer 90059      expect(await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});60      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: 100n * nominal, reasons: 'All'}]);61      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');6263      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);64      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);65      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo?66      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased676869      await helper.staking.stake(staker, 200n * nominal);70      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);71      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});72      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);73      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);74    });7576    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {77      const [staker] = await helper.arrange.createAccounts([2000n], donor);78      for (let i = 0; i < 10; i++) {79        await helper.staking.stake(staker, 100n * nominal);80      }8182      // can have 10 stakes83      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);84      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);8586      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');8788      // After unstake can stake again89      await helper.staking.unstakeAll(staker);90      await helper.staking.stake(staker, 100n * nominal);91      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);92    });9394    itSub('should allow to stake() if balance is locked with different id', async ({helper}) => {95      const staker = accounts.pop()!;9697      // staker has tokens locked with vesting id:98      await helper.balance.vestedTransfer(donor, staker.address, {start: 0n, period: 1n, periodCount: 1n, perPeriod: 200n * nominal});99      expect(await helper.balance.getSubstrateFull(staker.address))100        .to.deep.contain({free: 1200n * nominal, miscFrozen: 200n * nominal, feeFrozen: 200n * nominal, reserved: 0n});101102      // Locked balance can be staked. staker can stake 1200 tokens (minus fee):103      await helper.staking.stake(staker, 1000n * nominal);104      await helper.staking.stake(staker, 199n * nominal);105      // check balances106      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'ormlvest', amount: 200n * nominal, reasons: 'All'}, {id: 'appstake', amount: 1199n * nominal, reasons: 'All'}]);107      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 1199n * nominal, feeFrozen: 1199n * nominal});108      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.eq(1199n);109      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.eq(1199n * nominal);110111      // staker can unstake112      await helper.staking.unstakeAll(staker);113      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.eq(1199n * nominal);114      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});115      await helper.wait.forParachainBlockNumber(pendingUnstake.block);116117      // check balances118      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'ormlvest', amount: 200n * nominal, reasons: 'All'}]);119      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 200n * nominal, feeFrozen: 200n * nominal});120      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.eq(1199n);121      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.eq(0n);122123      // staker can transfer balances now124      await helper.balance.transferToSubstrate(staker, donor.address, 900n * nominal);125    });126127    itSub('should not allow to stake(), if stake amount is more than total free balance minus locked by staking', async ({helper}) => {128      const staker = accounts.pop()!;129130      // Can't stake full balance because Alice needs to pay some fee131      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected; // With('Arithmetic')132      await helper.staking.stake(staker, 500n * nominal);133134      // Can't stake 500 tkn because Alice has Less than 500 transferable;135      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejected; // With('Arithmetic');136      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);137    });138139    itSub('for different accounts in one block is possible', async ({helper}) => {140      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];141142      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));143      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;144145      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));146      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);147    });148  });149150  describe('Unstaking', () => {151    [152      {method: 'unstakeAll' as const},153      {method: 'unstakePartial' as const},154    ].map(testCase => {155      itSub(`[${testCase.method}] should move tokens to "pendingUnstake" and subtract it from totalStaked`, async ({helper}) => {156        const [staker, recepient] = [accounts.pop()!, accounts.pop()!];157        const totalStakedBefore = await helper.staking.getTotalStaked();158        const STAKE_AMOUNT = 900n * nominal;159160        await helper.staking.stake(staker, STAKE_AMOUNT);161        testCase.method === 'unstakeAll'162          ? await helper.staking.unstakeAll(staker)163          : await helper.staking.unstakePartial(staker, STAKE_AMOUNT);164165        // Right after unstake tokens are still locked166        expect(await helper.staking.getStakesNumber({Substrate: staker.address})).to.eq(0);167        expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: STAKE_AMOUNT, reasons: 'All'}]);168        expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: STAKE_AMOUNT, feeFrozen: STAKE_AMOUNT});169        // Staker can not transfer170        await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');171        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(STAKE_AMOUNT);172        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);173        expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);174      });175    });176177    [178      {method: 'unstakeAll' as const},179      {method: 'unstakePartial' as const},180    ].map(testCase => {181      itSub(`[${testCase.method}] should unlock balance after unlocking period ends and remove it from "pendingUnstake"`, async ({helper}) => {182        const staker = accounts.pop()!;183        await helper.staking.stake(staker, 100n * nominal);184        testCase.method === 'unstakeAll'185          ? await helper.staking.unstakeAll(staker)186          : await helper.staking.unstakePartial(staker, 100n * nominal);187        const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});188189        // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n190        await helper.wait.forParachainBlockNumber(pendingUnstake.block);191        expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});192        expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);193194        // staker can transfer:195        await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);196        expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);197      });198    });199200    [201      {method: 'unstakeAll' as const},202      {method: 'unstakePartial' as const},203    ].map(testCase => {204      itSub(`[${testCase.method}] should successfully unstake multiple stakes`, async ({helper}) => {205        const staker = accounts.pop()!;206        await helper.staking.stake(staker, 100n * nominal);207        await helper.staking.stake(staker, 200n * nominal);208        await helper.staking.stake(staker, 300n * nominal);209210        // staked: [100, 200, 300]; unstaked: 0211        let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});212        let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});213        let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});214        expect(totalPendingUnstake).to.be.deep.equal(0n);215        expect(pendingUnstake).to.be.deep.equal([]);216        expect(stakes[0].amount).to.equal(100n * nominal);217        expect(stakes[1].amount).to.equal(200n * nominal);218        expect(stakes[2].amount).to.equal(300n * nominal);219220        // Can unstake multiple stakes221        testCase.method === 'unstakeAll'222          ? await helper.staking.unstakeAll(staker)223          : await helper.staking.unstakePartial(staker, 600n * nominal);224225        pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});226        totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});227        stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});228        expect(totalPendingUnstake).to.be.equal(600n * nominal);229        expect(stakes).to.be.deep.equal([]);230        expect(pendingUnstake[0].amount).to.equal(600n * nominal);231232        expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 600n * nominal, miscFrozen: 600n * nominal});233        expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);234        await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);235        expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});236        expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);237      });238    });239240    [241      {method: 'unstakeAll' as const},242      {method: 'unstakePartial' as const},243    ].map(testCase => {244      itSub(`[${testCase.method}] should not have any effects if no active stakes`, async ({helper}) => {245        const staker = accounts.pop()!;246247        // unstake has no effect if no stakes at all248        testCase.method === 'unstakeAll'249          ? await helper.staking.unstakeAll(staker)250          : await helper.staking.unstakePartial(staker, 100n * nominal);251252        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);253        expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper254255        // TODO stake() unstake() waitUnstaked() unstake();256257        // can't unstake if there are only pendingUnstakes258        await helper.staking.stake(staker, 100n * nominal);259260        if (testCase.method === 'unstakeAll') {261          await helper.staking.unstakeAll(staker);262          await helper.staking.unstakeAll(staker);263        } else {264          await helper.staking.unstakePartial(staker, 100n * nominal);265          await helper.staking.unstakePartial(staker, 100n * nominal);266        }267268        expect(await helper.staking.getStakesNumber({Substrate: staker.address})).to.eq(0);269        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);270        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);271      });272    });273274    [275      {method: 'unstakeAll' as const},276      {method: 'unstakePartial' as const},277    ].map(testCase => {278      itSub(`[${testCase.method}] should create different pending-unlock for each unlocking stake`, async ({helper}) => {279        const staker = accounts.pop()!;280        await helper.staking.stake(staker, 100n * nominal);281        testCase.method === 'unstakeAll'282          ? await helper.staking.unstakeAll(staker)283          : await helper.staking.unstakePartial(staker, 100n * nominal);284        await helper.staking.stake(staker, 120n * nominal);285        testCase.method === 'unstakeAll'286          ? await helper.staking.unstakeAll(staker)287          : await helper.staking.unstakePartial(staker, 120n * nominal);288289        const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});290        expect(unstakingPerBlock).has.length(2);291        expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);292        expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);293        expect(await helper.staking.getStakesNumber({Substrate: staker.address})).to.equal(0);294      });295    });296297    [298      {method: 'unstakeAll' as const},299      {method: 'unstakePartial' as const},300    ].map(testCase => {301      itSub(`[${testCase.method}] should be possible for 3 accounts in one block`, async ({helper}) => {302        const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];303304        await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));305        await Promise.all(stakers.map(staker => {306          return testCase.method === 'unstakeAll'307            ? helper.staking.unstakeAll(staker)308            : helper.staking.unstakePartial(staker, 100n * nominal);309        }));310311        await Promise.all(stakers.map(async (staker) => {312          expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);313          expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);314        }));315      });316    });317318    itSub('should not be possible for more than 3 accounts in one block', async ({helper}) => {319      if (!await helper.arrange.isDevNode()) {320        const stakers = await helper.arrange.createAccounts([200n,200n,200n,200n,200n,200n,200n,200n,200n,200n], donor);321322        await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));323        const unstakingResults = await Promise.allSettled(stakers.map((staker, i) => {324          return i % 2 === 0325            ? helper.staking.unstakeAll(staker)326            : helper.staking.unstakePartial(staker, 100n * nominal);327        }));328329        const successfulUnstakes = unstakingResults.filter(result => result.status === 'fulfilled');330        expect(successfulUnstakes).to.have.length(3);331      }332    });333  });334335  describe('collection sponsoring', () => {336    itSub('should actually sponsor transactions', async ({helper}) => {337      const api = helper.getApi();338      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];339      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});340      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});341      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));342      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);343344      await token.transfer(tokenSender, {Substrate: receiver.address});345      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});346      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);347348      // senders balance the same, transaction has sponsored349      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);350      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;351    });352353    itSub('can not be set by non admin', async ({helper}) => {354      const api = helper.getApi();355      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];356357      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});358359      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;360      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');361    });362363    itSub('should set pallet address as confirmed admin', async ({helper}) => {364      const api = helper.getApi();365      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];366367      // Can set sponsoring for collection without sponsor368      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});369      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;370      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});371372      // Can set sponsoring for collection with unconfirmed sponsor373      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});374      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});375      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;376      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});377378      // Can set sponsoring for collection with confirmed sponsor379      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});380      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);381      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;382      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});383    });384385    itSub('can be overwritten by collection owner', async ({helper}) => {386      const api = helper.getApi();387      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];388      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});389      const collectionId = collection.collectionId;390391      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;392393      // Collection limits still can be changed by the owner394      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;395      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);396      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});397398      // Collection sponsor can be changed too399      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;400      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});401    });402403    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {404      const api = helper.getApi();405      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};406      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});407408      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;409      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);410    });411412    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {413      const api = helper.getApi();414      const collectionOwner = accounts.pop()!;415416      // collection has never existed417      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;418      // collection has been burned419      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});420      await collection.burn(collectionOwner);421422      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;423    });424  });425426  describe('stopSponsoringCollection', () => {427    itSub('can not be called by non-admin', async ({helper}) => {428      const api = helper.getApi();429      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];430      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});431432      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;433434      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;435      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});436    });437438    itSub('should set sponsoring as disabled', async ({helper}) => {439      const api = helper.getApi();440      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];441      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});442      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});443444      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));445      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));446447      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');448449      // Transactions are not sponsored anymore:450      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);451      await token.transfer(collectionOwner, {Substrate: recepient.address});452      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);453      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);454    });455456    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {457      const api = helper.getApi();458      const collectionOwner = accounts.pop()!;459      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});460      await collection.confirmSponsorship(collectionOwner);461462      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;463464      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});465    });466467    itSub('should reject transaction if collection does not exist', async ({helper}) => {468      const collectionOwner = accounts.pop()!;469      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});470471      await collection.burn(collectionOwner);472      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');473      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');474    });475  });476477  describe('contract sponsoring', () => {478    itEth('should set palletes address as a sponsor', async ({helper}) => {479      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();480      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);481      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);482483      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);484485      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;486      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);487      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({488        confirmed: {489          substrate: palletAddress,490        },491      });492    });493494    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {495      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();496      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);497      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);498499      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;500501      // Contract is self sponsored502      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({503        confirmed: {504          ethereum: flipper.options.address.toLowerCase(),505        },506      });507508      // set promotion sponsoring509      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);510511      // new sponsor is pallet address512      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;513      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);514      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({515        confirmed: {516          substrate: palletAddress,517        },518      });519    });520521    itEth('can be overwritten by contract owner', async ({helper}) => {522      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();523      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);524      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);525526      // contract sponsored by pallet527      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);528529      // owner sets self sponsoring530      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;531532      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;533      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);534      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({535        confirmed: {536          ethereum: flipper.options.address.toLowerCase(),537        },538      });539    });540541    itEth('can not be set by non admin', async ({helper}) => {542      const nonAdmin = accounts.pop()!;543      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();544      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);545      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);546547      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;548549      // nonAdmin calls sponsorContract550      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');551552      // contract still self-sponsored553      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({554        confirmed: {555          ethereum: flipper.options.address.toLowerCase(),556        },557      });558    });559560    itEth('should actually sponsor transactions', async ({helper}) => {561      // Contract caller562      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);563      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);564565      // Deploy flipper566      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();567      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);568      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);569570      // Owner sets to sponsor every tx571      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});572      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});573      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);574575      // Set promotion to the Flipper576      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);577578      // Caller calls Flipper579      await flipper.methods.flip().send({from: caller});580      expect(await flipper.methods.getValue().call()).to.be.true;581582      // The contracts and caller balances have not changed583      const callerBalance = await helper.balance.getEthereum(caller);584      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);585      expect(callerBalance).to.be.equal(1000n * nominal);586      expect(1000n * nominal === contractBalanceAfter).to.be.true;587588      // The pallet balance has decreased589      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);590      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;591    });592  });593594  describe('stopSponsoringContract', () => {595    itEth('should remove pallet address from contract sponsors', async ({helper}) => {596      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);597      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();598      const flipper = await helper.eth.deployFlipper(contractOwner);599      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);600      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);601602      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});603      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);604      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);605606      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;607      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);608      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({609        disabled: null,610      });611612      await flipper.methods.flip().send({from: caller});613      expect(await flipper.methods.getValue().call()).to.be.true;614615      const callerBalance = await helper.balance.getEthereum(caller);616      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);617618      // caller payed for call619      expect(1000n * nominal > callerBalance).to.be.true;620      expect(contractBalanceAfter).to.be.equal(100n * nominal);621    });622623    itEth('can not be called by non-admin', async ({helper}) => {624      const nonAdmin = accounts.pop()!;625      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();626      const flipper = await helper.eth.deployFlipper(contractOwner);627628      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);629      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))630        .to.be.rejectedWith(/appPromotion\.NoPermission/);631    });632633    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {634      const nonAdmin = accounts.pop()!;635      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();636      const flipper = await helper.eth.deployFlipper(contractOwner);637      const contractHelper = await helper.ethNativeContract.contractHelpers(contractOwner);638      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;639640      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');641    });642  });643644  describe('payoutStakers', () => {645    itSub('can not be called by non admin', async ({helper}) => {646      const nonAdmin = accounts.pop()!;647      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');648    });649650    itSub('should increase total staked', async ({helper}) => {651      const staker = accounts.pop()!;652      const totalStakedBefore = await helper.staking.getTotalStaked();653      await helper.staking.stake(staker, 100n * nominal);654655      // Wait for rewards and pay656      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});657      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));658      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);659660      const totalStakedAfter = await helper.staking.getTotalStaked();661      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);662      // staker can unstake663      await helper.staking.unstakeAll(staker);664      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal));665    });666667    itSub('should credit 0.05% for staking period', async ({helper}) => {668      const staker = accounts.pop()!;669670      await waitPromotionPeriodDoesntEnd(helper);671672      await helper.staking.stake(staker, 100n * nominal);673      await helper.staking.stake(staker, 200n * nominal);674675      // wait rewards are available:676      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});677      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));678679      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;680      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal));681682      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});683      const income1 = calculateIncome(100n * nominal);684      const income2 = calculateIncome(200n * nominal);685      expect(totalStakedPerBlock[0].amount).to.equal(income1);686      expect(totalStakedPerBlock[1].amount).to.equal(income2);687688      const stakerBalance = await helper.balance.getSubstrateFull(staker.address);689      expect(stakerBalance).to.contain({miscFrozen: income1 + income2, feeFrozen: income1 + income2, reserved: 0n});690      expect(stakerBalance.free / nominal).to.eq(999n);691    });692693    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {694      const staker = accounts.pop()!;695696      await helper.staking.stake(staker, 100n * nominal);697      // wait for two rewards are available:698      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});699      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);700701      await helper.admin.payoutStakers(palletAdmin, 100);702      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});703      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);704      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);705706      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);707708      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});709    });710711    itSub('should not be credited for pending-unstaked tokens', async ({helper}) => {712      // staker unstakes before rewards been payed713      const staker = accounts.pop()!;714      await helper.staking.stake(staker, 100n * nominal);715      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});716      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);717      await helper.staking.unstakeAll(staker);718719      // so he did not receive any rewards720      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);721      await helper.admin.payoutStakers(palletAdmin, 100);722      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);723724      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);725    });726727    itSub('should bring compound interest', async ({helper}) => {728      const staker = accounts.pop()!;729730      await helper.staking.stake(staker, 100n * nominal);731732      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});733      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));734735      await helper.admin.payoutStakers(palletAdmin, 100);736      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});737      expect(stake.amount).to.equal(calculateIncome(100n * nominal));738739      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);740      await helper.admin.payoutStakers(palletAdmin, 100);741      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});742      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 2));743    });744745    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {746      // all other stakes should be unstaked747      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);748749      // stakers stakes 10 times each750      for (let i = 0; i < 10; i++) {751        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));752      }753      await helper.wait.newBlocks(40);754      await helper.admin.payoutStakers(palletAdmin, 100);755    });756757    itSub.skip('can handle 40.000 rewards', async ({helper}) => {758      const crowdStakes = async () => {759        // each account in the crowd stakes 2 times760        const crowd = await helper.arrange.createCrowd(500, 300n, donor);761        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));762        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));763        //764      };765766      for (let i = 0; i < 40; i++) {767        await crowdStakes();768      }769770      // TODO pay rewards for some period771    });772  });773});774775function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {776  const DAY = 7200n;777  const ACCURACY = 1_000_000_000n;778  // 5n / 10_000n = 0.05% p/day779  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;780781  if (iter > 1) {782    return calculateIncome(income, iter - 1, calcPeriod);783  } else return income;784}785786function rewardAvailableInBlock(stakedInBlock: bigint) {787  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;788  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);789}790791// Wait while promotion period less than specified block, to avoid boundary cases792// 0 if this should be the beginning of the period.793async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {794  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();795  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;796797  if (currentPeriodBlock > waitBlockLessThan) {798    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);799  }800}