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