difftreelog
fix 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 {default as usingApi, submitTransactionAsync} from './substrate/substrate-api';18import {IKeyringPair, ITuple} from '@polkadot/types/types';19import {20 21 createMultipleItemsExpectSuccess,22 isTokenExists,23 getLastTokenId,24 getAllowance,25 approve,26 transferFrom,27 createCollection,28 transfer,29 burnItem,30 normalizeAccountId,31 CrossAccountId,32 createFungibleItemExpectSuccess,33 U128_MAX,34 burnFromExpectSuccess,35 UNIQUE,36 getModuleNames,37 Pallets,38 getBlockNumber,39} from './util/helpers';4041import chai, {use} from 'chai';42import chaiAsPromised from 'chai-as-promised';43import {usingPlaygrounds} from './util/playgrounds';44import {default as waitNewBlocks} from './substrate/wait-new-blocks';4546import {encodeAddress, hdEthereum, mnemonicGenerate} from '@polkadot/util-crypto';47import {stringToU8a} from '@polkadot/util';48import {UniqueHelper} from './util/playgrounds/unique';49import {ApiPromise} from '@polkadot/api';50chai.use(chaiAsPromised);51const expect = chai.expect;5253let alice: IKeyringPair;54let bob: IKeyringPair;55let palletAdmin: IKeyringPair;56let nominal: bigint;57let promotionStartBlock: number | null = null;5859describe('app-promotions.stake extrinsic', () => {60 before(async function() {61 await usingPlaygrounds(async (helper, privateKeyWrapper) => {62 if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();63 alice = privateKeyWrapper('//Alice');64 bob = privateKeyWrapper('//Bob');65 palletAdmin = privateKeyWrapper('//palletAdmin');66 const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));67 nominal = helper.balance.getOneTokenNominal();68 await helper.signTransaction(alice, tx);69 });70 });71 it('will change balance state to "locked", add it to "staked" map, and increase "totalStaked" amount', async () => {72 // arrange: Alice balance = 100073 // act: Alice calls appPromotion.stake(100)74 // assert: Alice locked balance equal 10075 // assert: Alice free balance closeTo 90076 // assert: query appPromotion.staked(Alice) equal [100]77 // assert: query appPromotion.totalStaked() increased by 10078 // act: Alice extrinsic appPromotion.stake(200)79 80 // assert: Alice locked balance equal 30081 // assert: query appPromotion.staked(Alice) equal [100, 200]82 // assert: query appPromotion.totalStaked() increased by 20083 84 await usingPlaygrounds(async (helper, privateKeyWrapper) => {85 const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();86 const staker = await createUser();87 88 89 90 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(nominal / 2n))).to.be.eventually.rejected;91 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;92 expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);93 expect(9n * nominal - await helper.balance.getSubstrate(staker.address) <= nominal / 2n).to.be.true;94 expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(nominal);95 expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + nominal);96 97 await waitNewBlocks(helper.api!, 1);98 99 100 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;101 expect((await helper.api!.rpc.unique.totalStakingLocked(normalizeAccountId(staker))).toBigInt()).to.be.equal(3n * nominal);102 103 const stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]);104 expect(stakedPerBlock.map((x) => x[1])).to.be.deep.equal([nominal, 2n * nominal]);105 });106 });107 108 it('will throws if stake amount is more than total free balance', async () => {109 // arrange: Alice balance = 1000110 // assert: Alice calls appPromotion.stake(1000) throws /// because Alice needs some fee111112 // act: Alice calls appPromotion.stake(700)113 // assert: Alice calls appPromotion.stake(400) throws /// because Alice has ~300 free QTZ and 700 locked114115 await usingPlaygrounds(async helper => { 116 117 const staker = await createUser();118 119 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.rejected;120 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(7n * nominal))).to.be.eventually.fulfilled;121 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(4n * nominal))).to.be.eventually.rejected;122 123 });124 });125 126 it('for different accounts in one block is possible', async () => {127 // arrange: Alice, Bob, Charlie, Dave balance = 1000128 // arrange: Alice, Bob, Charlie, Dave calls appPromotion.stake(100) in the same time129130 // assert: query appPromotion.staked(Alice/Bob/Charlie/Dave) equal [100]131 await usingPlaygrounds(async helper => {132 const crowd = [];133 for(let i = 4; i--;) crowd.push(await createUser());134 135 const promises = crowd.map(async user => helper.signTransaction(user, helper.api!.tx.promotion.stake(nominal)));136 await expect(Promise.all(promises)).to.be.eventually.fulfilled;137 138 for (let i = 0; i < crowd.length; i++){139 expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(crowd[i]))).toBigInt()).to.be.equal(nominal); 140 }141 });142 });143144});145146describe('unstake balance extrinsic', () => {147 before(async function () {148 await usingPlaygrounds(async (helper, privateKeyWrapper) => {149 if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();150 alice = privateKeyWrapper('//Alice');151 bob = privateKeyWrapper('//Bob');152 palletAdmin = privateKeyWrapper('//palletAdmin');153 const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));154 nominal = helper.balance.getOneTokenNominal();155 await helper.signTransaction(alice, tx);156 });157 });158 159 it('will change balance state to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => {160 // arrange: Alice balance = 1000161 // arrange: Alice calls appPromotion.stake(Alice, 500)162163 // act: Alice calls appPromotion.unstake(300)164 // assert: Alice reserved balance to equal 300165 // assert: query appPromotion.staked(Alice) equal [200] /// 500 - 300166 // assert: query appPromotion.pendingUnstake(Alice) to equal [300]167 // assert: query appPromotion.totalStaked() decreased by 300168 await usingPlaygrounds(async helper => {169 const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();170 const staker = await createUser();171 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(5n * nominal))).to.be.eventually.fulfilled;172 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal))).to.be.eventually.fulfilled;173 expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal);174 expect((await helper.api!.rpc.unique.totalStaked(normalizeAccountId(staker))).toBigInt()).to.be.equal(2n * nominal);175 expect((await helper.api!.rpc.unique.totalStaked()).toBigInt()).to.be.equal(totalStakedBefore + 2n * nominal);176 });177 });178 it('will remove from the "staked" map starting from the oldest entry', async () => {179 // arrange: Alice balance = 1000180 // arrange: Alice stakes 100181 // arrange: Alice stakes 200182 // arrange: Alice stakes 300183184 // assert Alice stake is [100, 200, 300]185186187 // act: Alice calls appPromotion.unstake(30)188 // assert: query appPromotion.staked(Alice) to equal [70, 200, 300] /// Can unstake part of stake189 // assert: query appPromotion.pendingUnstake(Alice) to equal [30]190191 // act: Alice calls appPromotion.unstake(170)192 // assert: query appPromotion.staked(Alice) to equal [100, 300] /// Can unstake one stake totally and one more partialy193 // assert: query appPromotion.pendingUnstake(Alice) to equal [30, 170]194195 // act: Alice calls appPromotion.unstake(400)196 // assert: query appPromotion.staked(Alice) to equal [100, 300] /// Can totally unstake 2 stakes in one tx197 // assert: query appPromotion.pendingUnstake(Alice) to equal [30, 170, 400]198 await usingPlaygrounds(async helper => {199 const totalStakedBefore = (await helper.api!.rpc.unique.totalStaked()).toBigInt();200 const staker = await createUser();201 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;202 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;203 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(3n * nominal))).to.be.eventually.fulfilled;204 let stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());205 expect(stakedPerBlock).to.be.deep.equal([nominal, 2n * nominal, 3n * nominal]);206 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(3n * nominal / 10n))).to.be.eventually.fulfilled;207 expect((await helper.api!.rpc.unique.pendingUnstake(normalizeAccountId(staker.address))).toBigInt()).to.be.equal(3n * nominal / 10n);208 stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());209 210 expect(stakedPerBlock).to.be.deep.equal([7n * nominal / 10n, 2n * nominal, 3n * nominal]);211 212 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(17n * nominal / 10n))).to.be.eventually.fulfilled;213 stakedPerBlock = (await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());214 expect(stakedPerBlock).to.be.deep.equal([nominal, 3n * nominal]);215 const unstakedPerBlock = (await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt());216 217 expect(unstakedPerBlock).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n]);218 219 await waitNewBlocks(helper.api!, 1);220 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(4n * nominal))).to.be.eventually.fulfilled;221 expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([]);222 expect((await helper.api!.rpc.unique.pendingUnstakePerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt())).to.be.deep.equal([3n * nominal / 10n, 17n * nominal / 10n, 4n * nominal]);223 });224 225 });226});227228229230describe('Admin adress', () => {231 before(async function () {232 await usingPlaygrounds(async (helper, privateKeyWrapper) => {233 if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();234 alice = privateKeyWrapper('//Alice');235 bob = privateKeyWrapper('//Bob');236 palletAdmin = privateKeyWrapper('//palletAdmin');237 await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());238 const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));239 240 await helper.signTransaction(alice, tx);241 242 nominal = helper.balance.getOneTokenNominal();243 });244 });245246 it('can be set by sudo only', async () => {247 // assert: Sudo calls appPromotion.setAdminAddress(Alice) /// Sudo successfully sets Alice as admin248 // assert: Bob calls appPromotion.setAdminAddress(Bob) throws /// Random account can not set admin249 // assert: Alice calls appPromotion.setAdminAddress(Bob) throws /// Admin account can not set admin250 await usingPlaygrounds(async (helper) => {251 await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled;252 await expect(helper.signTransaction(bob, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.rejected;253 await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled;254 });255 256 });257 258 it('can be any valid CrossAccountId', async () => {259 /// We are not going to set an eth address as a sponsor,260 /// but we do want to check, it doesn't break anything;261262 // arrange: Charlie creates Punks263 // arrange: Sudo calls appPromotion.setAdminAddress(0x0...) success264 // arrange: Sudo calls appPromotion.setAdminAddress(Alice) success265 266 // assert: Alice calls appPromotion.sponsorCollection(Punks.id) success267 268 await usingPlaygrounds(async (helper) => {269 270 const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};271 272 await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(ethAcc)))).to.be.eventually.fulfilled;273 await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin))))).to.be.eventually.fulfilled;274 275 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});276 277 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;278 });279 280 });281282 it('can be reassigned', async () => {283 // arrange: Charlie creates Punks284 // arrange: Sudo calls appPromotion.setAdminAddress(Alice)285 // act: Sudo calls appPromotion.setAdminAddress(Bob)286287 // assert: Alice calls appPromotion.sponsorCollection(Punks.id) throws /// Alice can not set collection sponsor288 // assert: Bob calls appPromotion.sponsorCollection(Punks.id) successful /// Bob can set collection sponsor289290 // act: Sudo calls appPromotion.setAdminAddress(null) successful /// Sudo can set null as a sponsor291 // assert: Bob calls appPromotion.stopSponsoringCollection(Punks.id) throws /// Bob is no longer an admin292 293 await usingPlaygrounds(async (helper) => {294 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});295 296 await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(alice))))).to.be.eventually.fulfilled;297 await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(bob))))).to.be.eventually.fulfilled;298 await expect(helper.signTransaction(alice, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected;299 300 await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled;301 });302 303 });304305});306307describe('App-promotion collection sponsoring', () => {308 before(async function () {309 await usingPlaygrounds(async (helper, privateKeyWrapper) => {310 if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();311 alice = privateKeyWrapper('//Alice');312 bob = privateKeyWrapper('//Bob');313 palletAdmin = privateKeyWrapper('//palletAdmin');314 await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());315 await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());316 317 318 const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));319 await helper.signTransaction(alice, tx);320 321 // const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock));322 // await helper.signTransaction(alice, txStart);323 324 nominal = helper.balance.getOneTokenNominal();325 });326 });327 328 it('can not be set by non admin', async () => {329 330 331 // arrange: Charlie creates Punks332 // arrange: Sudo calls appPromotion.setAdminAddress(Alice)333334 // assert: Random calls appPromotion.sponsorCollection(Punks.id) throws /// Random account can not set sponsoring335 // assert: Alice calls appPromotion.sponsorCollection(Punks.id) success /// Admin account can set sponsoring336 337 await usingPlaygrounds(async (helper) => {338 const colletcion = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});339 340 const collectionId = colletcion.collectionId;341 342 await expect(helper.signTransaction(bob, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected;343 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;344 });345 346 });347348 it('will set pallet address as confirmed admin for collection without sponsor', async () => {349 // arrange: Charlie creates Punks350351 // act: Admin calls appPromotion.sponsorCollection(Punks.id)352353 // assert: query collectionById: Punks sponsoring is confirmed by PalleteAddress354 355 await usingPlaygrounds(async (helper) => {356 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});357 const collectionId = collection.collectionId;358359 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;360 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});361 });362 363 });364365 it('will set pallet address as confirmed admin for collection with unconfirmed sponsor', async () => {366 // arrange: Charlie creates Punks367 // arrange: Charlie calls setCollectionSponsor(Punks.Id, Dave) /// Dave is unconfirmed sponsor368369 // act: Admin calls appPromotion.sponsorCollection(Punks.id)370371 // assert: query collectionById: Punks sponsoring is confirmed by PalleteAddress372 373 await usingPlaygrounds(async (helper) => {374 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});375 await collection.setSponsor(alice, bob.address);376 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});377 378 const collectionId = collection.collectionId;379 380 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;381 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});382 });383 384 });385386 it('will set pallet address as confirmed admin for collection with confirmed sponsor', async () => {387 // arrange: Charlie creates Punks388 // arrange: setCollectionSponsor(Punks.Id, Dave)389 // arrange: confirmSponsorship(Punks.Id, Dave) /// Dave is confirmed sponsor390391 // act: Admin calls appPromotion.sponsorCollection(Punks.id)392393 // assert: query collectionById: Punks sponsoring is confirmed by PalleteAddress394 395 await usingPlaygrounds(async (helper) => {396 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});397 await collection.setSponsor(alice, bob.address);398 399 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});400 expect(await collection.confirmSponsorship(bob)).to.be.true;401 402 const collectionId = collection.collectionId;403 404 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;405 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});406 });407 });408409 it('can be overwritten by collection owner', async () => {410 // arrange: Charlie creates Punks411 // arrange: appPromotion.sponsorCollection(Punks.Id) /// Sponsor of Punks is pallete412413 // act: Charlie calls unique.setCollectionLimits(limits) /// Charlie as owner can successfully change limits414 // assert: query collectionById(Punks.id) 1. sponsored by pallete, 2. limits has been changed415416 // act: Charlie calls setCollectionSponsor(Dave) /// Collection owner reasignes sponsoring417 // assert: query collectionById: Punks sponsoring is unconfirmed by Dave418 419 await usingPlaygrounds(async (helper) => {420 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});421 const collectionId = collection.collectionId;422 423 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;424 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});425 426 expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true;427 expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0);428 429 expect((await collection.setSponsor(alice, bob.address))).to.be.true;430 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: bob.address});431 });432 433 });434 435 it('will keep collection limits set by the owner earlier', async () => {436 // arrange: const limits = {...all possible collection limits}437 // arrange: Charlie creates Punks438 // arrange: Charlie calls unique.setCollectionLimits(limits) /// Owner sets all possible limits439440 // act: Admin calls appPromotion.sponsorCollection(Punks.id)441 // assert: query collectionById(Punks.id) returns limits442 443 await usingPlaygrounds(async (helper) => {444 445 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});446 expect(await collection.setLimits(alice, {sponsorTransferTimeout: 0})).to.be.true;447 const limits = (await collection.getData())?.raw.limits;448 449 const collectionId = collection.collectionId;450 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;451 expect((await collection.getData())?.raw.limits).to.be.deep.equal(limits);452 });453 454 });455 456 it('will throw if collection doesn\'t exist', async () => {457 // assert: Admin calls appPromotion.sponsorCollection(999999999999999) throw 458 await usingPlaygrounds(async (helper) => {459 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(999999999))).to.be.eventually.rejected;460 });461 });462463 it('will throw if collection was burnt', async () => {464 // arrange: Charlie creates Punks465 // arrange: Charlie burns Punks466467 // assert: Admin calls appPromotion.sponsorCollection(Punks.id) throw468 469 await usingPlaygrounds(async (helper) => {470 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});471 const collectionId = collection.collectionId;472 473 expect((await collection.burn(alice))).to.be.true;474 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.rejected;475 });476 477 });478});479480481describe('app-promotion stopSponsoringCollection', () => {482 before(async function () {483 await usingPlaygrounds(async (helper, privateKeyWrapper) => {484 if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();485 alice = privateKeyWrapper('//Alice');486 bob = privateKeyWrapper('//Bob');487 palletAdmin = privateKeyWrapper('//palletAdmin');488 await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());489 await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());490 491 const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));492 await helper.signTransaction(alice, tx);493494 nominal = helper.balance.getOneTokenNominal();495 });496 });497 498 it('can not be called by non-admin', async () => {499 // arrange: Alice creates Punks500 // arrange: appPromotion.sponsorCollection(Punks.Id)501502 // assert: Random calls appPromotion.stopSponsoringCollection(Punks) throws503 // assert: query collectionById(Punks.id): sponsoring confirmed by PalleteAddress504 505 await usingPlaygrounds(async (helper) => {506 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});507 const collectionId = collection.collectionId;508 509 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;510 511 await expect(helper.signTransaction(bob, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;512 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: calculatePalleteAddress('appstake')});513 });514 });515516 it('will set sponsoring as disabled', async () => {517 // arrange: Alice creates Punks518 // arrange: appPromotion.sponsorCollection(Punks.Id)519520 // act: Admin calls appPromotion.stopSponsoringCollection(Punks)521522 // assert: query collectionById(Punks.id): sponsoring unconfirmed523 524 await usingPlaygrounds(async (helper) => {525 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});526 const collectionId = collection.collectionId;527 528 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled;529 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.fulfilled;530 531 expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled');532 });533 });534535 it('will not affect collection which is not sponsored by pallete', async () => {536 // arrange: Alice creates Punks537 // arrange: Alice calls setCollectionSponsoring(Punks)538 // arrange: Alice calls confirmSponsorship(Punks)539540 // act: Admin calls appPromotion.stopSponsoringCollection(A)541 // assert: query collectionById(Punks): Sponsoring: {Confirmed: Alice} /// Alice still collection owner542 543 await usingPlaygrounds(async (helper) => {544 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});545 const collectionId = collection.collectionId;546 expect(await collection.setSponsor(alice, alice.address)).to.be.true;547 expect(await collection.confirmSponsorship(alice)).to.be.true;548 549 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;550 551 expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: alice.address});552 });553 554 });555556 it('will throw if collection does not exist', async () => {557 // arrange: Alice creates Punks558 // arrange: Alice burns Punks559560 // assert: Admin calls appPromotion.stopSponsoringCollection(Punks.id) throws561 // assert: Admin calls appPromotion.stopSponsoringCollection(999999999999999) throw562 563 await usingPlaygrounds(async (helper) => {564 const collection = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'});565 const collectionId = collection.collectionId;566 567 expect((await collection.burn(alice))).to.be.true;568 await expect(helper.signTransaction(palletAdmin, helper.api!.tx.promotion.stopSponsorignCollection(collectionId))).to.be.eventually.rejected;569 });570 });571});572573describe('app-promotion contract sponsoring', () => {574 it('will set contract sponsoring mode and set palletes address as a sponsor', async () => {575 // arrange: Alice deploys Flipper576 577 // act: Admin calls appPromotion.sponsorContract(Flipper.address)578579 // assert: contract.sponsoringMode = TODO580 // assert: contract.sponsor to be PalleteAddress581 });582583 it('will overwrite sponsoring mode and existed sponsor', async () => {584 // arrange: Alice deploys Flipper585 // arrange: Alice sets self sponsoring for Flipper586587 // act: Admin calls appPromotion.sponsorContract(Flipper.address)588589 // assert: contract.sponsoringMode = TODO590 // assert: contract.sponsor to be PalleteAddress591 });592593 it('can be overwritten by contract owner', async () => {594 // arrange: Alice deploys Flipper595 // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)596597 // act: Alice sets self sponsoring for Flipper598599 // assert: contract.sponsoringMode = Self600 // assert: contract.sponsor to be contract601 });602603 it('can not be set by non admin', async () => {604 // arrange: Alice deploys Flipper605 // arrange: Alice sets self sponsoring for Flipper606607 // assert: Random calls appPromotion.sponsorContract(Flipper.address) throws608 // assert: contract.sponsoringMode = Self609 // assert: contract.sponsor to be contract610 });611612 it('will return unused gas fee to app-promotion pallete', async () => {613 // arrange: Alice deploys Flipper614 // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)615616 // assert: Bob calls Flipper - expect balances deposit event do not appears for Bob /// Unused gas fee returns to contract617 // assert: Bobs balance the same618 });619620 it('will failed for non contract address', async () => {621 // arrange: web3 creates new address - 0x0622623 // assert: Admin calls appPromotion.sponsorContract(0x0) throws624 // assert: Admin calls appPromotion.sponsorContract(Substrate address) throws625 });626627 it('will actually sponsor transactions', async () => {628 // TODO test it because this is a new way of contract sponsoring629 });630});631632describe('app-promotion stopSponsoringContract', () => {633 before(async function () {634 await usingPlaygrounds(async (helper, privateKeyWrapper) => {635 if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();636 alice = privateKeyWrapper('//Alice');637 bob = privateKeyWrapper('//Bob');638 palletAdmin = privateKeyWrapper('//palletAdmin');639 await helper.balance.transferToSubstrate(alice, palletAdmin.address, 10n * helper.balance.getOneTokenNominal());640 await helper.balance.transferToSubstrate(alice, calculatePalleteAddress('appstake'), 10n * helper.balance.getOneTokenNominal());641 642 const promotionStartBlock = await helper.chain.getLatestBlockNumber();643 const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));644 await helper.signTransaction(alice, tx);645 646 const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock));647 await helper.signTransaction(alice, txStart);648 649 nominal = helper.balance.getOneTokenNominal();650 });651 });652 653 it('will set contract sponsoring mode as disabled', async () => {654 // arrange: Alice deploys Flipper655 // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)656 657 // act: Admin calls appPromotion.stopSponsoringContract(Flipper.address)658 // assert: contract sponsoring mode = TODO659660 // act: Bob calls Flipper661662 // assert: PalleteAddress balance did not change663 // assert: Bobs balance less than before /// Bob payed some fee664 });665666 it('can not be called by non-admin', async () => {667 // arrange: Alice deploys Flipper668 // arrange: Admin calls appPromotion.sponsorContract(Flipper.address)669670 // assert: Random calls appPromotion.stopSponsoringContract(Flipper.address) throws671 // assert: contract sponsor is PallereAddress672 });673674 it('will not affect a contract which is not sponsored by pallete', async () => {675 // arrange: Alice deploys Flipper676 // arrange: Alice sets self sponsoring for Flipper677 678 // act: Admin calls appPromotion.stopSponsoringContract(Flipper.address) throws679680 // assert: contract.sponsoringMode = Self681 // assert: contract.sponsor to be contract682 });683684 it('will failed for non contract address', async () => {685 // arrange: web3 creates new address - 0x0686687 // expect stopSponsoringContract(0x0) throws688 });689});690691describe('app-promotion rewards', () => {692 const DAY = 7200n;693 694 695 before(async function () {696 await usingPlaygrounds(async (helper, privateKeyWrapper) => {697 if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip();698 alice = privateKeyWrapper('//Alice');699 bob = privateKeyWrapper('//Bob');700 palletAdmin = privateKeyWrapper('//palletAdmin');701 if (promotionStartBlock == null) {702 promotionStartBlock = (await helper.api!.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();703 }704 const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.setAdminAddress(normalizeAccountId(palletAdmin)));705 await helper.signTransaction(alice, tx);706 707 const txStart = helper.api!.tx.sudo.sudo(helper.api!.tx.promotion.startAppPromotion(promotionStartBlock!));708 await helper.signTransaction(alice, txStart);709710 nominal = helper.balance.getOneTokenNominal();711 });712 });713 714 it('will credit 0.05% for staking period', async () => {715 // arrange: bob.stake(10000);716 // arrange: bob.stake(20000);717 // arrange: waitForRewards();718719 // assert: bob.staked to equal [10005, 20010]720 721 await usingPlaygrounds(async helper => {722 const staker = await createUser(50n * nominal);723 await waitForRecalculationBlock(helper.api!);724 725 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(1n * nominal))).to.be.eventually.fulfilled;726 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(2n * nominal))).to.be.eventually.fulfilled;727 await waitForRelayBlock(helper.api!, 36);728 729 730 expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))731 .map(([_, amount]) => amount.toBigInt()))732 .to.be.deep.equal([calculateIncome(nominal, 10n), calculateIncome(2n * nominal, 10n)]);733 });734 735 });736 737 it('will not be credited for unstaked (reserved) balance', async () => {738 // arrange: bob.stake(10000);739 // arrange: bob.unstake(5000);740 // arrange: waitForRewards();741742 // assert: bob.staked to equal [5002.5]743 await usingPlaygrounds(async helper => {744 const staker = await createUser(20n * nominal);745 await waitForRecalculationBlock(helper.api!);746 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;747 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(5n * nominal))).to.be.eventually.fulfilled;748 await waitForRelayBlock(helper.api!, 38);749750 expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))751 .map(([_, amount]) => amount.toBigInt()))752 .to.be.deep.equal([calculateIncome(5n * nominal, 10n)]);753 754 });755 756 });757 758 it('will bring compound interest', async () => {759 // arrange: bob balance = 30000760 // arrange: bob.stake(10000);761 // arrange: bob.stake(10000);762 // arrange: waitForRewards();763764 // assert: bob.staked() equal [10005, 10005, 10005] /// 10_000 * 1.0005765 // act: waitForRewards();766767 // assert: bob.staked() equal [10010.0025, 10010.0025, 10010.0025] /// 10_005 * 1.0005768 // act: bob.unstake(10.0025)769 // assert: bob.staked() equal [10000, 10010.0025, 10010.0025] /// 10_005 * 1.0005770771 // act: waitForRewards();772 // assert: bob.staked() equal [10005, 10015,00750125, 10015,00750125] ///773 await usingPlaygrounds(async helper => {774 const staker = await createUser(40n * nominal);775 776 await waitForRecalculationBlock(helper.api!);777 // const foo = await helper.api!.registry.getChainProperties().778779 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;780 // await waitNewBlocks(helper.api!, 1);781 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;782 // await waitNewBlocks(helper.api!, 1);783 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.stake(10n * nominal))).to.be.eventually.fulfilled;784 // console.log(await helper.balance.getSubstrate(staker.address));785 // await waitNewBlocks(helper.api!, 17);786 await waitForRelayBlock(helper.api!, 34);787 expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))788 .map(([_, amount]) => amount.toBigInt()))789 .to.be.deep.equal([calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n), calculateIncome(10n * nominal, 10n)]);790 791 // console.log(await getBlockNumber(helper.api!));792 // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([block, amount]) => [block.toBigInt(), amount.toBigInt()]));793 // console.log(`${calculateIncome(10n * nominal, 10n)} || ${calculateIncome(10n * nominal, 10n, 2)}`);794 // await waitNewBlocks(helper.api!, 10);795 await waitForRelayBlock(helper.api!, 20);796 // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()));797 // console.log(await helper.balance.getSubstrate(staker.address));798 await expect(helper.signTransaction(staker, helper.api!.tx.promotion.unstake(calculateIncome(10n * nominal, 10n, 2) - 10n * nominal))).to.be.eventually.fulfilled;799 // console.log(calculateIncome(10n * nominal, 10n, 2));800 // console.log(calculateIncome(10n * nominal, 10n, 3));801 // console.log(calculateIncome(10n * nominal, 10n, 4));802 // console.log(calculateIncome(10n * nominal, 10n, 5));803 expect((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker)))804 .map(([_, amount]) => amount.toBigInt()))805 .to.be.deep.equal([10n * nominal, calculateIncome(10n * nominal, 10n, 2), calculateIncome(10n * nominal, 10n, 2)]);806 807 // console.log((await helper.api!.rpc.unique.totalStakedPerBlock(normalizeAccountId(staker))).map(([_, amount]) => amount.toBigInt()));808 809 // console.log(await helper.balance.getSubstrate(staker.address));810 });811 812 });813});814815816function waitForRecalculationBlock(api: ApiPromise): Promise<void> {817 return new Promise<void>(async (resolve, reject) => {818 const unsubscribe = await api.query.system.events((events) => {819 820 events.forEach((record) => {821 822 const {event, phase} = record;823 const types = event.typeDef;824 825 if (event.section === 'promotion' && event.method === 'StakingRecalculation') {826 unsubscribe();827 resolve();828 }829 });830 });831 });832}833834async function waitForRelayBlock(api: ApiPromise, blocks = 1): Promise<void> {835 const current_block = (await api.query.parachainSystem.lastRelayChainBlockNumber()).toNumber();836 return new Promise<void>(async (resolve, reject) => {837 const unsubscribe = await api.query.parachainSystem.validationData(async (data) => {838 // console.log(`${current_block} || ${data.value.relayParentNumber.toNumber()}`);839 if (data.value.relayParentNumber.toNumber() - current_block >= blocks) {840 unsubscribe();841 resolve();842 }843 });844 });845 846}847848849function calculatePalleteAddress(palletId: any) {850 const address = stringToU8a(('modl' + palletId).padEnd(32, '\0'));851 return encodeAddress(address);852}853function calculateIncome(base: bigint, calcPeriod: bigint, iter = 0): bigint {854 const DAY = 7200n;855 const ACCURACY = 1_000_000_000n;856 const income = base + base * (ACCURACY * (calcPeriod * 5n) / (10_000n * DAY)) / ACCURACY ;857 858 if (iter > 1) {859 return calculateIncome(income, calcPeriod, iter - 1);860 } else return income;861}862863async function createUser(amount?: bigint) {864 return await usingPlaygrounds(async helper => {865 const user: IKeyringPair = helper.util.fromSeed(mnemonicGenerate());866 await helper.balance.transferToSubstrate(alice, user.address, amount ? amount : 10n * helper.balance.getOneTokenNominal());867 return user;868 });869}870871const creteAccounts = async (balances: bigint[], donor: IKeyringPair, helper: UniqueHelper) => {872 let nonce = await helper.chain.getNonce(donor.address);873 const tokenNominal = helper.balance.getOneTokenNominal();874 const transactions = [];875 const accounts = [];876 for (const balance of balances) {877 const recepient = helper.util.fromSeed(mnemonicGenerate());878 accounts.push(recepient);879 if (balance !== 0n){880 const tx = helper.constructApiCall('api.tx.balances.transfer', [{Id: recepient.address}, balance * tokenNominal]);881 transactions.push(helper.signTransaction(donor, tx, 'account generation', {nonce}));882 nonce++;883 }884 }885886 await Promise.all(transactions);887 return accounts;888};