git.delta.rocks / unique-network / refs/commits / 0f81eccfefee

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      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');55      56      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);57      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);58      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 59      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 60  61      62      await helper.staking.stake(staker, 200n * nominal);63      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);64      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});65      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);66      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);67    });68  69    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {70      const [staker] = await helper.arrange.createAccounts([2000n], donor);71      for (let i = 0; i < 10; i++) {72        await helper.staking.stake(staker, 100n * nominal);73      }74  75      // can have 10 stakes76      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);77      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);78  79      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');80  81      // After unstake can stake again82      await helper.staking.unstake(staker);83      await helper.staking.stake(staker, 100n * nominal);84      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);85    });86    87    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {88      const staker = accounts.pop()!;89  90      // Can't stake full balance because Alice needs to pay some fee91      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;92      await helper.staking.stake(staker, 500n * nominal);93  94      // Can't stake 500 tkn because Alice has Less than 500 transferable;95      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 96      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);97    });98    99    itSub('for different accounts in one block is possible', async ({helper}) => {100      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];101        102      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));103      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;104  105      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));106      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);107    });108  });109  110  describe('unstake extrinsic', () => {  111    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {112      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];113      const totalStakedBefore = await helper.staking.getTotalStaked();114      await helper.staking.stake(staker, 900n * nominal);115      await helper.staking.unstake(staker);116  117      // Right after unstake balance is reserved118      // Staker can not transfer 119      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});120      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');121      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);122      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);123      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);124    });125  126    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {127      const staker = accounts.pop()!;128      await helper.staking.stake(staker, 100n * nominal);129      await helper.staking.unstake(staker);130      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});131  132      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n133      await helper.wait.forParachainBlockNumber(pendingUnstake.block);134      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});135      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);136  137      // staker can transfer:138      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);139      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);140    });141  142    itSub('should successfully unstake multiple stakes', async ({helper}) => {143      const staker = accounts.pop()!;144      await helper.staking.stake(staker, 100n * nominal);145      await helper.staking.stake(staker, 200n * nominal);146      await helper.staking.stake(staker, 300n * nominal);147  148      // staked: [100, 200, 300]; unstaked: 0149      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});150      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});151      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});152      expect(totalPendingUnstake).to.be.deep.equal(0n);153      expect(pendingUnstake).to.be.deep.equal([]);154      expect(stakes[0].amount).to.equal(100n * nominal);155      expect(stakes[1].amount).to.equal(200n * nominal);156      expect(stakes[2].amount).to.equal(300n * nominal);157       158      // Can unstake multiple stakes159      await helper.staking.unstake(staker);160      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});161      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});162      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});163      expect(totalPendingUnstake).to.be.equal(600n * nominal);164      expect(stakes).to.be.deep.equal([]);165      expect(pendingUnstake[0].amount).to.equal(600n * nominal);166  167      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});168      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);169      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});170      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);171    });172  173    itSub('should not have any effects if no active stakes', async ({helper}) => {174      const staker = accounts.pop()!;175        176      // unstake has no effect if no stakes at all177      await helper.staking.unstake(staker);178      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);179      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper180  181      // TODO stake() unstake() waitUnstaked() unstake();182  183      // can't unstake if there are only pendingUnstakes184      await helper.staking.stake(staker, 100n * nominal);185      await helper.staking.unstake(staker);186      await helper.staking.unstake(staker);187  188      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);189      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);190    });191  192    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {193      const staker = accounts.pop()!;194      await helper.staking.stake(staker, 100n * nominal);195      await helper.staking.unstake(staker);196      await helper.staking.stake(staker, 120n * nominal);197      await helper.staking.unstake(staker);198  199      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});200      expect(unstakingPerBlock).has.length(2);201      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);202      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);203    });204  205    itSub('should be possible for different accounts in one block', async ({helper}) => {206      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];207  208      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));209      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));210  211      await Promise.all(stakers.map(async (staker) => {212        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);213        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);214      }));215    });216  });217  218  describe('collection sponsoring', () => {219    itSub('should actually sponsor transactions', async ({helper}) => {220      const api = helper.getApi();221      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];222      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});223      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});224      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));225      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);226  227      await token.transfer(tokenSender, {Substrate: receiver.address});228      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});229      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);230  231      // senders balance the same, transaction has sponsored232      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);233      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;234    });235  236    itSub('can not be set by non admin', async ({helper}) => {237      const api = helper.getApi();238      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];239  240      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});241        242      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;243      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');244    });245  246    itSub('should set pallet address as confirmed admin', async ({helper}) => {247      const api = helper.getApi();248      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];249        250      // Can set sponsoring for collection without sponsor251      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});252      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;253      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});254  255      // Can set sponsoring for collection with unconfirmed sponsor256      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});257      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});258      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;259      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});260  261      // Can set sponsoring for collection with confirmed sponsor262      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});263      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);264      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;265      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});266    });267  268    itSub('can be overwritten by collection owner', async ({helper}) => {    269      const api = helper.getApi();270      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];271      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});272      const collectionId = collection.collectionId;273        274      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;275        276      // Collection limits still can be changed by the owner277      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;278      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);279      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});280  281      // Collection sponsor can be changed too282      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;283      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});284    });285    286    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {287      const api = helper.getApi();288      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};289      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});290  291      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;292      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);293    });294    295    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {296      const api = helper.getApi();297      const collectionOwner = accounts.pop()!;298        299      // collection has never existed300      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;301      // collection has been burned302      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});303      await collection.burn(collectionOwner);304  305      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;306    });307  });308  309  describe('stopSponsoringCollection', () => {310    itSub('can not be called by non-admin', async ({helper}) => {311      const api = helper.getApi();312      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];313      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});314        315      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;316        317      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;318      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});319    });320  321    itSub('should set sponsoring as disabled', async ({helper}) => {322      const api = helper.getApi();323      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];324      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});325      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});326        327      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));328      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));329        330      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');331  332      // Transactions are not sponsored anymore:333      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);334      await token.transfer(collectionOwner, {Substrate: recepient.address});335      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);336      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);337    });338  339    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {340      const api = helper.getApi();341      const collectionOwner = accounts.pop()!;342      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});343      await collection.confirmSponsorship(collectionOwner);344        345      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;346        347      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});348    });349  350    itSub('should reject transaction if collection does not exist', async ({helper}) => {    351      const collectionOwner = accounts.pop()!;352      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});353        354      await collection.burn(collectionOwner);355      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');356      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');357    });358  });359  360  describe('contract sponsoring', () => {361    itEth('should set palletes address as a sponsor', async ({helper}) => {362      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();363      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);364      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);365  366      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);367      368      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  369      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  370      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({371        confirmed: {372          substrate: palletAddress,373        },374      });375    });376  377    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {378      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();379      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);380      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);381  382      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;383  384      // Contract is self sponsored385      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({386        confirmed: {387          ethereum: flipper.options.address.toLowerCase(),388        },389      });390  391      // set promotion sponsoring392      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);393  394      // new sponsor is pallet address395      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  396      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  397      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({398        confirmed: {399          substrate: palletAddress,400        },401      });402    });403  404    itEth('can be overwritten by contract owner', async ({helper}) => {405      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();406      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);407      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);408  409      // contract sponsored by pallet410      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);411  412      // owner sets self sponsoring413      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;414  415      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  416      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  417      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({418        confirmed: {419          ethereum: flipper.options.address.toLowerCase(),420        },421      });422    });423  424    itEth('can not be set by non admin', async ({helper}) => {425      const nonAdmin = accounts.pop()!;426      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();427      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);428      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);429  430      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;431  432      // nonAdmin calls sponsorContract433      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');434  435      // contract still self-sponsored 436      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({437        confirmed: {438          ethereum: flipper.options.address.toLowerCase(),439        },440      });441    });442  443    itEth('should actually sponsor transactions', async ({helper}) => {444      // Contract caller445      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);446      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);447          448      // Deploy flipper449      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();450      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);451      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);452      453      // Owner sets to sponsor every tx454      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});455      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});456      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);457  458      // Set promotion to the Flipper459      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);460  461      // Caller calls Flipper462      await flipper.methods.flip().send({from: caller});463      expect(await flipper.methods.getValue().call()).to.be.true;464  465      // The contracts and caller balances have not changed466      const callerBalance = await helper.balance.getEthereum(caller);467      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);468      expect(callerBalance).to.be.equal(1000n * nominal);469      expect(1000n * nominal === contractBalanceAfter).to.be.true;470  471      // The pallet balance has decreased472      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);473      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;474    });475  });476  477  describe('stopSponsoringContract', () => {  478    itEth('should remove pallet address from contract sponsors', async ({helper}) => {479      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);480      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();481      const flipper = await helper.eth.deployFlipper(contractOwner);482      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);483      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);484  485      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});486      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);487      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);488  489      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  490      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  491      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({492        disabled: null,493      });494  495      await flipper.methods.flip().send({from: caller});496      expect(await flipper.methods.getValue().call()).to.be.true;497  498      const callerBalance = await helper.balance.getEthereum(caller);499      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);500  501      // caller payed for call502      expect(1000n * nominal > callerBalance).to.be.true;503      expect(contractBalanceAfter).to.be.equal(100n * nominal);504    });505  506    itEth('can not be called by non-admin', async ({helper}) => {507      const nonAdmin = accounts.pop()!;508      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();509      const flipper = await helper.eth.deployFlipper(contractOwner);510  511      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);512      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))513        .to.be.rejectedWith(/appPromotion\.NoPermission/);514    });515  516    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {517      const nonAdmin = accounts.pop()!;518      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();519      const flipper = await helper.eth.deployFlipper(contractOwner);520      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);521      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;522  523      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');524    });525  });526  527  describe('payoutStakers', () => {528    itSub('can not be called by non admin', async ({helper}) => {529      const nonAdmin = accounts.pop()!;530      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');531    });532  533    itSub('should increase total staked', async ({helper}) => {534      const staker = accounts.pop()!;535      const totalStakedBefore = await helper.staking.getTotalStaked();536      await helper.staking.stake(staker, 100n * nominal);537  538      // Wait for rewards and pay539      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});540      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));541      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);542  543      const totalStakedAfter = await helper.staking.getTotalStaked();544      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);545      // staker can unstake546      await helper.staking.unstake(staker);547      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal));548    });549  550    itSub('should credit 0.05% for staking period', async ({helper}) => {    551      const staker = accounts.pop()!;552  553      await waitPromotionPeriodDoesntEnd(helper);554        555      await helper.staking.stake(staker, 100n * nominal);556      await helper.staking.stake(staker, 200n * nominal);557  558      // wait rewards are available:559      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});560      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));561  562      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;563      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal));564  565      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});566      const income1 = calculateIncome(100n * nominal);567      const income2 = calculateIncome(200n * nominal);568      expect(totalStakedPerBlock[0].amount).to.equal(income1);569      expect(totalStakedPerBlock[1].amount).to.equal(income2);570571      const stakerBalance = await helper.balance.getSubstrateFull(staker.address);572      expect(stakerBalance).to.contain({miscFrozen: income1 + income2, feeFrozen: income1 + income2, reserved: 0n});573      expect(stakerBalance.free / nominal).to.eq(999n);574    });575  576    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {577      const staker = accounts.pop()!;578  579      await helper.staking.stake(staker, 100n * nominal);580      // wait for two rewards are available:581      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});582      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);583  584      await helper.admin.payoutStakers(palletAdmin, 100);585      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});586      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);587      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);588  589      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);590  591      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});592    });593    594    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {595      // staker unstakes before rewards has been payed596      const staker = accounts.pop()!;597      await helper.staking.stake(staker, 100n * nominal);598      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});599      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);600      await helper.staking.unstake(staker);601        602      // so he did not receive any rewards603      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);604      await helper.admin.payoutStakers(palletAdmin, 100);605      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);606  607      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);608    });609610    itSub('e2e: should not be credited for vested balance', async ({helper}) => {611      const [staker, sender] = [accounts.pop()!, accounts.pop()!];612      const VESTED_TRANSFER = 300n * nominal;613      const STAKE = 100n * nominal;614      // Arrange: Staker has frozen vested transfer of VESTED_TRANSFER tokens615      await helper.balance.vestedTransfer(sender, staker.address, {start: 1000n, period: 10n, periodCount: 1n, perPeriod: VESTED_TRANSFER});616      // Arrange: Staker has frozen stake of 100 tokens617      await helper.staking.stake(staker, STAKE);618      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});619620      // Assert: Staker's full balance inludes vested transfer and staked amount621      const stakerBalanceBefore = await helper.balance.getSubstrateFull(staker.address);622      expect(stakerBalanceBefore).to.contain({miscFrozen: VESTED_TRANSFER + STAKE, feeFrozen: VESTED_TRANSFER + STAKE, reserved: 0n});623      expect(stakerBalanceBefore.free / nominal).to.eq(1299n);624625      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));626      await helper.admin.payoutStakers(palletAdmin, 100);627      // Assert: Staker got reward only for {STAKE} staked tokens628      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});629      const income = calculateIncome(STAKE);630      expect(stake.amount).to.be.equal(income);631      // Assert: Frozen balance increased on {income} amount632      const stakerBalanceAfterReward = await helper.balance.getSubstrateFull(staker.address);633      expect(stakerBalanceAfterReward).to.contain({miscFrozen: VESTED_TRANSFER + income, feeFrozen: VESTED_TRANSFER + income, reserved: 0n});634      expect(stakerBalanceAfterReward.free > stakerBalanceBefore.free).to.be.true;635636      // Act: Staker can claim:637      await helper.balance.claim(staker);638      // Assert: Staker's frozen balance reduced on {VESTED_TRANSFER} amount639      const stakerBalanceAfterClaim = await helper.balance.getSubstrateFull(staker.address);640      expect(stakerBalanceAfterClaim).to.contain({miscFrozen: income, feeFrozen: income, reserved: 0n});641      expect(stakerBalanceAfterClaim.free).to.eq(stakerBalanceAfterReward.free);642643      // Act: Staker receives another vested transfer644      await helper.balance.vestedTransfer(sender, staker.address, {start: 1000n, period: 10n, periodCount: 1n, perPeriod: VESTED_TRANSFER});645      // Assert: vested transfer included in balance646      const stakerBalanceAfterSecondVestedTransfer = await helper.balance.getSubstrateFull(staker.address);647      expect(stakerBalanceAfterSecondVestedTransfer).to.contain({miscFrozen: VESTED_TRANSFER + income, feeFrozen: VESTED_TRANSFER + income, reserved: 0n});648      expect(stakerBalanceAfterSecondVestedTransfer.free / nominal).to.eq(1599n);649650      // Act: Staker can unstake651      await helper.staking.unstake(staker);652      // Assert: Staker's frozen balance reduced on {income} amount653      const stakerBalanceAfterUnstake = await helper.balance.getSubstrateFull(staker.address);654      expect(stakerBalanceAfterUnstake).to.contain({miscFrozen: VESTED_TRANSFER, feeFrozen: VESTED_TRANSFER, reserved: income});655      expect(stakerBalanceAfterUnstake.free / nominal).to.eq(1599n);656      // Assert: Balance after unstaking period ends657      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});  658      await helper.wait.forParachainBlockNumber(pendingUnstake.block);659      const stakerBalanceAfterUnstakeFinished = await helper.balance.getSubstrateFull(staker.address);660      expect(stakerBalanceAfterUnstakeFinished).to.contain({miscFrozen: VESTED_TRANSFER, feeFrozen: VESTED_TRANSFER, reserved: 0n});661      expect(stakerBalanceAfterUnstakeFinished.free > stakerBalanceAfterUnstake.free).to.be.true;662    });663    664    itSub('should bring compound interest', async ({helper}) => {665      const staker = accounts.pop()!;666              667      await helper.staking.stake(staker, 100n * nominal);668  669      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});670      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));671        672      await helper.admin.payoutStakers(palletAdmin, 100);673      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});674      expect(stake.amount).to.equal(calculateIncome(100n * nominal));675        676      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);677      await helper.admin.payoutStakers(palletAdmin, 100);678      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});679      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 2));680    });681  682    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {683      // all other stakes should be unstaked684      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);685  686      // stakers stakes 10 times each687      for (let i = 0; i < 10; i++) {688        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));689      }690      await helper.wait.newBlocks(40);691      await helper.admin.payoutStakers(palletAdmin, 100);692    });693  694    itSub.skip('can handle 40.000 rewards', async ({helper}) => {695      const crowdStakes = async () => {696        // each account in the crowd stakes 2 times697        const crowd = await helper.arrange.createCrowd(500, 300n, donor);698        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));699        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));700        // 701      };702  703      for (let i = 0; i < 40; i++) {704        await crowdStakes();705      }706  707      // TODO pay rewards for some period708    });709  });710});711712function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {713  const DAY = 7200n;714  const ACCURACY = 1_000_000_000n;715  // 5n / 10_000n = 0.05% p/day716  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;717  718  if (iter > 1) {719    return calculateIncome(income, iter - 1, calcPeriod);720  } else return income;721}722723function rewardAvailableInBlock(stakedInBlock: bigint) {724  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;725  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);726}727728// Wait while promotion period less than specified block, to avoid boundary cases729// 0 if this should be the beginning of the period.730async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {731  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();732  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;733734  if (currentPeriodBlock > waitBlockLessThan) {735    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);736  }737}