git.delta.rocks / unique-network / refs/commits / 5fb293eff7dc

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  normalizeAccountId,20  getModuleNames,21  Pallets,22} from './util/helpers';23import {itSub, usingPlaygrounds} from './util/playgrounds';24import {encodeAddress} from '@polkadot/util-crypto';25import {stringToU8a} from '@polkadot/util';26import {SponsoringMode} from './eth/util/helpers';27import {DevUniqueHelper} from './util/playgrounds/unique.dev';28import {itEth, expect} from './eth/util/playgrounds';2930let alice: IKeyringPair;31let palletAdmin: IKeyringPair;32let nominal: bigint;33const palletAddress = calculatePalleteAddress('appstake');34let accounts: IKeyringPair[] = [];35const LOCKING_PERIOD = 20n; // 20 blocks of relay36const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain37const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);3839const beforeEach = async (context: Mocha.Context) => {40  await usingPlaygrounds(async (helper, privateKey) => {41    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) context.skip();42    alice = privateKey('//Alice');43    palletAdmin = privateKey('//Charlie'); // TODO use custom address44    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));45    nominal = helper.balance.getOneTokenNominal();46    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);47    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);48    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests49  });50};5152describe('app-promotions.stake extrinsic', () => {53  before(async function () {54    await beforeEach(this);55  });5657  itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {58    const [staker, recepient] = [accounts.pop()!, accounts.pop()!];59    const totalStakedBefore = await helper.staking.getTotalStaked();6061    // Minimum stake amount is 100:62    await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;63    await helper.staking.stake(staker, 100n * nominal);6465    // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...66    // ...so he can not transfer 90067    expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});68    await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');69    70    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);71    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);72    // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 73    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 7475    76    await helper.staking.stake(staker, 200n * nominal);77    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);78    const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});79    expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);80    expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);81  });8283  itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {84    const [staker] = await helper.arrange.createAccounts([2000n], alice);85    for (let i = 0; i < 10; i++) {86      await helper.staking.stake(staker, 100n * nominal);87    }8889    // can have 10 stakes90    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);91    expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);9293    await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');9495    // After unstake can stake again96    await helper.staking.unstake(staker);97    await helper.staking.stake(staker, 100n * nominal);98    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);99  });100  101  itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {102    const staker = accounts.pop()!;103104    // Can't stake full balance because Alice needs to pay some fee105    await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;106    await helper.staking.stake(staker, 500n * nominal);107108    // Can't stake 500 tkn because Alice has Less than 500 transferable;109    await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 110    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);111  });112  113  itSub('for different accounts in one block is possible', async ({helper}) => {114    const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];115      116    const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));117    await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;118119    const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));120    expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);121  });122});123124describe('unstake balance extrinsic', () => {  125  before(async function () {126    await beforeEach(this);127  });128129  itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {130    const [staker, recepient] = [accounts.pop()!, accounts.pop()!];131    const totalStakedBefore = await helper.staking.getTotalStaked();132    await helper.staking.stake(staker, 900n * nominal);133    await helper.staking.unstake(staker);134135    // Right after unstake balance is reserved136    // Staker can not transfer 137    expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});138    await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');139    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);140    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);141    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);142  });143144  itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {145    const staker = accounts.pop()!;146    await helper.staking.stake(staker, 100n * nominal);147    await helper.staking.unstake(staker);148    const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});149150    // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n151    await helper.wait.forParachainBlockNumber(pendingUnstake.block);152    expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});153    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);154155    // staker can transfer:156    await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);157    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);158  });159160  itSub('should successfully unstake multiple stakes', async ({helper}) => {161    const staker = accounts.pop()!;162    await helper.staking.stake(staker, 100n * nominal);163    await helper.staking.stake(staker, 200n * nominal);164    await helper.staking.stake(staker, 300n * nominal);165166    // staked: [100, 200, 300]; unstaked: 0167    let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});168    let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});169    let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});170    expect(totalPendingUnstake).to.be.deep.equal(0n);171    expect(pendingUnstake).to.be.deep.equal([]);172    expect(stakes[0].amount).to.equal(100n * nominal);173    expect(stakes[1].amount).to.equal(200n * nominal);174    expect(stakes[2].amount).to.equal(300n * nominal);175     176    // Can unstake multiple stakes177    await helper.staking.unstake(staker);178    pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});179    totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});180    stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});181    expect(totalPendingUnstake).to.be.equal(600n * nominal);182    expect(stakes).to.be.deep.equal([]);183    expect(pendingUnstake[0].amount).to.equal(600n * nominal);184185    expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});186    await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);187    expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});188    expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);189  });190191  itSub('should not have any effects if no active stakes', async ({helper}) => {192    const staker = accounts.pop()!;193      194    // unstake has no effect if no stakes at all195    await helper.staking.unstake(staker);196    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);197    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper198199    // TODO stake() unstake() waitUnstaked() unstake();200201    // can't unstake if there are only pendingUnstakes202    await helper.staking.stake(staker, 100n * nominal);203    await helper.staking.unstake(staker);204    await helper.staking.unstake(staker);205206    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);207    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);208  });209210  itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {211    const staker = accounts.pop()!;212    await helper.staking.stake(staker, 100n * nominal);213    await helper.staking.unstake(staker);214    await helper.staking.stake(staker, 120n * nominal);215    await helper.staking.unstake(staker);216217    const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});218    expect(unstakingPerBlock).has.length(2);219    expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);220    expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);221  });222223  itSub('should be possible for different accounts in one block', async ({helper}) => {224    const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];225226    await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));227    await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));228229    await Promise.all(stakers.map(async (staker) => {230      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);231      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);232    }));233  });234});235236describe('Admin adress', () => {237  before(async function () {238    await beforeEach(this);239  });240241  itSub('can be set by sudo only', async ({helper}) => {242    const nonAdmin = accounts.pop()!;243    // nonAdmin can not set admin not from himself nor as a sudo244    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;245    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;246247    // Alice can248    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;249  });250  251  itSub('can be any valid CrossAccountId', async ({helper}) => {252    // We are not going to set an eth address as a sponsor,253    // but we do want to check, it doesn't break anything;254    const account = accounts.pop()!;255    const ethAccount = helper.address.substrateToEth(account.address); 256    // Alice sets Ethereum address as a sudo. Then Substrate address back...257    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;258    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;259      260    // ...It doesn't break anything;261    const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});262    await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;263  });264265  itSub('can be reassigned', async ({helper}) => {266    const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];267    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});268      269    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.fulfilled;270    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.fulfilled;271    await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;272      273    await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;274  });275});276277describe('App-promotion collection sponsoring', () => {278  before(async function () {279    await beforeEach(this);280    await usingPlaygrounds(async (helper) => {281      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));282      await helper.signTransaction(alice, tx);283    });284  });285286  itSub('should actually sponsor transactions', async ({helper}) => {287    const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];288    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});289    const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});290    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));291    const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);292293    await token.transfer(tokenSender, {Substrate: receiver.address});294    expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});295    const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);296297    // senders balance the same, transaction has sponsored298    expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);299    expect (palletBalanceBefore > palletBalanceAfter).to.be.true;300  });301302  itSub('can not be set by non admin', async ({helper}) => {303    const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];304305    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});306      307    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;308    expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');309  });310311  itSub('should set pallet address as confirmed admin', async ({helper}) => {312    const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];313      314    // Can set sponsoring for collection without sponsor315    const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});316    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;317    expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});318319    // Can set sponsoring for collection with unconfirmed sponsor320    const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});321    expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});322    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;323    expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});324325    // Can set sponsoring for collection with confirmed sponsor326    const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});327    await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);328    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;329    expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});330  });331332  itSub('can be overwritten by collection owner', async ({helper}) => {    333    const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];334    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});335    const collectionId = collection.collectionId;336      337    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;338      339    // Collection limits still can be changed by the owner340    expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;341    expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);342    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});343344    // Collection sponsor can be changed too345    expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;346    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});347  });348  349  itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {350    const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};351    const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});352353    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;354    expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);355  });356  357  itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {358    const collectionOwner = accounts.pop()!;359      360    // collection has never existed361    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;362    // collection has been burned363    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});364    await collection.burn(collectionOwner);365366    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;367  });368});369370describe('app-promotion stopSponsoringCollection', () => {371  before(async function () {372    await beforeEach(this);373  });374375  itSub('can not be called by non-admin', async ({helper}) => {    376    const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];377    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});378      379    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;380      381    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;382    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});383  });384385  itSub('should set sponsoring as disabled', async ({helper}) => {386    const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];387    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});388    const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});389      390    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));391    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));392      393    expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');394395    // Transactions are not sponsored anymore:396    const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);397    await token.transfer(collectionOwner, {Substrate: recepient.address});398    const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);399    expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);400  });401402  itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {403    const collectionOwner = accounts.pop()!;404    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});405    await collection.confirmSponsorship(collectionOwner);406      407    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;408      409    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});410  });411412  itSub('should reject transaction if collection does not exist', async ({helper}) => {    413    const collectionOwner = accounts.pop()!;414    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});415      416    await collection.burn(collectionOwner);417    await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound');418    await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound');419  });420});421422describe('app-promotion contract sponsoring', () => {423  before(async function () {424    await beforeEach(this);425  });426427  itEth('should set palletes address as a sponsor', async ({helper}) => {428    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();429    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);430    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);431432    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);433    434    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  435    expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  436    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({437      confirmed: {438        substrate: palletAddress,439      },440    });441  });442443  itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {444    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();445    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);446    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);447448    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;449450    // Contract is self sponsored451    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({452      confirmed: {453        ethereum: flipper.options.address.toLowerCase(),454      },455    });456457    // set promotion sponsoring458    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);459460    // new sponsor is pallet address461    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  462    expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner);  463    expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({464      confirmed: {465        substrate: palletAddress,466      },467    });468  });469470  itEth('can be overwritten by contract owner', async ({helper}) => {471    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();472    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);473    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);474475    // contract sponsored by pallet476    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);477478    // owner sets self sponsoring479    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;480481    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  482    expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  483    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({484      confirmed: {485        ethereum: flipper.options.address.toLowerCase(),486      },487    });488  });489490  itEth('can not be set by non admin', async ({helper}) => {491    const nonAdmin = accounts.pop()!;492    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();493    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);494    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);495496    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;497498    // nonAdmin calls sponsorContract499    await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');500501    // contract still self-sponsored 502    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({503      confirmed: {504        ethereum: flipper.options.address.toLowerCase(),505      },506    });507  });508509  itEth('should actually sponsor transactions', async ({helper}) => {510    // Contract caller511    const caller = await helper.eth.createAccountWithBalance(alice, 1000n);512    const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);513        514    // Deploy flipper515    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();516    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);517    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);518    519    // Owner sets to sponsor every tx520    await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});521    await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});522    await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);523524    // Set promotion to the Flipper525    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorContract(flipper.options.address));526527    // Caller calls Flipper528    await flipper.methods.flip().send({from: caller});529    expect(await flipper.methods.getValue().call()).to.be.true;530531    // The contracts and caller balances have not changed532    const callerBalance = await helper.balance.getEthereum(caller);533    const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);534    expect(callerBalance).to.be.equal(1000n * nominal);535    expect(1000n * nominal === contractBalanceAfter).to.be.true;536537    // The pallet balance has decreased538    const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);539    expect(palletBalanceAfter < palletBalanceBefore).to.be.true;540  });541});542543describe('app-promotion stopSponsoringContract', () => {  544  before(async function () {545    await beforeEach(this);546  });547548  itEth('should remove pallet address from contract sponsors', async ({helper}) => {549    const caller = await helper.eth.createAccountWithBalance(alice, 1000n);550    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();551    const flipper = await helper.eth.deployFlipper(contractOwner);552    await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address);553    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);554555    await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});556    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);557    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);558559    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  560    expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  561    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({562      disabled: null,563    });564565    await flipper.methods.flip().send({from: caller});566    expect(await flipper.methods.getValue().call()).to.be.true;567568    const callerBalance = await helper.balance.getEthereum(caller);569    const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);570571    // caller payed for call572    expect(1000n * nominal > callerBalance).to.be.true;573    expect(contractBalanceAfter).to.be.equal(1000n * nominal);574  });575576  itEth('can not be called by non-admin', async ({helper}) => {577    const nonAdmin = accounts.pop()!;578    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();579    const flipper = await helper.eth.deployFlipper(contractOwner);580581    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);582    const stopSponsoringResult = await helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]);583    expect(stopSponsoringResult.status).to.equal('Fail');584    expect(stopSponsoringResult.moduleError).to.equal('appPromotion.NoPermission');585  });586587  itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {588    const nonAdmin = accounts.pop()!;589    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();590    const flipper = await helper.eth.deployFlipper(contractOwner);591    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);592    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;593594    await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');595  });596});597598describe('app-promotion rewards', () => {599  before(async function () {600    await beforeEach(this);601  });602603  itSub('can not be called by non admin', async ({helper}) => {604    const nonAdmin = accounts.pop()!;605    await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission');606  });607608  itSub('should increase total staked', async ({helper}) => {609    const staker = accounts.pop()!;610    const totalStakedBefore = await helper.staking.getTotalStaked();611    await helper.staking.stake(staker, 100n * nominal);612613    // Wait for rewards and pay614    const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});615    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));616    const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n);617618    const totalStakedAfter = await helper.staking.getTotalStaked();619    expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout);620    // staker can unstake621    await helper.staking.unstake(staker);622    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));623  });624625  itSub('should credit 0.05% for staking period', async ({helper}) => {    626    const staker = accounts.pop()!;627628    await waitPromotionPeriodDoesntEnd(helper);629      630    await helper.staking.stake(staker, 100n * nominal);631    await helper.staking.stake(staker, 200n * nominal);632633    // wait rewards are available:634    const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});635    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));636637    const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout;638    expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n));639640    const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});641    expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));642    expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));643  });644645  itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {646    const staker = accounts.pop()!;647648    await helper.staking.stake(staker, 100n * nominal);649    // wait for two rewards are available:650    let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});651    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);652653    await helper.admin.payoutStakers(palletAdmin, 100);654    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});655    const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);656    expect(stake.amount).to.be.equal(frozenBalanceShouldBe);657658    const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);659660    expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});661  });662  663  itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {664    // staker unstakes before rewards has been payed665    const staker = accounts.pop()!;666    await helper.staking.stake(staker, 100n * nominal);667    const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});668    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);669    await helper.staking.unstake(staker);670      671    // so he did not receive any rewards672    const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);673    await helper.admin.payoutStakers(palletAdmin, 100);674    const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);675676    expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);677  });678  679  itSub('should bring compound interest', async ({helper}) => {680    const staker = accounts.pop()!;681            682    await helper.staking.stake(staker, 100n * nominal);683684    let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});685    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));686      687    await helper.admin.payoutStakers(palletAdmin, 100);688    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});689    expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));690      691    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);692    await helper.admin.payoutStakers(palletAdmin, 100);693    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});694    expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));695  });696697  itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {698    // all other stakes should be unstaked699    const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);700701    // stakers stakes 10 times each702    for (let i = 0; i < 10; i++) {703      await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));704    }705    await helper.wait.newBlocks(40);706    await helper.admin.payoutStakers(palletAdmin, 100);707  });708709  itSub.skip('can handle 40.000 rewards', async ({helper}) => {710    const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);711    const crowdStakes = async () => {712      // each account in the crowd stakes 2 times713      const crowd = await helper.arrange.createCrowd(500, 300n, donor);714      await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));715      await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));716      // 717    };718719    for (let i = 0; i < 40; i++) {720      await crowdStakes();721    }722723    // TODO pay rewards for some period724  });725});726727function calculatePalleteAddress(palletId: any) {728  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));729  return encodeAddress(address);730}731732function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {733  const DAY = 7200n;734  const ACCURACY = 1_000_000_000n;735  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;736  737  if (iter > 1) {738    return calculateIncome(income, calcPeriod, iter - 1);739  } else return income;740}741742// Wait while promotion period less than specified block, to avoid boundary cases743// 0 if this should be the beginning of the period.744async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {745  const relayBlockNumber = (await helper.api!.query.parachainSystem.validationData()).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();746  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;747748  if (currentPeriodBlock > waitBlockLessThan) {749    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);750  }751}