git.delta.rocks / unique-network / refs/commits / 7586abb798e7

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';2324import chai from 'chai';25import chaiAsPromised from 'chai-as-promised';26import {itSub, usingPlaygrounds} from './util/playgrounds';2728import {encodeAddress} from '@polkadot/util-crypto';29import {stringToU8a} from '@polkadot/util';30import {SponsoringMode} from './eth/util/helpers';31import {DevUniqueHelper} from './util/playgrounds/unique.dev';32import {itEth} from './eth/util/playgrounds';33chai.use(chaiAsPromised);34const expect = chai.expect;3536let alice: IKeyringPair;37let palletAdmin: IKeyringPair;38let nominal: bigint;39const palletAddress = calculatePalleteAddress('appstake');40let accounts: IKeyringPair[] = [];41const LOCKING_PERIOD = 20n; // 20 blocks of relay42const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain43const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);4445const beforeEach = async (context: Mocha.Context) => {46  await usingPlaygrounds(async (helper, privateKey) => {47    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) context.skip();48    alice = privateKey('//Alice');49    palletAdmin = privateKey('//Charlie'); // TODO use custom address50    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));51    nominal = helper.balance.getOneTokenNominal();52    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);53    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);54    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests55  });56};5758describe('app-promotions.stake extrinsic', () => {59  before(async function () {60    await beforeEach(this);61  });6263  itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => {64    const [staker, recepient] = [accounts.pop()!, accounts.pop()!];65    const totalStakedBefore = await helper.staking.getTotalStaked();6667    // Minimum stake amount is 100:68    await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected;69    await helper.staking.stake(staker, 100n * nominal);7071    // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n...72    // ...so he can not transfer 90073    expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});74    await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions');75    76    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);77    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);78    // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 79    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased 8081    82    await helper.staking.stake(staker, 200n * nominal);83    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);84    const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});85    expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal);86    expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal);87  });8889  itSub('should allow to create maximum 10 stakes for account', async ({helper}) => {90    const [staker] = await helper.arrange.createAccounts([2000n], alice);91    for (let i = 0; i < 10; i++) {92      await helper.staking.stake(staker, 100n * nominal);93    }9495    // can have 10 stakes96    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal);97    expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10);9899    await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission');100101    // After unstake can stake again102    await helper.staking.unstake(staker);103    await helper.staking.stake(staker, 100n * nominal);104    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal);105  });106  107  itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => {108    const staker = accounts.pop()!;109110    // Can't stake full balance because Alice needs to pay some fee111    await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected;112    await helper.staking.stake(staker, 500n * nominal);113114    // Can't stake 500 tkn because Alice has Less than 500 transferable;115    await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); 116    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);117  });118  119  itSub('for different accounts in one block is possible', async ({helper}) => {120    const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];121      122    const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));123    await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled;124125    const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));126    expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);127  });128});129130describe('unstake balance extrinsic', () => {  131  before(async function () {132    await beforeEach(this);133  });134135  itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => {136    const [staker, recepient] = [accounts.pop()!, accounts.pop()!];137    const totalStakedBefore = await helper.staking.getTotalStaked();138    await helper.staking.stake(staker, 900n * nominal);139    await helper.staking.unstake(staker);140141    // Right after unstake balance is reserved142    // Staker can not transfer 143    expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});144    await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance');145    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);146    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);147    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);148  });149150  itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => {151    const staker = accounts.pop()!;152    await helper.staking.stake(staker, 100n * nominal);153    await helper.staking.unstake(staker);154    const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});155156    // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n157    await helper.wait.forParachainBlockNumber(pendingUnstake.block);158    expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});159    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);160161    // staker can transfer:162    await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);163    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);164  });165166  itSub('should successfully unstake multiple stakes', async ({helper}) => {167    const staker = accounts.pop()!;168    await helper.staking.stake(staker, 100n * nominal);169    await helper.staking.stake(staker, 200n * nominal);170    await helper.staking.stake(staker, 300n * nominal);171172    // staked: [100, 200, 300]; unstaked: 0173    let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});174    let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});175    let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});176    expect(totalPendingUnstake).to.be.deep.equal(0n);177    expect(pendingUnstake).to.be.deep.equal([]);178    expect(stakes[0].amount).to.equal(100n * nominal);179    expect(stakes[1].amount).to.equal(200n * nominal);180    expect(stakes[2].amount).to.equal(300n * nominal);181     182    // Can unstake multiple stakes183    await helper.staking.unstake(staker);184    pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});185    totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});186    stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});187    expect(totalPendingUnstake).to.be.equal(600n * nominal);188    expect(stakes).to.be.deep.equal([]);189    expect(pendingUnstake[0].amount).to.equal(600n * nominal);190191    expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});192    await helper.wait.forParachainBlockNumber(pendingUnstake[0].block);193    expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});194    expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);195  });196197  itSub('should not have any effects if no active stakes', async ({helper}) => {198    const staker = accounts.pop()!;199      200    // unstake has no effect if no stakes at all201    await helper.staking.unstake(staker);202    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);203    expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper204205    // TODO stake() unstake() waitUnstaked() unstake();206207    // can't unstake if there are only pendingUnstakes208    await helper.staking.stake(staker, 100n * nominal);209    await helper.staking.unstake(staker);210    await helper.staking.unstake(staker);211212    expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);213    expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);214  });215216  itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => {217    const staker = accounts.pop()!;218    await helper.staking.stake(staker, 100n * nominal);219    await helper.staking.unstake(staker);220    await helper.staking.stake(staker, 120n * nominal);221    await helper.staking.unstake(staker);222223    const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});224    expect(unstakingPerBlock).has.length(2);225    expect(unstakingPerBlock[0].amount).to.equal(100n * nominal);226    expect(unstakingPerBlock[1].amount).to.equal(120n * nominal);227  });228229  itSub('should be possible for different accounts in one block', async ({helper}) => {230    const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];231232    await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));233    await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));234235    await Promise.all(stakers.map(async (staker) => {236      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);237      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);238    }));239  });240});241242describe('Admin adress', () => {243  before(async function () {244    await beforeEach(this);245  });246247  itSub('can be set by sudo only', async ({helper}) => {248    const nonAdmin = accounts.pop()!;249    // nonAdmin can not set admin not from himself nor as a sudo250    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected;251    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected;252253    // Alice can254    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;255  });256  257  itSub('can be any valid CrossAccountId', async ({helper}) => {258    // We are not going to set an eth address as a sponsor,259    // but we do want to check, it doesn't break anything;260    const account = accounts.pop()!;261    const ethAccount = helper.address.substrateToEth(account.address); 262    // Alice sets Ethereum address as a sudo. Then Substrate address back...263    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled;264    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled;265      266    // ...It doesn't break anything;267    const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});268    await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;269  });270271  itSub('can be reassigned', async ({helper}) => {272    const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];273    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});274      275    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.fulfilled;276    await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.fulfilled;277    await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;278      279    await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;280  });281});282283describe('App-promotion collection sponsoring', () => {284  before(async function () {285    await beforeEach(this);286    await usingPlaygrounds(async (helper) => {287      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));288      await helper.signTransaction(alice, tx);289    });290  });291292  itSub('should actually sponsor transactions', async ({helper}) => {293    const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];294    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});295    const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});296    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));297    const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);298299    await token.transfer(tokenSender, {Substrate: receiver.address});300    expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});301    const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);302303    // senders balance the same, transaction has sponsored304    expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);305    expect (palletBalanceBefore > palletBalanceAfter).to.be.true;306  });307308  itSub('can not be set by non admin', async ({helper}) => {309    const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];310311    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});312      313    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;314    expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');315  });316317  itSub('should set pallet address as confirmed admin', async ({helper}) => {318    const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];319      320    // Can set sponsoring for collection without sponsor321    const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});322    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled;323    expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});324325    // Can set sponsoring for collection with unconfirmed sponsor326    const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});327    expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});328    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled;329    expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});330331    // Can set sponsoring for collection with confirmed sponsor332    const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});333    await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);334    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled;335    expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});336  });337338  itSub('can be overwritten by collection owner', async ({helper}) => {    339    const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];340    const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});341    const collectionId = collection.collectionId;342      343    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled;344      345    // Collection limits still can be changed by the owner346    expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;347    expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);348    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});349350    // Collection sponsor can be changed too351    expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;352    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});353  });354  355  itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => {356    const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};357    const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});358359    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled;360    expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);361  });362  363  itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => {364    const collectionOwner = accounts.pop()!;365      366    // collection has never existed367    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected;368    // collection has been burned369    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});370    await collection.burn(collectionOwner);371372    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected;373  });374});375376describe('app-promotion stopSponsoringCollection', () => {377  before(async function () {378    await beforeEach(this);379  });380381  itSub('can not be called by non-admin', async ({helper}) => {    382    const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];383    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});384      385    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled;386      387    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;388    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});389  });390391  itSub('should set sponsoring as disabled', async ({helper}) => {392    const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];393    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});394    const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});395      396    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));397    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));398      399    expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');400401    // Transactions are not sponsored anymore:402    const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);403    await token.transfer(collectionOwner, {Substrate: recepient.address});404    const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);405    expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);406  });407408  itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => {409    const collectionOwner = accounts.pop()!;410    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});411    await collection.confirmSponsorship(collectionOwner);412      413    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;414      415    expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});416  });417418  itSub('should reject transaction if collection does not exist', async ({helper}) => {    419    const collectionOwner = accounts.pop()!;420    const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});421      422    await collection.burn(collectionOwner);423    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected;424    await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.rejected;425  });426});427428describe('app-promotion contract sponsoring', () => {429  before(async function () {430    await beforeEach(this);431  });432433  itEth('should set palletes address as a sponsor', async ({helper}) => {434    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();435    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);436    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);437438    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);439    440    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  441    expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  442    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({443      confirmed: {444        substrate: palletAddress,445      },446    });447  });448449  itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => {450    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();451    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);452    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);453454    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;455456    // Contract is self sponsored457    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({458      confirmed: {459        ethereum: flipper.options.address.toLowerCase(),460      },461    });462463    // set promotion sponsoring464    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);465466    // new sponsor is pallet address467    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  468    expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  469    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({470      confirmed: {471        substrate: palletAddress,472      },473    });474  });475476  itEth('can be overwritten by contract owner', async ({helper}) => {477    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();478    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);479    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);480481    // contract sponsored by pallet482    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);483484    // owner sets self sponsoring485    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;486487    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true;  488    expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  489    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({490      confirmed: {491        ethereum: flipper.options.address.toLowerCase(),492      },493    });494  });495496  itEth('can not be set by non admin', async ({helper}) => {497    const nonAdmin = accounts.pop()!;498    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();499    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);500    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);501502    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;503504    // nonAdmin calls sponsorContract505    await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');506507    // contract still self-sponsored 508    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({509      confirmed: {510        ethereum: flipper.options.address.toLowerCase(),511      },512    });513  });514515  itEth('should actually sponsor transactions', async ({helper}) => {516    // Contract caller517    const caller = await helper.eth.createAccountWithBalance(alice, 1000n);518    const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);519        520    // Deploy flipper521    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();522    const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner);523    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);524    525    // Owner sets to sponsor every tx526    await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});527    await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});528    await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n);529530    // Set promotion to the Flipper531    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorContract(flipper.options.address));532533    // Caller calls Flipper534    await flipper.methods.flip().send({from: caller});535    expect(await flipper.methods.getValue().call()).to.be.true;536537    // The contracts and caller balances have not changed538    const callerBalance = await helper.balance.getEthereum(caller);539    const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);540    expect(callerBalance).to.be.equal(1000n * nominal);541    expect(1000n * nominal === contractBalanceAfter).to.be.true;542543    // The pallet balance has decreased544    const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);545    expect(palletBalanceAfter < palletBalanceBefore).to.be.true;546  });547});548549describe('app-promotion stopSponsoringContract', () => {  550  before(async function () {551    await beforeEach(this);552  });553554  itEth('should remove pallet address from contract sponsors', async ({helper}) => {555    const caller = await helper.eth.createAccountWithBalance(alice, 1000n);556    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();557    const flipper = await helper.eth.deployFlipper(contractOwner);558    await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address);559    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);560561    await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});562    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true);563    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true);564565    expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  566    expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  567    expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({568      disabled: null,569    });570571    await flipper.methods.flip().send({from: caller});572    expect(await flipper.methods.getValue().call()).to.be.true;573574    const callerBalance = await helper.balance.getEthereum(caller);575    const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);576577    // caller payed for call578    expect(1000n * nominal > callerBalance).to.be.true;579    expect(contractBalanceAfter).to.be.equal(1000n * nominal);580  });581582  itEth('can not be called by non-admin', async ({helper}) => {583    const nonAdmin = accounts.pop()!;584    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();585    const flipper = await helper.eth.deployFlipper(contractOwner);586587    await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]);588    const stopSponsoringResult = await helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]);589    expect(stopSponsoringResult.status).to.equal('Fail');590    expect(stopSponsoringResult.moduleError).to.equal('appPromotion.NoPermission');591  });592593  itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => {594    const nonAdmin = accounts.pop()!;595    const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase();596    const flipper = await helper.eth.deployFlipper(contractOwner);597    const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner);598    await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled;599600    await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission');601  });602});603604describe('app-promotion rewards', () => {605  before(async function () {606    await beforeEach(this);607  });608609  itSub('can not be called by non admin', async ({helper}) => {610    const nonAdmin = accounts.pop()!;611    await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;612  });613614  itSub('should increase total staked', async ({helper}) => {615    const staker = accounts.pop()!;616    const totalStakedBefore = await helper.staking.getTotalStaked();617    await helper.staking.stake(staker, 100n * nominal);618619    // Wait for rewards and pay620    const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});621    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block));622    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));623624    const totalStakedAfter = await helper.staking.getTotalStaked();625    expect(totalStakedAfter >= totalStakedBefore + calculateIncome(100n * nominal, 10n)).to.be.true;626627    // staker can unstake628    await helper.staking.unstake(staker);629    expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));630  });631632  itSub('should credit 0.05% for staking period', async ({helper}) => {    633    const staker = accounts.pop()!;634635    await waitPromotionPeriodDoesntEnd(helper);636      637    await helper.staking.stake(staker, 100n * nominal);638    await helper.staking.stake(staker, 200n * nominal);639640    // wait rewards are available:641    const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});642    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block));643644    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));645646    const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});647    expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n));648    expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n));649  });650651  itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => {652    const staker = accounts.pop()!;653654    await helper.staking.stake(staker, 100n * nominal);655    // wait for two rewards are available:656    let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});657    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);658659    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));660    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});661    const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);662    expect(stake.amount).to.be.equal(frozenBalanceShouldBe);663664    const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);665666    expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});667  });668  669  itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => {670    // staker unstakes before rewards has been payed671    const staker = accounts.pop()!;672    await helper.staking.stake(staker, 100n * nominal);673    const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});674    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);675    await helper.staking.unstake(staker);676      677    // so he did not receive any rewards678    const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);679    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));680    const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);681682    expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);683  });684  685  itSub('should bring compound interest', async ({helper}) => {686    const staker = accounts.pop()!;687            688    await helper.staking.stake(staker, 100n * nominal);689690    let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});691    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block));692      693    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));694    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});695    expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n));696      697    await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD);698    await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));699    [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});700    expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2));701  });702703  itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => {704    // all other stakes should be unstaked705    const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);706707    // stakers stakes 10 times each708    for (let i = 0; i < 10; i++) {709      await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));710    }711    await helper.wait.newBlocks(40);712    const result = await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));713  });714715  itSub.skip('can handle 40.000 rewards', async ({helper}) => {716    const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);717    const crowdStakes = async () => {718      // each account in the crowd stakes 2 times719      const crowd = await helper.arrange.createCrowd(500, 300n, donor);720      await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));721      await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));722      // 723    };724725    for (let i = 0; i < 40; i++) {726      await crowdStakes();727    }728729    // TODO pay rewards for some period730  });731});732733function calculatePalleteAddress(palletId: any) {734  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));735  return encodeAddress(address);736}737738function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {739  const DAY = 7200n;740  const ACCURACY = 1_000_000_000n;741  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;742  743  if (iter > 1) {744    return calculateIncome(income, calcPeriod, iter - 1);745  } else return income;746}747748// Wait while promotion period less than specified block, to avoid boundary cases749// 0 if this should be the beginning of the period.750async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {751  const relayBlockNumber = (await helper.api!.query.parachainSystem.validationData()).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();752  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;753754  if (currentPeriodBlock > waitBlockLessThan) {755    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);756  }757}