git.delta.rocks / unique-network / refs/commits / 6afd9fe97b2d

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 = 20n; // 20 blocks of relay28const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain29const rewardAvailableInBlock = (stakedInBlock: bigint) => {30  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + 20n;31  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);32};3334describe('App promotion', () => {35  before(async function () {36    await usingPlaygrounds(async (helper, privateKey) => {37      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);38      donor = await privateKey({filename: __filename});39      palletAddress = helper.arrange.calculatePalletAddress('appstake');40      palletAdmin = await privateKey('//PromotionAdmin');41      nominal = helper.balance.getOneTokenNominal();42      accounts = await helper.arrange.createCrowd(100, 1000n, donor); // create accounts-pool to speed up tests43    });44  });4546  describe('stake extrinsic', () => {  47    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {48      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];49      const totalStakedBefore = await helper.staking.getTotalStaked();50  51      // Minimum stake amount is 100:52      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;53      await helper.staking.stake(staker, 100n * nominal);54  55      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...56      // ...so he can not transfer 90057      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});58      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');59      60      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);61      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);62      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 63      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 64  65      66      await helper.staking.stake(staker, 200n * nominal);67      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);68      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});69      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);70      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);71    });72  73    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {74      const [staker] = await helper.arrange.createAccounts([2000n], donor);75      for (let i = 0; i < 10; i++) {76        await helper.staking.stake(staker, 100n * nominal);77      }78  79      // can have 10 stakes80      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);81      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);82  83      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');84  85      // After unstake can stake again86      await helper.staking.unstake(staker);87      await helper.staking.stake(staker, 100n * nominal);88      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);89    });90    91    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {92      const staker = accounts.pop()!;93  94      // Can't stake full balance because Alice needs to pay some fee95      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;96      await helper.staking.stake(staker, 500n * nominal);97  98      // Can't stake 500 tkn because Alice has Less than 500 transferable;99      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 100      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);101    });102    103    itSub('for different accounts in one block is possible', async ({helper}) => {104      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];105        106      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));107      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;108  109      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));110      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);111    });112  });113  114  describe('unstake extrinsic', () => {  115    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {116      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];117      const totalStakedBefore = await helper.staking.getTotalStaked();118      await helper.staking.stake(staker, 900n * nominal);119      await helper.staking.unstake(staker);120  121      // Right after unstake balance is reserved122      // Staker can not transfer 123      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});124      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');125      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);126      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);127      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);128    });129  130    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {131      const staker = accounts.pop()!;132      await helper.staking.stake(staker, 100n * nominal);133      await helper.staking.unstake(staker);134      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});135  136      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n137      await helper.wait.forParachainBlockNumber(pendingUnstake.block);138      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});139      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);140  141      // staker can transfer:142      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);143      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);144    });145  146    itSub('should successfully unstake multiple stakes', async ({helper}) => {147      const staker = accounts.pop()!;148      await helper.staking.stake(staker, 100n * nominal);149      await helper.staking.stake(staker, 200n * nominal);150      await helper.staking.stake(staker, 300n * nominal);151  152      // staked: [100, 200, 300]; unstaked: 0153      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});154      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});155      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});156      expect(totalPendingUnstake).to.be.deep.equal(0n);157      expect(pendingUnstake).to.be.deep.equal([]);158      expect(stakes[0].amount).to.equal(100n * nominal);159      expect(stakes[1].amount).to.equal(200n * nominal);160      expect(stakes[2].amount).to.equal(300n * nominal);161       162      // Can unstake multiple stakes163      await helper.staking.unstake(staker);164      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});165      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});166      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});167      expect(totalPendingUnstake).to.be.equal(600n * nominal);168      expect(stakes).to.be.deep.equal([]);169      expect(pendingUnstake[0].amount).to.equal(600n * nominal);170  171      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});172      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);173      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});174      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);175    });176  177    itSub('should not have any effects if no active stakes', async ({helper}) => {178      const staker = accounts.pop()!;179        180      // unstake has no effect if no stakes at all181      await helper.staking.unstake(staker);182      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);183      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper184  185      // TODO stake() unstake() waitUnstaked() unstake();186  187      // can't unstake if there are only pendingUnstakes188      await helper.staking.stake(staker, 100n * nominal);189      await helper.staking.unstake(staker);190      await helper.staking.unstake(staker);191  192      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);193      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);194    });195  196    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {197      const staker = accounts.pop()!;198      await helper.staking.stake(staker, 100n * nominal);199      await helper.staking.unstake(staker);200      await helper.staking.stake(staker, 120n * nominal);201      await helper.staking.unstake(staker);202  203      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});204      expect(unstakingPerBlock).has.length(2);205      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);206      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);207    });208  209    itSub('should be possible for different accounts in one block', async ({helper}) => {210      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];211  212      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));213      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));214  215      await Promise.all(stakers.map(async (staker) => {216        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);217        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);218      }));219    });220  });221  222  describe('collection sponsoring', () => {223    itSub('should actually sponsor transactions', async ({helper}) => {224      const api = helper.getApi();225      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];226      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});227      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});228      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));229      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);230  231      await token.transfer(tokenSender, {Substrate: receiver.address});232      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});233      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);234  235      // senders balance the same, transaction has sponsored236      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);237      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;238    });239  240    itSub('can not be set by non admin', async ({helper}) => {241      const api = helper.getApi();242      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];243  244      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});245        246      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;247      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');248    });249  250    itSub('should set pallet address as confirmed admin', async ({helper}) => {251      const api = helper.getApi();252      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];253        254      // Can set sponsoring for collection without sponsor255      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});256      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;257      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});258  259      // Can set sponsoring for collection with unconfirmed sponsor260      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});261      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});262      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;263      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});264  265      // Can set sponsoring for collection with confirmed sponsor266      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});267      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);268      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;269      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});270    });271  272    itSub('can be overwritten by collection owner', async ({helper}) => {    273      const api = helper.getApi();274      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];275      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});276      const collectionId = collection.collectionId;277        278      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;279        280      // Collection limits still can be changed by the owner281      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;282      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);283      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});284  285      // Collection sponsor can be changed too286      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;287      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});288    });289    290    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {291      const api = helper.getApi();292      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};293      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});294  295      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;296      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);297    });298    299    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {300      const api = helper.getApi();301      const collectionOwner = accounts.pop()!;302        303      // collection has never existed304      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;305      // collection has been burned306      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});307      await collection.burn(collectionOwner);308  309      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;310    });311  });312  313  describe('stopSponsoringCollection', () => {314    itSub('can not be called by non-admin', async ({helper}) => {315      const api = helper.getApi();316      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];317      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});318        319      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;320        321      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;322      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});323    });324  325    itSub('should set sponsoring as disabled', async ({helper}) => {326      const api = helper.getApi();327      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];328      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});329      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});330        331      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));332      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));333        334      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');335  336      // Transactions are not sponsored anymore:337      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);338      await token.transfer(collectionOwner, {Substrate: recepient.address});339      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);340      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);341    });342  343    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {344      const api = helper.getApi();345      const collectionOwner = accounts.pop()!;346      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});347      await collection.confirmSponsorship(collectionOwner);348        349      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;350        351      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});352    });353  354    itSub('should reject transaction if collection does not exist', async ({helper}) => {    355      const collectionOwner = accounts.pop()!;356      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});357        358      await collection.burn(collectionOwner);359      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');360      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');361    });362  });363  364  describe('contract sponsoring', () => {365    itEth('should set palletes address as a sponsor', async ({helper}) => {366      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();367      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);368      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);369  370      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);371      372      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  373      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  374      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({375        confirmed: {376          substrate: palletAddress,377        },378      });379    });380  381    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {382      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();383      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);384      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);385  386      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;387  388      // Contract is self sponsored389      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({390        confirmed: {391          ethereum: flipper.options.address.toLowerCase(),392        },393      });394  395      // set promotion sponsoring396      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);397  398      // new sponsor is pallet address399      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  400      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  401      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({402        confirmed: {403          substrate: palletAddress,404        },405      });406    });407  408    itEth('can be overwritten by contract owner', async ({helper}) => {409      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();410      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);411      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);412  413      // contract sponsored by pallet414      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);415  416      // owner sets self sponsoring417      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;418  419      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  420      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  421      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({422        confirmed: {423          ethereum: flipper.options.address.toLowerCase(),424        },425      });426    });427  428    itEth('can not be set by non admin', async ({helper}) => {429      const nonAdmin = accounts.pop()!;430      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();431      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);432      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);433  434      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;435  436      // nonAdmin calls sponsorContract437      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');438  439      // contract still self-sponsored 440      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({441        confirmed: {442          ethereum: flipper.options.address.toLowerCase(),443        },444      });445    });446  447    itEth('should actually sponsor transactions', async ({helper}) => {448      // Contract caller449      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);450      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);451          452      // Deploy flipper453      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();454      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);455      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);456      457      // Owner sets to sponsor every tx458      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});459      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});460      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);461  462      // Set promotion to the Flipper463      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);464  465      // Caller calls Flipper466      await flipper.methods.flip().send({from: caller});467      expect(await flipper.methods.getValue().call()).to.be.true;468  469      // The contracts and caller balances have not changed470      const callerBalance = await helper.balance.getEthereum(caller);471      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);472      expect(callerBalance).to.be.equal(1000n * nominal);473      expect(1000n * nominal === contractBalanceAfter).to.be.true;474  475      // The pallet balance has decreased476      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);477      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;478    });479  });480  481  describe('stopSponsoringContract', () => {  482    itEth('should remove pallet address from contract sponsors', async ({helper}) => {483      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);484      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();485      const flipper = await helper.eth.deployFlipper(contractOwner);486      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);487      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);488  489      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});490      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);491      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);492  493      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  494      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  495      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({496        disabled: null,497      });498  499      await flipper.methods.flip().send({from: caller});500      expect(await flipper.methods.getValue().call()).to.be.true;501  502      const callerBalance = await helper.balance.getEthereum(caller);503      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);504  505      // caller payed for call506      expect(1000n * nominal > callerBalance).to.be.true;507      expect(contractBalanceAfter).to.be.equal(100n * nominal);508    });509  510    itEth('can not be called by non-admin', async ({helper}) => {511      const nonAdmin = accounts.pop()!;512      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();513      const flipper = await helper.eth.deployFlipper(contractOwner);514  515      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);516      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))517        .to.be.rejectedWith(/appPromotion\.NoPermission/);518    });519  520    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {521      const nonAdmin = accounts.pop()!;522      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();523      const flipper = await helper.eth.deployFlipper(contractOwner);524      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);525      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;526  527      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');528    });529  });530  531  describe('rewards', () => {532    itSub('can not be called by non admin', async ({helper}) => {533      const nonAdmin = accounts.pop()!;534      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');535    });536  537    itSub('should increase total staked', async ({helper}) => {538      const staker = accounts.pop()!;539      const totalStakedBefore = await helper.staking.getTotalStaked();540      await helper.staking.stake(staker, 100n * nominal);541  542      // Wait for rewards and pay543      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});544      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));545      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);546  547      const totalStakedAfter = await helper.staking.getTotalStaked();548      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);549      // staker can unstake550      await helper.staking.unstake(staker);551      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));552    });553  554    itSub('should credit 0.05% for staking period', async ({helper}) => {    555      const staker = accounts.pop()!;556  557      await waitPromotionPeriodDoesntEnd(helper);558        559      await helper.staking.stake(staker, 100n * nominal);560      await helper.staking.stake(staker, 200n * nominal);561  562      // wait rewards are available:563      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});564      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));565  566      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;567      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));568  569      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});570      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));571      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));572    });573  574    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {575      const staker = accounts.pop()!;576  577      await helper.staking.stake(staker, 100n * nominal);578      // wait for two rewards are available:579      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});580      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);581  582      await helper.admin.payoutStakers(palletAdmin, 100);583      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});584      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);585      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);586  587      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);588  589      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});590    });591    592    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {593      // staker unstakes before rewards has been payed594      const staker = accounts.pop()!;595      await helper.staking.stake(staker, 100n * nominal);596      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});597      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);598      await helper.staking.unstake(staker);599        600      // so he did not receive any rewards601      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);602      await helper.admin.payoutStakers(palletAdmin, 100);603      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);604  605      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);606    });607    608    itSub('should bring compound interest', async ({helper}) => {609      const staker = accounts.pop()!;610              611      await helper.staking.stake(staker, 100n * nominal);612  613      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});614      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));615        616      await helper.admin.payoutStakers(palletAdmin, 100);617      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});618      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));619        620      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);621      await helper.admin.payoutStakers(palletAdmin, 100);622      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});623      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));624    });625  626    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {627      // all other stakes should be unstaked628      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);629  630      // stakers stakes 10 times each631      for (let i = 0; i < 10; i++) {632        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));633      }634      await helper.wait.newBlocks(40);635      await helper.admin.payoutStakers(palletAdmin, 100);636    });637  638    itSub.skip('can handle 40.000 rewards', async ({helper}) => {639      const crowdStakes = async () => {640        // each account in the crowd stakes 2 times641        const crowd = await helper.arrange.createCrowd(500, 300n, donor);642        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));643        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));644        // 645      };646  647      for (let i = 0; i < 40; i++) {648        await crowdStakes();649      }650  651      // TODO pay rewards for some period652    });653  });654});655656function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {657  const DAY = 7200n;658  const ACCURACY = 1_000_000_000n;659  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;660  661  if (iter > 1) {662    return calculateIncome(income, calcPeriod, iter - 1);663  } else return income;664}665666// Wait while promotion period less than specified block, to avoid boundary cases667// 0 if this should be the beginning of the period.668async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {669  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();670  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;671672  if (currentPeriodBlock > waitBlockLessThan) {673    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);674  }675}