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

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 {itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip} from './util';19import {DevUniqueHelper} from './util/playgrounds/unique.dev';20import {itEth, expect, SponsoringMode} from './eth/util';2122let donor: IKeyringPair;23let palletAdmin: IKeyringPair;24let nominal: bigint;25let palletAddress: string;26let accounts: IKeyringPair[];27const LOCKING_PERIOD = 8n; // 8 blocks of relay28const UNLOCKING_PERIOD = 4n; // 4 blocks of parachain2930describe('App promotion', () => {31  before(async function () {32    await usingPlaygrounds(async (helper, privateKey) => {33      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);34      donor = await privateKey({filename: __filename});35      palletAddress = helper.arrange.calculatePalletAddress('appstake');36      palletAdmin = await privateKey('//PromotionAdmin');37      nominal = helper.balance.getOneTokenNominal();38      accounts = await helper.arrange.createCrowd(100, 1000n, donor); // create accounts-pool to speed up tests39    });40  });4142  describe('stake extrinsic', () => {  43    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {44      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];45      const totalStakedBefore = await helper.staking.getTotalStaked();46  47      // Minimum stake amount is 100:48      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;49      await helper.staking.stake(staker, 100n * nominal);50  51      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...52      // ...so he can not transfer 90053      expect(await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});54      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: 100n * nominal, reasons: 'All'}]);55      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');56      57      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);58      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);59      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 60      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 61  62      63      await helper.staking.stake(staker, 200n * nominal);64      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);65      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});66      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);67      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);68    });69  70    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {71      const [staker] = await helper.arrange.createAccounts([2000n], donor);72      for (let i = 0; i < 10; i++) {73        await helper.staking.stake(staker, 100n * nominal);74      }75  76      // can have 10 stakes77      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);78      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);79  80      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');81  82      // After unstake can stake again83      await helper.staking.unstake(staker);84      await helper.staking.stake(staker, 100n * nominal);85      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);86    });87    88    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {89      const staker = accounts.pop()!;90  91      // Can't stake full balance because Alice needs to pay some fee92      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;93      await helper.staking.stake(staker, 500n * nominal);94  95      // Can't stake 500 tkn because Alice has Less than 500 transferable;96      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 97      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);98    });99    100    itSub('for different accounts in one block is possible', async ({helper}) => {101      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];102        103      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));104      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;105  106      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));107      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);108    });109  });110  111  describe('unstake extrinsic', () => {  112    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {113      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];114      const totalStakedBefore = await helper.staking.getTotalStaked();115      await helper.staking.stake(staker, 900n * nominal);116      await helper.staking.unstake(staker);117  118      // Right after unstake balance is reserved119      // Staker can not transfer 120      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});121      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');122      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);123      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);124      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);125    });126  127    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {128      const staker = accounts.pop()!;129      await helper.staking.stake(staker, 100n * nominal);130      await helper.staking.unstake(staker);131      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});132  133      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n134      await helper.wait.forParachainBlockNumber(pendingUnstake.block);135      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});136      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);137  138      // staker can transfer:139      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);140      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);141    });142  143    itSub('should successfully unstake multiple stakes', async ({helper}) => {144      const staker = accounts.pop()!;145      await helper.staking.stake(staker, 100n * nominal);146      await helper.staking.stake(staker, 200n * nominal);147      await helper.staking.stake(staker, 300n * nominal);148  149      // staked: [100, 200, 300]; unstaked: 0150      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});151      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});152      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});153      expect(totalPendingUnstake).to.be.deep.equal(0n);154      expect(pendingUnstake).to.be.deep.equal([]);155      expect(stakes[0].amount).to.equal(100n * nominal);156      expect(stakes[1].amount).to.equal(200n * nominal);157      expect(stakes[2].amount).to.equal(300n * nominal);158       159      // Can unstake multiple stakes160      await helper.staking.unstake(staker);161      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});162      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});163      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});164      expect(totalPendingUnstake).to.be.equal(600n * nominal);165      expect(stakes).to.be.deep.equal([]);166      expect(pendingUnstake[0].amount).to.equal(600n * nominal);167  168      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});169      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);170      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});171      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);172    });173  174    itSub('should not have any effects if no active stakes', async ({helper}) => {175      const staker = accounts.pop()!;176        177      // unstake has no effect if no stakes at all178      await helper.staking.unstake(staker);179      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);180      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper181  182      // TODO stake() unstake() waitUnstaked() unstake();183  184      // can't unstake if there are only pendingUnstakes185      await helper.staking.stake(staker, 100n * nominal);186      await helper.staking.unstake(staker);187      await helper.staking.unstake(staker);188  189      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);190      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);191    });192  193    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {194      const staker = accounts.pop()!;195      await helper.staking.stake(staker, 100n * nominal);196      await helper.staking.unstake(staker);197      await helper.staking.stake(staker, 120n * nominal);198      await helper.staking.unstake(staker);199  200      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});201      expect(unstakingPerBlock).has.length(2);202      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);203      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);204    });205  206    itSub('should be possible for different accounts in one block', async ({helper}) => {207      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];208  209      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));210      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));211  212      await Promise.all(stakers.map(async (staker) => {213        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);214        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);215      }));216    });217  });218  219  describe('collection sponsoring', () => {220    itSub('should actually sponsor transactions', async ({helper}) => {221      const api = helper.getApi();222      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];223      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});224      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});225      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));226      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);227  228      await token.transfer(tokenSender, {Substrate: receiver.address});229      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});230      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);231  232      // senders balance the same, transaction has sponsored233      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);234      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;235    });236  237    itSub('can not be set by non admin', async ({helper}) => {238      const api = helper.getApi();239      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];240  241      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});242        243      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;244      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');245    });246  247    itSub('should set pallet address as confirmed admin', async ({helper}) => {248      const api = helper.getApi();249      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];250        251      // Can set sponsoring for collection without sponsor252      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});253      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;254      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});255  256      // Can set sponsoring for collection with unconfirmed sponsor257      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});258      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});259      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;260      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});261  262      // Can set sponsoring for collection with confirmed sponsor263      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});264      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);265      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;266      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});267    });268  269    itSub('can be overwritten by collection owner', async ({helper}) => {    270      const api = helper.getApi();271      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];272      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});273      const collectionId = collection.collectionId;274        275      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;276        277      // Collection limits still can be changed by the owner278      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;279      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);280      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});281  282      // Collection sponsor can be changed too283      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;284      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});285    });286    287    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {288      const api = helper.getApi();289      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};290      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});291  292      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;293      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);294    });295    296    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {297      const api = helper.getApi();298      const collectionOwner = accounts.pop()!;299        300      // collection has never existed301      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;302      // collection has been burned303      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});304      await collection.burn(collectionOwner);305  306      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;307    });308  });309  310  describe('stopSponsoringCollection', () => {311    itSub('can not be called by non-admin', async ({helper}) => {312      const api = helper.getApi();313      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];314      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});315        316      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;317        318      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;319      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});320    });321  322    itSub('should set sponsoring as disabled', async ({helper}) => {323      const api = helper.getApi();324      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];325      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});326      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});327        328      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));329      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));330        331      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');332  333      // Transactions are not sponsored anymore:334      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);335      await token.transfer(collectionOwner, {Substrate: recepient.address});336      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);337      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);338    });339  340    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {341      const api = helper.getApi();342      const collectionOwner = accounts.pop()!;343      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});344      await collection.confirmSponsorship(collectionOwner);345        346      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;347        348      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});349    });350  351    itSub('should reject transaction if collection does not exist', async ({helper}) => {    352      const collectionOwner = accounts.pop()!;353      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});354        355      await collection.burn(collectionOwner);356      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');357      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');358    });359  });360  361  describe('contract sponsoring', () => {362    itEth('should set palletes address as a sponsor', async ({helper}) => {363      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();364      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);365      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);366  367      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);368      369      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  370      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  371      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({372        confirmed: {373          substrate: palletAddress,374        },375      });376    });377  378    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {379      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();380      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);381      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);382  383      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;384  385      // Contract is self sponsored386      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({387        confirmed: {388          ethereum: flipper.options.address.toLowerCase(),389        },390      });391  392      // set promotion sponsoring393      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);394  395      // new sponsor is pallet address396      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  397      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  398      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({399        confirmed: {400          substrate: palletAddress,401        },402      });403    });404  405    itEth('can be overwritten by contract owner', async ({helper}) => {406      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();407      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);408      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);409  410      // contract sponsored by pallet411      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);412  413      // owner sets self sponsoring414      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;415  416      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  417      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  418      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({419        confirmed: {420          ethereum: flipper.options.address.toLowerCase(),421        },422      });423    });424  425    itEth('can not be set by non admin', async ({helper}) => {426      const nonAdmin = accounts.pop()!;427      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();428      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);429      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);430  431      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;432  433      // nonAdmin calls sponsorContract434      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');435  436      // contract still self-sponsored 437      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({438        confirmed: {439          ethereum: flipper.options.address.toLowerCase(),440        },441      });442    });443  444    itEth('should actually sponsor transactions', async ({helper}) => {445      // Contract caller446      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);447      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);448          449      // Deploy flipper450      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();451      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);452      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);453      454      // Owner sets to sponsor every tx455      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});456      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});457      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);458  459      // Set promotion to the Flipper460      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);461  462      // Caller calls Flipper463      await flipper.methods.flip().send({from: caller});464      expect(await flipper.methods.getValue().call()).to.be.true;465  466      // The contracts and caller balances have not changed467      const callerBalance = await helper.balance.getEthereum(caller);468      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);469      expect(callerBalance).to.be.equal(1000n * nominal);470      expect(1000n * nominal === contractBalanceAfter).to.be.true;471  472      // The pallet balance has decreased473      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);474      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;475    });476  });477  478  describe('stopSponsoringContract', () => {  479    itEth('should remove pallet address from contract sponsors', async ({helper}) => {480      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);481      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();482      const flipper = await helper.eth.deployFlipper(contractOwner);483      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);484      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);485  486      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});487      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);488      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);489  490      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  491      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  492      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({493        disabled: null,494      });495  496      await flipper.methods.flip().send({from: caller});497      expect(await flipper.methods.getValue().call()).to.be.true;498  499      const callerBalance = await helper.balance.getEthereum(caller);500      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);501  502      // caller payed for call503      expect(1000n * nominal > callerBalance).to.be.true;504      expect(contractBalanceAfter).to.be.equal(100n * nominal);505    });506  507    itEth('can not be called by non-admin', async ({helper}) => {508      const nonAdmin = accounts.pop()!;509      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();510      const flipper = await helper.eth.deployFlipper(contractOwner);511  512      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);513      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))514        .to.be.rejectedWith(/appPromotion\.NoPermission/);515    });516  517    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {518      const nonAdmin = accounts.pop()!;519      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();520      const flipper = await helper.eth.deployFlipper(contractOwner);521      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);522      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;523  524      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');525    });526  });527  528  describe('payoutStakers', () => {529    itSub('can not be called by non admin', async ({helper}) => {530      const nonAdmin = accounts.pop()!;531      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');532    });533  534    itSub('should increase total staked', async ({helper}) => {535      const staker = accounts.pop()!;536      const totalStakedBefore = await helper.staking.getTotalStaked();537      await helper.staking.stake(staker, 100n * nominal);538  539      // Wait for rewards and pay540      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});541      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));542      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);543  544      const totalStakedAfter = await helper.staking.getTotalStaked();545      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);546      // staker can unstake547      await helper.staking.unstake(staker);548      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal));549    });550  551    itSub('should credit 0.05% for staking period', async ({helper}) => {    552      const staker = accounts.pop()!;553  554      await waitPromotionPeriodDoesntEnd(helper);555        556      await helper.staking.stake(staker, 100n * nominal);557      await helper.staking.stake(staker, 200n * nominal);558  559      // wait rewards are available:560      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});561      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));562  563      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;564      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal));565  566      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});567      const income1 = calculateIncome(100n * nominal);568      const income2 = calculateIncome(200n * nominal);569      expect(totalStakedPerBlock[0].amount).to.equal(income1);570      expect(totalStakedPerBlock[1].amount).to.equal(income2);571572      const stakerBalance = await helper.balance.getSubstrateFull(staker.address);573      expect(stakerBalance).to.contain({miscFrozen: income1 + income2, feeFrozen: income1 + income2, reserved: 0n});574      expect(stakerBalance.free / nominal).to.eq(999n);575    });576  577    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {578      const staker = accounts.pop()!;579  580      await helper.staking.stake(staker, 100n * nominal);581      // wait for two rewards are available:582      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});583      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);584  585      await helper.admin.payoutStakers(palletAdmin, 100);586      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});587      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);588      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);589  590      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);591  592      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});593    });594    595    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {596      // staker unstakes before rewards has been payed597      const staker = accounts.pop()!;598      await helper.staking.stake(staker, 100n * nominal);599      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});600      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);601      await helper.staking.unstake(staker);602        603      // so he did not receive any rewards604      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);605      await helper.admin.payoutStakers(palletAdmin, 100);606      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);607  608      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);609    });610611    itSub('e2e: should not be credited for vested balance', async ({helper}) => {612      const [staker, sender] = [accounts.pop()!, accounts.pop()!];613      const VESTED_TRANSFER = 300n * nominal;614      const STAKE = 100n * nominal;615      // Arrange: Staker has frozen vested transfer of VESTED_TRANSFER tokens616      await helper.balance.vestedTransfer(sender, staker.address, {start: 1000n, period: 10n, periodCount: 1n, perPeriod: VESTED_TRANSFER});617      // Arrange: Staker has frozen stake of 100 tokens618      await helper.staking.stake(staker, STAKE);619      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});620621      // Assert: Staker's full balance inludes vested transfer and staked amount622      const stakerBalanceBefore = await helper.balance.getSubstrateFull(staker.address);623      expect(stakerBalanceBefore).to.contain({miscFrozen: VESTED_TRANSFER + STAKE, feeFrozen: VESTED_TRANSFER + STAKE, reserved: 0n});624      expect(stakerBalanceBefore.free / nominal).to.eq(1299n);625      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: STAKE, reasons: 'All'}, {id: 'ormlvest', amount: VESTED_TRANSFER, reasons: 'All'}]);626627      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));628      await helper.admin.payoutStakers(palletAdmin, 100);629      // Assert: Staker got reward only for {STAKE} staked tokens630      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});631      const income = calculateIncome(STAKE);632      expect(stake.amount).to.be.equal(income);633      // Assert: Frozen balance increased on {income} amount634      const stakerBalanceAfterReward = await helper.balance.getSubstrateFull(staker.address);635      expect(stakerBalanceAfterReward).to.contain({miscFrozen: VESTED_TRANSFER + income, feeFrozen: VESTED_TRANSFER + income, reserved: 0n});636      expect(stakerBalanceAfterReward.free > stakerBalanceBefore.free).to.be.true;637      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: income, reasons: 'All'}, {id: 'ormlvest', amount: VESTED_TRANSFER, reasons: 'All'}]);638639      // Act: Staker can claim:640      await helper.balance.claim(staker);641      // Assert: Staker's frozen balance reduced on {VESTED_TRANSFER} amount642      const stakerBalanceAfterClaim = await helper.balance.getSubstrateFull(staker.address);643      expect(stakerBalanceAfterClaim).to.contain({miscFrozen: income, feeFrozen: income, reserved: 0n});644      expect(stakerBalanceAfterClaim.free).to.eq(stakerBalanceAfterReward.free);645      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: income, reasons: 'All'}]);646647      // Act: Staker receives another vested transfer648      await helper.balance.vestedTransfer(sender, staker.address, {start: 1000n, period: 10n, periodCount: 1n, perPeriod: VESTED_TRANSFER});649      // Assert: vested transfer included in balance650      const stakerBalanceAfterSecondVestedTransfer = await helper.balance.getSubstrateFull(staker.address);651      expect(stakerBalanceAfterSecondVestedTransfer).to.contain({miscFrozen: VESTED_TRANSFER + income, feeFrozen: VESTED_TRANSFER + income, reserved: 0n});652      expect(stakerBalanceAfterSecondVestedTransfer.free / nominal).to.eq(1599n);653      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: income, reasons: 'All'}, {id: 'ormlvest', amount: VESTED_TRANSFER, reasons: 'All'}]);654655      // Act: Staker can unstake656      await helper.staking.unstake(staker);657      // Assert: Staker's frozen balance reduced on {income} amount658      const stakerBalanceAfterUnstake = await helper.balance.getSubstrateFull(staker.address);659      expect(stakerBalanceAfterUnstake).to.contain({miscFrozen: VESTED_TRANSFER, feeFrozen: VESTED_TRANSFER, reserved: income});660      expect(stakerBalanceAfterUnstake.free / nominal).to.eq(1599n);661      // FIXME: should remove app staking instantly or after unlocking period ends?662      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: income, reasons: 'All'}, {id: 'ormlvest', amount: VESTED_TRANSFER, reasons: 'All'}]);663      664      // Assert: Balance after unstaking period ends665      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});  666      await helper.wait.forParachainBlockNumber(pendingUnstake.block);667      const stakerBalanceAfterUnstakeFinished = await helper.balance.getSubstrateFull(staker.address);668      expect(stakerBalanceAfterUnstakeFinished).to.contain({miscFrozen: VESTED_TRANSFER, feeFrozen: VESTED_TRANSFER, reserved: 0n});669      expect(stakerBalanceAfterUnstakeFinished.free > stakerBalanceAfterUnstake.free).to.be.true;670      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'ormlvest', amount: VESTED_TRANSFER, reasons: 'All'}]);671    });672    673    itSub('should bring compound interest', async ({helper}) => {674      const staker = accounts.pop()!;675              676      await helper.staking.stake(staker, 100n * nominal);677  678      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});679      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));680        681      await helper.admin.payoutStakers(palletAdmin, 100);682      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});683      expect(stake.amount).to.equal(calculateIncome(100n * nominal));684        685      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);686      await helper.admin.payoutStakers(palletAdmin, 100);687      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});688      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 2));689    });690  691    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {692      // all other stakes should be unstaked693      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);694  695      // stakers stakes 10 times each696      for (let i = 0; i < 10; i++) {697        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));698      }699      await helper.wait.newBlocks(40);700      await helper.admin.payoutStakers(palletAdmin, 100);701    });702  703    itSub.skip('can handle 40.000 rewards', async ({helper}) => {704      const crowdStakes = async () => {705        // each account in the crowd stakes 2 times706        const crowd = await helper.arrange.createCrowd(500, 300n, donor);707        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));708        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));709        // 710      };711  712      for (let i = 0; i < 40; i++) {713        await crowdStakes();714      }715  716      // TODO pay rewards for some period717    });718  });719});720721function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {722  const DAY = 7200n;723  const ACCURACY = 1_000_000_000n;724  // 5n / 10_000n = 0.05% p/day725  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;726  727  if (iter > 1) {728    return calculateIncome(income, iter - 1, calcPeriod);729  } else return income;730}731732function rewardAvailableInBlock(stakedInBlock: bigint) {733  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;734  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);735}736737// Wait while promotion period less than specified block, to avoid boundary cases738// 0 if this should be the beginning of the period.739async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {740  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();741  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;742743  if (currentPeriodBlock > waitBlockLessThan) {744    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);745  }746}