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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import {19  itSub, usingPlaygrounds, Pallets, requirePalletsOrSkip, LOCKING_PERIOD, UNLOCKING_PERIOD,20} from './util';21import {DevUniqueHelper} from './util/playgrounds/unique.dev';22import {itEth, expect, SponsoringMode} from './eth/util';2324let donor: IKeyringPair;25let palletAdmin: IKeyringPair;26let nominal: bigint;27let palletAddress: string;28let accounts: IKeyringPair[];29// App promotion periods:30// LOCKING_PERIOD = 12 blocks of relay31// UNLOCKING_PERIOD = 6 blocks of parachain3233describe('App promotion', () => {34  before(async function () {35    await usingPlaygrounds(async (helper, privateKey) => {36      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);37      donor = await privateKey({filename: __filename});38      palletAddress = helper.arrange.calculatePalletAddress('appstake');39      palletAdmin = await privateKey('//PromotionAdmin');40      nominal = helper.balance.getOneTokenNominal();4142      const accountBalances = new Array(100);43      accountBalances.fill(1000n);44      accounts = await helper.arrange.createAccounts(accountBalances, donor); // create accounts-pool to speed up tests45    });46  });4748  describe('stake extrinsic', () => {  49    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {50      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];51      const totalStakedBefore = await helper.staking.getTotalStaked();52  53      // Minimum stake amount is 100:54      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;55      await helper.staking.stake(staker, 100n * nominal);56  57      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...58      // ...so he can not transfer 90059      expect(await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});60      expect(await helper.balance.getLocked(staker.address)).to.deep.eq([{id: 'appstake', amount: 100n * nominal, reasons: 'All'}]);61      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');62      63      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);64      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);65      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 66      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 67  68      69      await helper.staking.stake(staker, 200n * nominal);70      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);71      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});72      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);73      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);74    });75  76    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {77      const [staker] = await helper.arrange.createAccounts([2000n], donor);78      for (let i = 0; i < 10; i++) {79        await helper.staking.stake(staker, 100n * nominal);80      }81  82      // can have 10 stakes83      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);84      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);85  86      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');87  88      // After unstake can stake again89      await helper.staking.unstake(staker);90      await helper.staking.stake(staker, 100n * nominal);91      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);92    });93    94    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {95      const staker = accounts.pop()!;96  97      // Can't stake full balance because Alice needs to pay some fee98      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;99      await helper.staking.stake(staker, 500n * nominal);100  101      // Can't stake 500 tkn because Alice has Less than 500 transferable;102      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 103      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);104    });105    106    itSub('for different accounts in one block is possible', async ({helper}) => {107      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];108        109      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));110      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;111  112      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));113      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);114    });115  });116  117  describe('unstake extrinsic', () => {  118    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {119      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];120      const totalStakedBefore = await helper.staking.getTotalStaked();121      await helper.staking.stake(staker, 900n * nominal);122      await helper.staking.unstake(staker);123  124      // Right after unstake balance is reserved125      // Staker can not transfer 126      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});127      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');128      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);129      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);130      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);131    });132  133    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {134      const staker = accounts.pop()!;135      await helper.staking.stake(staker, 100n * nominal);136      await helper.staking.unstake(staker);137      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});138  139      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n140      await helper.wait.forParachainBlockNumber(pendingUnstake.block);141      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});142      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);143  144      // staker can transfer:145      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);146      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);147    });148  149    itSub('should successfully unstake multiple stakes', async ({helper}) => {150      const staker = accounts.pop()!;151      await helper.staking.stake(staker, 100n * nominal);152      await helper.staking.stake(staker, 200n * nominal);153      await helper.staking.stake(staker, 300n * nominal);154  155      // staked: [100, 200, 300]; unstaked: 0156      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});157      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});158      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});159      expect(totalPendingUnstake).to.be.deep.equal(0n);160      expect(pendingUnstake).to.be.deep.equal([]);161      expect(stakes[0].amount).to.equal(100n * nominal);162      expect(stakes[1].amount).to.equal(200n * nominal);163      expect(stakes[2].amount).to.equal(300n * nominal);164       165      // Can unstake multiple stakes166      await helper.staking.unstake(staker);167      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});168      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});169      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});170      expect(totalPendingUnstake).to.be.equal(600n * nominal);171      expect(stakes).to.be.deep.equal([]);172      expect(pendingUnstake[0].amount).to.equal(600n * nominal);173  174      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});175      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);176      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});177      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);178    });179  180    itSub('should not have any effects if no active stakes', async ({helper}) => {181      const staker = accounts.pop()!;182        183      // unstake has no effect if no stakes at all184      await helper.staking.unstake(staker);185      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);186      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper187  188      // TODO stake() unstake() waitUnstaked() unstake();189  190      // can't unstake if there are only pendingUnstakes191      await helper.staking.stake(staker, 100n * nominal);192      await helper.staking.unstake(staker);193      await helper.staking.unstake(staker);194  195      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);196      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);197    });198  199    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {200      const staker = accounts.pop()!;201      await helper.staking.stake(staker, 100n * nominal);202      await helper.staking.unstake(staker);203      await helper.staking.stake(staker, 120n * nominal);204      await helper.staking.unstake(staker);205  206      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});207      expect(unstakingPerBlock).has.length(2);208      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);209      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);210    });211  212    itSub('should be possible for different accounts in one block', async ({helper}) => {213      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];214  215      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));216      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));217  218      await Promise.all(stakers.map(async (staker) => {219        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);220        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);221      }));222    });223  });224  225  describe('collection sponsoring', () => {226    itSub('should actually sponsor transactions', async ({helper}) => {227      const api = helper.getApi();228      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];229      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});230      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});231      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));232      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);233  234      await token.transfer(tokenSender, {Substrate: receiver.address});235      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});236      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);237  238      // senders balance the same, transaction has sponsored239      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);240      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;241    });242  243    itSub('can not be set by non admin', async ({helper}) => {244      const api = helper.getApi();245      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];246  247      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});248        249      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;250      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');251    });252  253    itSub('should set pallet address as confirmed admin', async ({helper}) => {254      const api = helper.getApi();255      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];256        257      // Can set sponsoring for collection without sponsor258      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});259      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;260      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});261  262      // Can set sponsoring for collection with unconfirmed sponsor263      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});264      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});265      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;266      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});267  268      // Can set sponsoring for collection with confirmed sponsor269      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});270      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);271      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;272      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});273    });274  275    itSub('can be overwritten by collection owner', async ({helper}) => {    276      const api = helper.getApi();277      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];278      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});279      const collectionId = collection.collectionId;280        281      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;282        283      // Collection limits still can be changed by the owner284      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;285      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);286      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});287  288      // Collection sponsor can be changed too289      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;290      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});291    });292    293    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {294      const api = helper.getApi();295      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};296      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});297  298      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;299      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);300    });301    302    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {303      const api = helper.getApi();304      const collectionOwner = accounts.pop()!;305        306      // collection has never existed307      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;308      // collection has been burned309      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});310      await collection.burn(collectionOwner);311  312      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;313    });314  });315  316  describe('stopSponsoringCollection', () => {317    itSub('can not be called by non-admin', async ({helper}) => {318      const api = helper.getApi();319      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];320      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});321        322      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;323        324      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;325      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});326    });327  328    itSub('should set sponsoring as disabled', async ({helper}) => {329      const api = helper.getApi();330      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];331      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});332      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});333        334      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));335      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));336        337      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');338  339      // Transactions are not sponsored anymore:340      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);341      await token.transfer(collectionOwner, {Substrate: recepient.address});342      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);343      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);344    });345  346    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {347      const api = helper.getApi();348      const collectionOwner = accounts.pop()!;349      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});350      await collection.confirmSponsorship(collectionOwner);351        352      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;353        354      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});355    });356  357    itSub('should reject transaction if collection does not exist', async ({helper}) => {    358      const collectionOwner = accounts.pop()!;359      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});360        361      await collection.burn(collectionOwner);362      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');363      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');364    });365  });366  367  describe('contract sponsoring', () => {368    itEth('should set palletes address as a sponsor', async ({helper}) => {369      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();370      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);371      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);372  373      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);374      375      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  376      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  377      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({378        confirmed: {379          substrate: palletAddress,380        },381      });382    });383  384    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {385      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();386      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);387      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);388  389      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;390  391      // Contract is self sponsored392      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({393        confirmed: {394          ethereum: flipper.options.address.toLowerCase(),395        },396      });397  398      // set promotion sponsoring399      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);400  401      // new sponsor is pallet address402      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  403      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  404      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({405        confirmed: {406          substrate: palletAddress,407        },408      });409    });410  411    itEth('can be overwritten by contract owner', async ({helper}) => {412      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();413      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);414      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);415  416      // contract sponsored by pallet417      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);418  419      // owner sets self sponsoring420      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;421  422      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  423      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  424      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({425        confirmed: {426          ethereum: flipper.options.address.toLowerCase(),427        },428      });429    });430  431    itEth('can not be set by non admin', async ({helper}) => {432      const nonAdmin = accounts.pop()!;433      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();434      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);435      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);436  437      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;438  439      // nonAdmin calls sponsorContract440      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');441  442      // contract still self-sponsored 443      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({444        confirmed: {445          ethereum: flipper.options.address.toLowerCase(),446        },447      });448    });449  450    itEth('should actually sponsor transactions', async ({helper}) => {451      // Contract caller452      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);453      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);454          455      // Deploy flipper456      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();457      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);458      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);459      460      // Owner sets to sponsor every tx461      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});462      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});463      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);464  465      // Set promotion to the Flipper466      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);467  468      // Caller calls Flipper469      await flipper.methods.flip().send({from: caller});470      expect(await flipper.methods.getValue().call()).to.be.true;471  472      // The contracts and caller balances have not changed473      const callerBalance = await helper.balance.getEthereum(caller);474      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);475      expect(callerBalance).to.be.equal(1000n * nominal);476      expect(1000n * nominal === contractBalanceAfter).to.be.true;477  478      // The pallet balance has decreased479      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);480      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;481    });482  });483  484  describe('stopSponsoringContract', () => {  485    itEth('should remove pallet address from contract sponsors', async ({helper}) => {486      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);487      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();488      const flipper = await helper.eth.deployFlipper(contractOwner);489      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);490      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);491  492      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});493      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);494      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);495  496      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  497      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  498      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({499        disabled: null,500      });501  502      await flipper.methods.flip().send({from: caller});503      expect(await flipper.methods.getValue().call()).to.be.true;504  505      const callerBalance = await helper.balance.getEthereum(caller);506      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);507  508      // caller payed for call509      expect(1000n * nominal > callerBalance).to.be.true;510      expect(contractBalanceAfter).to.be.equal(100n * nominal);511    });512  513    itEth('can not be called by non-admin', async ({helper}) => {514      const nonAdmin = accounts.pop()!;515      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();516      const flipper = await helper.eth.deployFlipper(contractOwner);517  518      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);519      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))520        .to.be.rejectedWith(/appPromotion\.NoPermission/);521    });522  523    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {524      const nonAdmin = accounts.pop()!;525      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();526      const flipper = await helper.eth.deployFlipper(contractOwner);527      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);528      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;529  530      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');531    });532  });533  534  describe('payoutStakers', () => {535    itSub('can not be called by non admin', async ({helper}) => {536      const nonAdmin = accounts.pop()!;537      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');538    });539  540    itSub('should increase total staked', async ({helper}) => {541      const staker = accounts.pop()!;542      const totalStakedBefore = await helper.staking.getTotalStaked();543      await helper.staking.stake(staker, 100n * nominal);544  545      // Wait for rewards and pay546      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});547      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));548      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);549  550      const totalStakedAfter = await helper.staking.getTotalStaked();551      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);552      // staker can unstake553      await helper.staking.unstake(staker);554      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal));555    });556  557    itSub('should credit 0.05% for staking period', async ({helper}) => {    558      const staker = accounts.pop()!;559  560      await waitPromotionPeriodDoesntEnd(helper);561        562      await helper.staking.stake(staker, 100n * nominal);563      await helper.staking.stake(staker, 200n * nominal);564  565      // wait rewards are available:566      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});567      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));568  569      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;570      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal));571  572      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});573      const income1 = calculateIncome(100n * nominal);574      const income2 = calculateIncome(200n * nominal);575      expect(totalStakedPerBlock[0].amount).to.equal(income1);576      expect(totalStakedPerBlock[1].amount).to.equal(income2);577578      const stakerBalance = await helper.balance.getSubstrateFull(staker.address);579      expect(stakerBalance).to.contain({miscFrozen: income1 + income2, feeFrozen: income1 + income2, reserved: 0n});580      expect(stakerBalance.free / nominal).to.eq(999n);581    });582  583    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {584      const staker = accounts.pop()!;585  586      await helper.staking.stake(staker, 100n * nominal);587      // wait for two rewards are available:588      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});589      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);590  591      await helper.admin.payoutStakers(palletAdmin, 100);592      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});593      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 2);594      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);595  596      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);597  598      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});599    });600    601    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {602      // staker unstakes before rewards has been payed603      const staker = accounts.pop()!;604      await helper.staking.stake(staker, 100n * nominal);605      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});606      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);607      await helper.staking.unstake(staker);608        609      // so he did not receive any rewards610      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);611      await helper.admin.payoutStakers(palletAdmin, 100);612      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);613  614      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);615    });616    617    itSub('should bring compound interest', async ({helper}) => {618      const staker = accounts.pop()!;619              620      await helper.staking.stake(staker, 100n * nominal);621  622      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});623      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));624        625      await helper.admin.payoutStakers(palletAdmin, 100);626      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});627      expect(stake.amount).to.equal(calculateIncome(100n * nominal));628        629      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);630      await helper.admin.payoutStakers(palletAdmin, 100);631      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});632      expect(stake.amount).to.equal(calculateIncome(100n * nominal, 2));633    });634  635    itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {636      // all other stakes should be unstaked637      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, donor);638  639      // stakers stakes 10 times each640      for (let i = 0; i < 10; i++) {641        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));642      }643      await helper.wait.newBlocks(40);644      await helper.admin.payoutStakers(palletAdmin, 100);645    });646  647    itSub.skip('can handle 40.000 rewards', async ({helper}) => {648      const crowdStakes = async () => {649        // each account in the crowd stakes 2 times650        const crowd = await helper.arrange.createCrowd(500, 300n, donor);651        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));652        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));653        // 654      };655  656      for (let i = 0; i < 40; i++) {657        await crowdStakes();658      }659  660      // TODO pay rewards for some period661    });662  });663});664665function calculateIncome(base: bigint, iter = 0, calcPeriod: bigint = UNLOCKING_PERIOD): bigint {666  const DAY = 7200n;667  const ACCURACY = 1_000_000_000n;668  // 5n / 10_000n = 0.05% p/day669  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;670  671  if (iter > 1) {672    return calculateIncome(income, iter - 1, calcPeriod);673  } else return income;674}675676function rewardAvailableInBlock(stakedInBlock: bigint) {677  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + LOCKING_PERIOD;678  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);679}680681// Wait while promotion period less than specified block, to avoid boundary cases682// 0 if this should be the beginning of the period.683async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {684  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();685  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;686687  if (currentPeriodBlock > waitBlockLessThan) {688    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);689  }690}