git.delta.rocks / unique-network / refs/commits / 280815c7a88b

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 {usingPlaygrounds} from './util/playgrounds';2728import {encodeAddress} from '@polkadot/util-crypto';29import {stringToU8a} from '@polkadot/util';30import {SponsoringMode, contractHelpers, createEthAccountWithBalance, deployFlipper, itWeb3, transferBalanceToEth} from './eth/util/helpers';31import {DevUniqueHelper} from './util/playgrounds/unique.dev';32chai.use(chaiAsPromised);33const expect = chai.expect;3435let alice: IKeyringPair;36let palletAdmin: IKeyringPair;37let nominal: bigint;38const palletAddress = calculatePalleteAddress('appstake');39let accounts: IKeyringPair[] = [];40const LOCKING_PERIOD = 20n; // 20 blocks of relay41const UNLOCKING_PERIOD = 10n; // 20 blocks of parachain42const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);4344const beforeEach = async (context: Mocha.Context) => {45  await usingPlaygrounds(async (helper, privateKey) => {46    if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) context.skip();47    alice = privateKey('//Alice');48    palletAdmin = privateKey('//Charlie'); // TODO use custom address49    await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})));50    nominal = helper.balance.getOneTokenNominal();51    await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal);52    await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal);53    accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests54  });55};5657describe('app-promotions.stake extrinsic', () => {58  before(async function () {59    await beforeEach(this);60  });6162  it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => {63    await usingPlaygrounds(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.eventually.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.rejected;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      expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);85    });86  });8788  it('should allow to create maximum 10 stakes for account', async () => {89    await usingPlaygrounds(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.rejected;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  108  it('should reject transaction if stake amount is more than total free balance minus frozen', async () => {109    await usingPlaygrounds(async helper => { 110      const staker = accounts.pop()!;111112      // Can't stake full balance because Alice needs to pay some fee113      await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected;114      await helper.staking.stake(staker, 500n * nominal);115116      // Can't stake 500 tkn because Alice has Less than 500 transferable;117      await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; 118      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal);119    });120  });121  122  it('for different accounts in one block is possible', async () => {123    await usingPlaygrounds(async helper => {124      const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!];125      126      const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal));127      await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled;128129      const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address})));130      expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]);131    });132  });133});134135describe('unstake balance extrinsic', () => {  136  before(async function () {137    await beforeEach(this);138  });139140  it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {141    await usingPlaygrounds(async helper => {142      const [staker, recepient] = [accounts.pop()!, accounts.pop()!];143      const totalStakedBefore = await helper.staking.getTotalStaked();144      await helper.staking.stake(staker, 900n * nominal);145      await helper.staking.unstake(staker);146147      // Right after unstake balance is reserved148      // Staker can not transfer 149      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n});150      await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected;151      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal);152      expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);153      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore);154    });155  });156157  it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => {158    await usingPlaygrounds(async (helper) => {159      const staker = accounts.pop()!;160      await helper.staking.stake(staker, 100n * nominal);161      await helper.staking.unstake(staker);162      const unstakedInBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];163164      // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n165      await helper.wait.forParachainBlockNumber(unstakedInBlock);166      expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});167      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);168169      // staker can transfer:170      await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal);171      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n);172    });173  });174175  it('should successfully unstake multiple stakes', async () => {176    await usingPlaygrounds(async helper => {177      const staker = accounts.pop()!;178      await helper.staking.stake(staker, 100n * nominal);179      await helper.staking.stake(staker, 200n * nominal);180      await helper.staking.stake(staker, 300n * nominal);181182      // staked: [100, 200, 300]; unstaked: 0183      let pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});184      let unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);185      let stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);186      expect(pendingUnstake).to.be.deep.equal(0n);187      expect(unstakedPerBlock).to.be.deep.equal([]);188      expect(stakedPerBlock).to.be.deep.equal([100n * nominal, 200n * nominal, 300n * nominal]);189     190      // Can unstake multiple stakes191      await helper.staking.unstake(staker);192      const unstakingBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];193      pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});194      unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);195      stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);196      expect(pendingUnstake).to.be.equal(600n * nominal);197      expect(stakedPerBlock).to.be.deep.equal([]);198      expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]);199200      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});201      await helper.wait.forParachainBlockNumber(unstakingBlock);202      expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});203      expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);204    });205  });206207  it('should not have any effects if no active stakes', async () => {208    await usingPlaygrounds(async (helper) => {209      const staker = accounts.pop()!;210      211      // unstake has no effect if no stakes at all212      await helper.staking.unstake(staker);213      expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);214      expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper215216      // TODO stake() unstake() waitUnstaked() unstake();217218      // can't unstake if there are only pendingUnstakes219      await helper.staking.stake(staker, 100n * nominal);220      await helper.staking.unstake(staker);221      await helper.staking.unstake(staker);222223      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  });227228  it('should keep different unlocking block for each unlocking stake', async () => {229    await usingPlaygrounds(async (helper) => {230      const staker = accounts.pop()!;231      await helper.staking.stake(staker, 100n * nominal);232      await helper.staking.unstake(staker);233      await helper.staking.stake(staker, 120n * nominal);234      await helper.staking.unstake(staker);235236      const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address});237      expect(unstakingPerBlock).has.length(2);238      expect(unstakingPerBlock[0][1]).to.equal(100n * nominal);239      expect(unstakingPerBlock[1][1]).to.equal(120n * nominal);240    });241  });242243  it('should be possible for different accounts in one block', async () => {244    await usingPlaygrounds(async (helper) => {245      const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!];246247      await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal)));248      await Promise.all(stakers.map(staker => helper.staking.unstake(staker)));249250      await Promise.all(stakers.map(async (staker) => {251        expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);252        expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);253      }));254    });255  });256});257258describe('Admin adress', () => {259  before(async function () {260    await beforeEach(this);261  });262263  it('can be set by sudo only', async () => {264    await usingPlaygrounds(async (helper) => {265      const nonAdmin = accounts.pop()!;266      // nonAdmin can not set admin not from himself nor as a sudo267      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected;268      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected;269270      // Alice can271      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;272    });273  });274  275  it('can be any valid CrossAccountId', async () => {276    // We are not going to set an eth address as a sponsor,277    // but we do want to check, it doesn't break anything;278    await usingPlaygrounds(async (helper) => {279      const account = accounts.pop()!;280      const ethAccount = helper.address.substrateToEth(account.address); 281      // Alice sets Ethereum address as a sudo. Then Substrate address back...282      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled;283      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled;284      285      // ...It doesn't break anything;286      const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});287      await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;288    });289  });290291  it('can be reassigned', async () => {292    await usingPlaygrounds(async (helper) => {293      const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];294      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});295      296      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled;297      await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled;298      await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;299      300      await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;301    });302  });303});304305describe('App-promotion collection sponsoring', () => {306  before(async function () {307    await beforeEach(this);308    await usingPlaygrounds(async (helper) => {309      const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}));310      await helper.signTransaction(alice, tx);311    });312  });313314  it('should actually sponsor transactions', async () => {315    await usingPlaygrounds(async (helper) => {316      const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!];317      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}});318      const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address});319      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));320      const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress);321322      await token.transfer(tokenSender, {Substrate: receiver.address});323      expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address});324      const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress);325326      // senders balance the same, transaction has sponsored327      expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal);328      expect (palletBalanceBefore > palletBalanceAfter).to.be.true;329    });330  });331332  it('can not be set by non admin', async () => {333    await usingPlaygrounds(async (helper) => {334      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];335336      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});337      338      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;339      expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled');340    });341  });342343  it('should set pallet address as confirmed admin', async () => {344    await usingPlaygrounds(async (helper) => {345      const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!];346      347      // Can set sponsoring for collection without sponsor348      const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'});349      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled;350      expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});351352      // Can set sponsoring for collection with unconfirmed sponsor353      const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});354      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address});355      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled;356      expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});357358      // Can set sponsoring for collection with confirmed sponsor359      const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address});360      await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor);361      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled;362      expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});363    });364  });365366  it('can be overwritten by collection owner', async () => {    367    await usingPlaygrounds(async (helper) => {368      const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!];369      const collection  = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});370      const collectionId = collection.collectionId;371      372      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;373      374      // Collection limits still can be changed by the owner375      expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true;376      expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);377      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});378379      // Collection sponsor can be changed too380      expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true;381      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address});382    });383  });384  385  it('should not overwrite collection limits set by the owner earlier', async () => {386    await usingPlaygrounds(async (helper) => {387      const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0};388      const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits});389390      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled;391      expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits);392    });393  });394  395  it('should reject transaction if collection doesn\'t exist', async () => {396    await usingPlaygrounds(async (helper) => {397      const collectionOwner = accounts.pop()!;398      399      // collection has never existed400      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected;401      // collection has been burned402      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});403      await collection.burn(collectionOwner);404405      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;406    });407  });408});409410describe('app-promotion stopSponsoringCollection', () => {411  before(async function () {412    await beforeEach(this);413  });414415  it('can not be called by non-admin', async () => {    416    await usingPlaygrounds(async (helper) => {417      const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!];418      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});419      420      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;421      422      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;423      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress});424    });425  });426427  it('should set sponsoring as disabled', async () => {428    await usingPlaygrounds(async (helper) => {429      const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!];430      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}});431      const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address});432      433      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId));434      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId));435      436      expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');437438      // Transactions are not sponsored anymore:439      const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address);440      await token.transfer(collectionOwner, {Substrate: recepient.address});441      const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address);442      expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true);443    });444  });445446  it('should not affect collection which is not sponsored by pallete', async () => {447    await usingPlaygrounds(async (helper) => {448      const collectionOwner = accounts.pop()!;449      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address});450      await collection.confirmSponsorship(collectionOwner);451      452      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;453      454      expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address});455    });456  });457458  it('should reject transaction if collection does not exist', async () => {    459    await usingPlaygrounds(async (helper) => {460      const collectionOwner = accounts.pop()!;461      const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});462      463      await collection.burn(collectionOwner);464      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected;465      await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected;466    });467  });468});469470describe('app-promotion contract sponsoring', () => {471  before(async function () {472    await beforeEach(this);473  });474475  itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => {476    await usingPlaygrounds(async (helper) => {477      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();478      const flipper = await deployFlipper(web3, contractOwner);479      const contractMethods = contractHelpers(web3, contractOwner);480481      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));482      483      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  484      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  485      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({486        confirmed: {487          substrate: palletAddress,488        },489      });490    });491  });492493  itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => {494    await usingPlaygrounds(async (helper) => {495      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();496      const flipper = await deployFlipper(web3, contractOwner);497      const contractMethods = contractHelpers(web3, contractOwner);498499      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;500501      // Contract is self sponsored502      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({503        confirmed: {504          ethereum: flipper.options.address.toLowerCase(),505        },506      });507508      // set promotion sponsoring509      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));510511      // new sponsor is pallet address512      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  513      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  514      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({515        confirmed: {516          substrate: palletAddress,517        },518      });519    });520  });521522  itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => {523    await usingPlaygrounds(async (helper) => {      524      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();525      const flipper = await deployFlipper(web3, contractOwner);526      const contractMethods = contractHelpers(web3, contractOwner);527528      // contract sponsored by pallet529      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));530531      // owner sets self sponsoring532      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;533534      expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true;  535      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  536      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({537        confirmed: {538          ethereum: flipper.options.address.toLowerCase(),539        },540      });541    });542  });543544  itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => {545    await usingPlaygrounds(async (helper) => {      546      const nonAdmin = accounts.pop()!;547      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();548      const flipper = await deployFlipper(web3, contractOwner);549      const contractMethods = contractHelpers(web3, contractOwner);550551      await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;552553      // nonAdmin calls sponsorContract554      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address))).to.be.rejected;555556      // contract still self-sponsored 557      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({558        confirmed: {559          ethereum: flipper.options.address.toLowerCase(),560        },561      });562    });563564    itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => {565      await usingPlaygrounds(async (helper) => {566567      });568    });569  });570571  itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => {572    await usingPlaygrounds(async (helper) => {      573      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);574      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();575      const flipper = await deployFlipper(web3, contractOwner);576      const contractHelper = contractHelpers(web3, contractOwner);577      await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner});578      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});579      await transferBalanceToEth(api, alice, flipper.options.address, 1000n);580581      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));582      await flipper.methods.flip().send({from: caller});583      expect(await flipper.methods.getValue().call()).to.be.true;584585      const callerBalance = await helper.balance.getEthereum(caller);586      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);587588      expect(callerBalance).to.be.equal(1000n * nominal);589      expect(1000n * nominal > contractBalanceAfter).to.be.true;590    });591  });592});593594describe('app-promotion stopSponsoringContract', () => {  595  before(async function () {596    await beforeEach(this);597  });598599  itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => {600    await usingPlaygrounds(async (helper) => {      601      const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper);602      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();603      const flipper = await deployFlipper(web3, contractOwner);604      await transferBalanceToEth(api, alice, flipper.options.address);605      const contractHelper = contractHelpers(web3, contractOwner);606      await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner});607      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));608      await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address));609610      expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false;  611      expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner);  612      expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({613        disabled: null,614      });615616      await flipper.methods.flip().send({from: caller});617      expect(await flipper.methods.getValue().call()).to.be.true;618619      const callerBalance = await helper.balance.getEthereum(caller);620      const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address);621622      // caller payed for call623      expect(1000n * nominal > callerBalance).to.be.true;624      expect(contractBalanceAfter).to.be.equal(1000n * nominal);625    });626  });627628  itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => {629    await usingPlaygrounds(async (helper) => {      630      const nonAdmin = accounts.pop()!;631      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();632      const flipper = await deployFlipper(web3, contractOwner);633634      await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address));635      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;636    });637  });638639  itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => {640    await usingPlaygrounds(async (helper) => {      641      const nonAdmin = accounts.pop()!;642      const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase();643      const flipper = await deployFlipper(web3, contractOwner);644      const contractHelper = contractHelpers(web3, contractOwner);645      await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;646647      await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected;648    });649  });650});651652describe('app-promotion rewards', () => {653  before(async function () {654    await beforeEach(this);655  });656657  it('can not be called by non admin', async () => {658    await usingPlaygrounds(async (helper) => {659      const nonAdmin = accounts.pop()!;660      await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected;661    });662  });663664  it('should increase total staked', async() => {665    await usingPlaygrounds(async (helper) => {666      const staker = accounts.pop()!;667      const totalStakedBefore = await helper.staking.getTotalStaked();668      await helper.staking.stake(staker, 100n * nominal);669670      // Wait for rewards and pay671      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];672      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));673      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));674675      const totalStakedAfter = await helper.staking.getTotalStaked();676      expect(totalStakedAfter >= totalStakedBefore + calculateIncome(100n * nominal, 10n)).to.be.true;677678      // staker can unstake679      await helper.staking.unstake(staker);680      expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n));681    });682  });683684  it('should credit 0.05% for staking period', async () => {    685    await usingPlaygrounds(async helper => {686      const staker = accounts.pop()!;687688      await waitPromotionPeriodDoesntEnd(helper);689      690      await helper.staking.stake(staker, 100n * nominal);691      await helper.staking.stake(staker, 200n * nominal);692693      // wait rewards are available:694      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[1][0];695      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));696697      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));698699      const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);700      expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]);701    });702  });703704  it('shoud be paid for more than one period if payments was missed', async () => {705    await usingPlaygrounds(async (helper) => {706      const staker = accounts.pop()!;707708      await helper.staking.stake(staker, 100n * nominal);709      // wait for two rewards are available:710      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];711      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);712713      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));714      const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});715      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);716      expect(stakedPerBlock[0][1]).to.be.equal(frozenBalanceShouldBe);717718      const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);719720      expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});721    });722  });723  724  it('should not be credited for unstaked (reserved) balance', async () => {725    await usingPlaygrounds(async helper => {726      // staker unstakes before rewards has been payed727      const staker = accounts.pop()!;728      await helper.staking.stake(staker, 100n * nominal);729      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];730      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);731      await helper.staking.unstake(staker);732      733      // so he did not receive any rewards734      const totalBalanceBefore = await helper.balance.getSubstrate(staker.address);735      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));736      const totalBalanceAfter = await helper.balance.getSubstrate(staker.address);737738      expect(totalBalanceBefore).to.be.equal(totalBalanceAfter);739    });740  });741  742  it('should bring compound interest', async () => {743    await usingPlaygrounds(async helper => {744      const staker = accounts.pop()!;745            746      await helper.staking.stake(staker, 100n * nominal);747748      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];749      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));750      751      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));752      let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);753      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n)]);754      755      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);756      await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));757      totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);758      expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2)]);      759    });760  });761762  it.skip('can be paid 1000 rewards in a time', async () => {763    // all other stakes should be unstaked764    await usingPlaygrounds(async (helper) => {765      const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice);766767      // stakers stakes 10 times each768      for (let i = 0; i < 10; i++) {769        await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal)));770      }771      await helper.wait.newBlocks(40);772      const result = await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));773    });774  });775776  it.skip('can handle 40.000 rewards', async () => {777    await usingPlaygrounds(async (helper) => {778      const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);779      const crowdStakes = async () => {780        // each account in the crowd stakes 2 times781        const crowd = await helper.arrange.createCrowd(500, 300n, donor);782        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));783        await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal)));784        // 785      };786787      for (let i = 0; i < 40; i++) {788        await crowdStakes();789      }790791      // TODO pay rewards for some period792    });793  });794});795796function calculatePalleteAddress(palletId: any) {797  const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));798  return encodeAddress(address);799}800801function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {802  const DAY = 7200n;803  const ACCURACY = 1_000_000_000n;804  const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;805  806  if (iter > 1) {807    return calculateIncome(income, calcPeriod, iter - 1);808  } else return income;809}810811// Wait while promotion period less than specified block, to avoid boundary cases812// 0 if this should be the beginning of the period.813async function waitPromotionPeriodDoesntEnd(helper: DevUniqueHelper, waitBlockLessThan = LOCKING_PERIOD / 3n) {814  const relayBlockNumber = (await helper.api!.query.parachainSystem.validationData()).value.relayParentNumber.toNumber(); // await helper.chain.getLatestBlockNumber();815  const currentPeriodBlock = BigInt(relayBlockNumber) % LOCKING_PERIOD;816817  if (currentPeriodBlock > waitBlockLessThan) {818    await helper.wait.forRelayBlockNumber(BigInt(relayBlockNumber) + LOCKING_PERIOD - currentPeriodBlock);819  }820}