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