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

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('rewards', () => {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      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal));567      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal));568    });569  570    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {571      const staker = accounts.pop()!;572  573      await helper.staking.stake(staker, 100n * nominal);574      // wait for two rewards are available:575      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});576      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);577  578      await helper.admin.payoutStakers(palletAdmin, 100);579      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});580      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);581      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);582  583      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);584  585      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});586    });587    588    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {589      // staker unstakes before rewards has been payed590      const staker = accounts.pop()!;591      await helper.staking.stake(staker, 100n * nominal);592      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});593      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);594      await helper.staking.unstake(staker);595        596      // so he did not receive any rewards597      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);598      await helper.admin.payoutStakers(palletAdmin, 100);599      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);600  601      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);602    });603    604    itSub('should bring compound interest', async ({helper}) => {605      const staker = accounts.pop()!;606              607      await helper.staking.stake(staker, 100n * nominal);608  609      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});610      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));611        612      await helper.admin.payoutStakers(palletAdmin, 100);613      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});614      expect(stake.amount).to.equal(calculateIncome(100n * nominal));615        616      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);617      await helper.admin.payoutStakers(palletAdmin, 100);618      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});619      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 2));620    });621  622    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {623      // all other stakes should be unstaked624      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);625  626      // stakers stakes 10 times each627      for (let i = 0; i < 10; i++) {628        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));629      }630      await helper.wait.newBlocks(40);631      await helper.admin.payoutStakers(palletAdmin, 100);632    });633  634    itSub.skip('can handle 40.000 rewards', async ({helper}) => {635      const crowdStakes = async () => {636        // each account in the crowd stakes 2 times637        const crowd = await helper.arrange.createCrowd(500, 300n, donor);638        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));639        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));640        // 641      };642  643      for (let i = 0; i < 40; i++) {644        await crowdStakes();645      }646  647      // TODO pay rewards for some period648    });649  });650});651652function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {653  const DAY = 7200n;654  const ACCURACY = 1_000_000_000n;655  // 5n / 10_000n = 0.05% p/day656  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;657  658  if (iter > 1) {659    return calculateIncome(income, iter - 1, calcPeriod);660  } else return income;661}662663function rewardAvailableInBlock(stakedInBlock: bigint) {664  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;665  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);666}667668// Wait while promotion period less than specified block, to avoid boundary cases669// 0 if this should be the beginning of the period.670async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {671  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();672  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;673674  if (currentPeriodBlock > waitBlockLessThan) {675    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);676  }677}