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

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/playgrounds';19import {encodeAddress} from '@polkadot/util-crypto';20import {stringToU8a} from '@polkadot/util';21import {DevUniqueHelper} from './util/playgrounds/unique.dev';22import {itEth, expect, SponsoringMode} from './eth/util/playgrounds';2324let superuser: IKeyringPair;25let donor: IKeyringPair;26let palletAdmin: IKeyringPair;27let nominal: bigint;28const palletAddress = calculatePalleteAddress('appstake');29let accounts: IKeyringPair[] = [];30const LOCKING_PERIOD = 20n; // 20 blocks of relay31const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain32const rewardAvailableInBlock = (stakedInBlock: bigint) => {33  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + 20n;34  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);35};3637describe('App promotion', () => {38  before(async function () {39    await usingPlaygrounds(async (helper, privateKey) => {40      requirePalletsOrSkip(this, helper, [Pallets.AppPromotion]);41      superuser = await privateKey('//Alice');42      donor = await privateKey({filename: __filename});43      [palletAdmin] = await helper.arrange.createAccounts([100n], donor);44      const api = helper.getApi();45      await helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));46      nominal = helper.balance.getOneTokenNominal();47      await helper.balance.transferToSubstrate(donor, palletAdmin.address, 1000n * nominal);48      await helper.balance.transferToSubstrate(donor, palletAddress, 1000n * nominal);49      accounts = await helper.arrange.createCrowd(100, 1000n, donor); // create accounts-pool to speed up tests50    });51  });5253  describe('stake extrinsic', () => {  54    itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {55      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];56      const totalStakedBefore = await helper.staking.getTotalStaked();57  58      // Minimum stake amount is 100:59      await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;60      await helper.staking.stake(staker, 100n * nominal);61  62      // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...63      // ...so he can not transfer 90064      expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});65      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');66      67      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);68      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);69      // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 70      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 71  72      73      await helper.staking.stake(staker, 200n * nominal);74      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);75      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});76      expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);77      expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);78    });79  80    itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {81      const [staker] = await helper.arrange.createAccounts([2000n], donor);82      for (let i = 0; i < 10; i++) {83        await helper.staking.stake(staker, 100n * nominal);84      }85  86      // can have 10 stakes87      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);88      expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);89  90      await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');91  92      // After unstake can stake again93      await helper.staking.unstake(staker);94      await helper.staking.stake(staker, 100n * nominal);95      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);96    });97    98    itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {99      const staker = accounts.pop()!;100  101      // Can't stake full balance because Alice needs to pay some fee102      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;103      await helper.staking.stake(staker, 500n * nominal);104  105      // Can't stake 500 tkn because Alice has Less than 500 transferable;106      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 107      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);108    });109    110    itSub('for different accounts in one block is possible', async ({helper}) => {111      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];112        113      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));114      await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;115  116      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));117      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);118    });119  });120  121  describe('unstake extrinsic', () => {  122    itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {123      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];124      const totalStakedBefore = await helper.staking.getTotalStaked();125      await helper.staking.stake(staker, 900n * nominal);126      await helper.staking.unstake(staker);127  128      // Right after unstake balance is reserved129      // Staker can not transfer 130      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});131      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');132      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);133      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);134      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);135    });136  137    itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {138      const staker = accounts.pop()!;139      await helper.staking.stake(staker, 100n * nominal);140      await helper.staking.unstake(staker);141      const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});142  143      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n144      await helper.wait.forParachainBlockNumber(pendingUnstake.block);145      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});146      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);147  148      // staker can transfer:149      await helper.balance.transferToSubstrate(staker, donor.address, 998n * nominal);150      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);151    });152  153    itSub('should successfully unstake multiple stakes', async ({helper}) => {154      const staker = accounts.pop()!;155      await helper.staking.stake(staker, 100n * nominal);156      await helper.staking.stake(staker, 200n * nominal);157      await helper.staking.stake(staker, 300n * nominal);158  159      // staked: [100, 200, 300]; unstaked: 0160      let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});161      let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});162      let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});163      expect(totalPendingUnstake).to.be.deep.equal(0n);164      expect(pendingUnstake).to.be.deep.equal([]);165      expect(stakes[0].amount).to.equal(100n * nominal);166      expect(stakes[1].amount).to.equal(200n * nominal);167      expect(stakes[2].amount).to.equal(300n * nominal);168       169      // Can unstake multiple stakes170      await helper.staking.unstake(staker);171      pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});172      totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});173      stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});174      expect(totalPendingUnstake).to.be.equal(600n * nominal);175      expect(stakes).to.be.deep.equal([]);176      expect(pendingUnstake[0].amount).to.equal(600n * nominal);177  178      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});179      await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);180      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});181      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);182    });183  184    itSub('should not have any effects if no active stakes', async ({helper}) => {185      const staker = accounts.pop()!;186        187      // unstake has no effect if no stakes at all188      await helper.staking.unstake(staker);189      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);190      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper191  192      // TODO stake() unstake() waitUnstaked() unstake();193  194      // can't unstake if there are only pendingUnstakes195      await helper.staking.stake(staker, 100n * nominal);196      await helper.staking.unstake(staker);197      await helper.staking.unstake(staker);198  199      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);200      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);201    });202  203    itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {204      const staker = accounts.pop()!;205      await helper.staking.stake(staker, 100n * nominal);206      await helper.staking.unstake(staker);207      await helper.staking.stake(staker, 120n * nominal);208      await helper.staking.unstake(staker);209  210      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});211      expect(unstakingPerBlock).has.length(2);212      expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);213      expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);214    });215  216    itSub('should be possible for different accounts in one block', async ({helper}) => {217      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];218  219      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));220      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));221  222      await Promise.all(stakers.map(async (staker) => {223        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);224        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);225      }));226    });227  });228  229  describe('admin adress', () => {230    itSub('can be set by sudo only', async ({helper}) => {231      const api = helper.getApi();232      const nonAdmin = accounts.pop()!;233      // nonAdmin can not set admin not from himself nor as a sudo234      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;235      await expect(helper.signTransaction(nonAdmin, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;236  237      // Alice can238      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;239    });240    241    itSub('can be any valid CrossAccountId', async ({helper}) => {242      // We are not going to set an eth address as a sponsor,243      // but we do want to check, it doesn't break anything;244      const api = helper.getApi();245      const account = accounts.pop()!;246      const ethAccount = helper.address.substrateToEth(account.address); 247      // Alice sets Ethereum address as a sudo. Then Substrate address back...248      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;249      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;250        251      // ...It doesn't break anything;252      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});253      await expect(helper.signTransaction(account, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;254    });255  256    itSub('can be reassigned', async ({helper}) => {257      const api = helper.getApi();258      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];259      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});260        261      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: oldAdmin.address})))).to.be.fulfilled;262      await expect(helper.signTransaction(superuser, api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: newAdmin.address})))).to.be.fulfilled;263      await expect(helper.signTransaction(oldAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;264        265      await expect(helper.signTransaction(newAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;266    });267  });268  269  describe('collection sponsoring', () => {270    before(async function () {271      await usingPlaygrounds(async (helper) => {272        const api = helper.getApi();273        const tx = api.tx.sudo.sudo(api.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));274        await helper.signTransaction(superuser, tx);275      });276    });277  278    itSub('should actually sponsor transactions', async ({helper}) => {279      const api = helper.getApi();280      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];281      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});282      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});283      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));284      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);285  286      await token.transfer(tokenSender, {Substrate: receiver.address});287      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});288      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);289  290      // senders balance the same, transaction has sponsored291      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);292      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;293    });294  295    itSub('can not be set by non admin', async ({helper}) => {296      const api = helper.getApi();297      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];298  299      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});300        301      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;302      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');303    });304  305    itSub('should set pallet address as confirmed admin', async ({helper}) => {306      const api = helper.getApi();307      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];308        309      // Can set sponsoring for collection without sponsor310      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});311      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;312      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});313  314      // Can set sponsoring for collection with unconfirmed sponsor315      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});316      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});317      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;318      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});319  320      // Can set sponsoring for collection with confirmed sponsor321      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});322      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);323      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;324      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});325    });326  327    itSub('can be overwritten by collection owner', async ({helper}) => {    328      const api = helper.getApi();329      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];330      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});331      const collectionId = collection.collectionId;332        333      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;334        335      // Collection limits still can be changed by the owner336      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;337      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);338      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});339  340      // Collection sponsor can be changed too341      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;342      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});343    });344    345    itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {346      const api = helper.getApi();347      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};348      const collectionWithLimits = await helper.nft.mintCollection(accounts.pop()!, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});349  350      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;351      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);352    });353    354    itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {355      const api = helper.getApi();356      const collectionOwner = accounts.pop()!;357        358      // collection has never existed359      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;360      // collection has been burned361      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});362      await collection.burn(collectionOwner);363  364      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;365    });366  });367  368  describe('stopSponsoringCollection', () => {369    itSub('can not be called by non-admin', async ({helper}) => {370      const api = helper.getApi();371      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];372      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});373        374      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;375        376      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;377      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});378    });379  380    itSub('should set sponsoring as disabled', async ({helper}) => {381      const api = helper.getApi();382      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];383      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});384      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});385        386      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorCollection(collection.collectionId));387      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId));388        389      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');390  391      // Transactions are not sponsored anymore:392      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);393      await token.transfer(collectionOwner, {Substrate: recepient.address});394      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);395      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);396    });397  398    itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {399      const api = helper.getApi();400      const collectionOwner = accounts.pop()!;401      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});402      await collection.confirmSponsorship(collectionOwner);403        404      await expect(helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;405        406      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});407    });408  409    itSub('should reject transaction if collection does not exist', async ({helper}) => {    410      const collectionOwner = accounts.pop()!;411      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});412        413      await collection.burn(collectionOwner);414      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');415      await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');416    });417  });418  419  describe('contract sponsoring', () => {420    itEth('should set palletes address as a sponsor', async ({helper}) => {421      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();422      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);423      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);424  425      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);426      427      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  428      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  429      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({430        confirmed: {431          substrate: palletAddress,432        },433      });434    });435  436    itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {437      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();438      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);439      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);440  441      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;442  443      // Contract is self sponsored444      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.be.deep.equal({445        confirmed: {446          ethereum: flipper.options.address.toLowerCase(),447        },448      });449  450      // set promotion sponsoring451      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);452  453      // new sponsor is pallet address454      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  455      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  456      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({457        confirmed: {458          substrate: palletAddress,459        },460      });461    });462  463    itEth('can be overwritten by contract owner', async ({helper}) => {464      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();465      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);466      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);467  468      // contract sponsored by pallet469      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);470  471      // owner sets self sponsoring472      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;473  474      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  475      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  476      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({477        confirmed: {478          ethereum: flipper.options.address.toLowerCase(),479        },480      });481    });482  483    itEth('can not be set by non admin', async ({helper}) => {484      const nonAdmin = accounts.pop()!;485      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();486      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);487      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);488  489      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;490  491      // nonAdmin calls sponsorContract492      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');493  494      // contract still self-sponsored 495      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({496        confirmed: {497          ethereum: flipper.options.address.toLowerCase(),498        },499      });500    });501  502    itEth('should actually sponsor transactions', async ({helper}) => {503      // Contract caller504      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);505      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);506          507      // Deploy flipper508      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();509      const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);510      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);511      512      // Owner sets to sponsor every tx513      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});514      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});515      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);516  517      // Set promotion to the Flipper518      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);519  520      // Caller calls Flipper521      await flipper.methods.flip().send({from: caller});522      expect(await flipper.methods.getValue().call()).to.be.true;523  524      // The contracts and caller balances have not changed525      const callerBalance = await helper.balance.getEthereum(caller);526      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);527      expect(callerBalance).to.be.equal(1000n * nominal);528      expect(1000n * nominal === contractBalanceAfter).to.be.true;529  530      // The pallet balance has decreased531      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);532      expect(palletBalanceAfter < palletBalanceBefore).to.be.true;533    });534  });535  536  describe('stopSponsoringContract', () => {  537    itEth('should remove pallet address from contract sponsors', async ({helper}) => {538      const caller = await helper.eth.createAccountWithBalance(donor, 1000n);539      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();540      const flipper = await helper.eth.deployFlipper(contractOwner);541      await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);542      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);543  544      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});545      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);546      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);547  548      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  549      expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  550      expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({551        disabled: null,552      });553  554      await flipper.methods.flip().send({from: caller});555      expect(await flipper.methods.getValue().call()).to.be.true;556  557      const callerBalance = await helper.balance.getEthereum(caller);558      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);559  560      // caller payed for call561      expect(1000n * nominal > callerBalance).to.be.true;562      // todo:playgrounds look into. why did it work before with 1000n, and is now 100n?563      expect(contractBalanceAfter).to.be.equal(100n * nominal);564    });565  566    itEth('can not be called by non-admin', async ({helper}) => {567      const nonAdmin = accounts.pop()!;568      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();569      const flipper = await helper.eth.deployFlipper(contractOwner);570  571      await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);572      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]))573        .to.be.rejectedWith(/appPromotion\.NoPermission/);574    });575  576    itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {577      const nonAdmin = accounts.pop()!;578      const contractOwner = (await helper.eth.createAccountWithBalance(donor, 1000n)).toLowerCase();579      const flipper = await helper.eth.deployFlipper(contractOwner);580      const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);581      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;582  583      await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');584    });585  });586  587  describe('rewards', () => {588    itSub('can not be called by non admin', async ({helper}) => {589      const nonAdmin = accounts.pop()!;590      await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');591    });592  593    itSub('should increase total staked', async ({helper}) => {594      const staker = accounts.pop()!;595      const totalStakedBefore = await helper.staking.getTotalStaked();596      await helper.staking.stake(staker, 100n * nominal);597  598      // Wait for rewards and pay599      const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});600      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));601      const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);602  603      const totalStakedAfter = await helper.staking.getTotalStaked();604      expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);605      // staker can unstake606      await helper.staking.unstake(staker);607      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));608    });609  610    itSub('should credit 0.05% for staking period', async ({helper}) => {    611      const staker = accounts.pop()!;612  613      await waitPromotionPeriodDoesntEnd(helper);614        615      await helper.staking.stake(staker, 100n * nominal);616      await helper.staking.stake(staker, 200n * nominal);617  618      // wait rewards are available:619      const [_stake1, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});620      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));621  622      const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;623      expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));624  625      const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});626      expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));627      expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));628    });629  630    itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {631      const staker = accounts.pop()!;632  633      await helper.staking.stake(staker, 100n * nominal);634      // wait for two rewards are available:635      let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});636      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);637  638      await helper.admin.payoutStakers(palletAdmin, 100);639      [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});640      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);641      expect(stake.amount).to.be.equal(frozenBalanceShouldBe);642  643      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);644  645      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});646    });647    648    itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {649      // staker unstakes before rewards has been payed650      const staker = accounts.pop()!;651      await helper.staking.stake(staker, 100n * nominal);652      const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});653      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);654      await helper.staking.unstake(staker);655        656      // so he did not receive any rewards657      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);658      await helper.admin.payoutStakers(palletAdmin, 100);659      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);660  661      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);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, 10n));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, 10n, 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 calculatePalleteAddress(palletId: any) {713  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));714  return encodeAddress(address);715}716717function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {718  const DAY = 7200n;719  const ACCURACY = 1_000_000_000n;720  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;721  722  if (iter > 1) {723    return calculateIncome(income, calcPeriod, iter - 1);724  } else return income;725}726727// Wait while promotion period less than specified block, to avoid boundary cases728// 0 if this should be the beginning of the period.729async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {730  const relayBlockNumber = (await helper.callRpc('api.query.parachainSystem.validationData', [])).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();731  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;732733  if (currentPeriodBlock > waitBlockLessThan) {734    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);735  }736}