difftreelog
feat make scheduler tests to use playgrounds
in: master
1 file changed
tests/src/.outdated/scheduler.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 chai, {expect} from 'chai';18import chaiAsPromised from 'chai-as-promised';19import {20 default as usingApi,21 executeTransaction,22 submitTransactionAsync,23 submitTransactionExpectFailAsync,24} from '../substrate/substrate-api';25import {26 createItemExpectSuccess,27 createCollectionExpectSuccess,28 scheduleTransferExpectSuccess,29 scheduleTransferAndWaitExpectSuccess,30 setCollectionSponsorExpectSuccess,31 confirmSponsorshipExpectSuccess,32 findUnusedAddress,33 UNIQUE,34 enablePublicMintingExpectSuccess,35 addToAllowListExpectSuccess,36 waitNewBlocks,37 makeScheduledId,38 normalizeAccountId,39 getTokenOwner,40 getGenericResult,41 scheduleTransferFundsExpectSuccess,42 getFreeBalance,43 confirmSponsorshipByKeyExpectSuccess,44 scheduleExpectFailure,45 scheduleAfter,46 cancelScheduled,47 requirePallets,48 Pallets,49 getBlockNumber,50 scheduleAt,51} from '../deprecated-helpers/helpers';52import {IKeyringPair, SignatureOptions} from '@polkadot/types/types';53import {RuntimeDispatchInfo} from '@polkadot/types/interfaces';54import {ApiPromise} from '@polkadot/api';55import {objectSpread} from '@polkadot/util';5657chai.use(chaiAsPromised);5859// Check that there are no failing Dispatched events in the block60function checkForFailedSchedulerEvents(api: ApiPromise, events: any[]) {61 return new Promise((res, rej) => {62 let schedulerEventPresent = false;63 64 for (const {event} of events) {65 if (api.events.scheduler.Dispatched.is(event)) {66 schedulerEventPresent = true;67 const result = event.data.result;68 if (result.isErr) {69 const decoded = api.registry.findMetaError(result.asErr.asModule);70 const {method, section} = decoded;71 rej(new Error(`${section}.${method}`));72 }73 }74 }75 res(schedulerEventPresent);76 });77}7879describe('Scheduling token and balance transfers', () => {80 let alice: IKeyringPair;81 let bob: IKeyringPair;8283 before(async function() {84 await requirePallets(this, [Pallets.Scheduler]);8586 await usingApi(async (_, privateKeyWrapper) => {87 alice = privateKeyWrapper('//Alice');88 bob = privateKeyWrapper('//Bob');89 });90 });919293 it('Can delay a transfer of an owned token', async () => {94 await usingApi(async api => {95 const collectionId = await createCollectionExpectSuccess();96 const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');97 const scheduledId = await makeScheduledId();9899 await scheduleTransferAndWaitExpectSuccess(api, collectionId, tokenId, alice, bob, 1, 4, scheduledId);100 });101 });102103 it('Can transfer funds periodically', async () => {104 await usingApi(async api => {105 const scheduledId = await makeScheduledId();106 const waitForBlocks = 1;107 const period = 2;108 const repetitions = 2;109110 const amount = 1n * UNIQUE;111112 await scheduleTransferFundsExpectSuccess(api, amount, alice, bob, waitForBlocks, scheduledId, period, repetitions);113 const bobsBalanceBefore = await getFreeBalance(bob);114115 await waitNewBlocks(waitForBlocks + 1);116 const bobsBalanceAfterFirst = await getFreeBalance(bob);117 expect(bobsBalanceAfterFirst)118 .to.be.equal(119 bobsBalanceBefore + 1n * amount,120 '#1 Balance of the recipient should be increased by 1 * amount',121 );122123 await waitNewBlocks(period);124 const bobsBalanceAfterSecond = await getFreeBalance(bob);125 expect(bobsBalanceAfterSecond)126 .to.be.equal(127 bobsBalanceBefore + 2n * amount,128 '#2 Balance of the recipient should be increased by 2 * amount',129 );130 });131 });132133 it('Can cancel a scheduled operation which has not yet taken effect', async () => {134 await usingApi(async api => {135 const collectionId = await createCollectionExpectSuccess();136 const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');137 const scheduledId = await makeScheduledId();138 const waitForBlocks = 4;139140 const amount = 1;141142 await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, bob, amount, waitForBlocks, scheduledId);143 await expect(cancelScheduled(api, alice, scheduledId)).to.not.be.rejected;144145 await waitNewBlocks(waitForBlocks);146147 expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(alice.address));148 });149 });150151 it('Can cancel a periodic operation (transfer of funds)', async () => {152 await usingApi(async api => {153 const waitForBlocks = 1;154 const period = 3;155 const repetitions = 2;156157 const scheduledId = await makeScheduledId();158 const amount = 1n * UNIQUE;159160 const bobsBalanceBefore = await getFreeBalance(bob);161 await scheduleTransferFundsExpectSuccess(api, amount, alice, bob, waitForBlocks, scheduledId, period, repetitions);162163 await waitNewBlocks(waitForBlocks + 1);164 const bobsBalanceAfterFirst = await getFreeBalance(bob);165 expect(bobsBalanceAfterFirst)166 .to.be.equal(167 bobsBalanceBefore + 1n * amount,168 '#1 Balance of the recipient should be increased by 1 * amount',169 );170171 await expect(cancelScheduled(api, alice, scheduledId)).to.not.be.rejected;172173 await waitNewBlocks(period);174 const bobsBalanceAfterSecond = await getFreeBalance(bob);175 expect(bobsBalanceAfterSecond)176 .to.be.equal(177 bobsBalanceAfterFirst,178 '#2 Balance of the recipient should not be changed',179 );180 });181 });182183 it('Scheduled tasks are transactional', async function() {184 await requirePallets(this, [Pallets.TestUtils]);185186 await usingApi(async api => {187 const scheduledId = await makeScheduledId();188 const waitForBlocks = 4;189190 const initTestVal = 42;191 const changedTestVal = 111;192193 const initTx = api.tx.testUtils.setTestValue(initTestVal);194 await submitTransactionAsync(alice, initTx);195196 const changeErrTx = api.tx.testUtils.setTestValueAndRollback(changedTestVal);197198 await expect(scheduleAfter(199 api,200 changeErrTx,201 alice,202 waitForBlocks,203 scheduledId,204 )).to.not.be.rejected;205206 await waitNewBlocks(waitForBlocks + 1);207208 const testVal = (await api.query.testUtils.testValue()).toNumber();209 expect(testVal, 'The test value should NOT be commited')210 .not.to.be.equal(changedTestVal)211 .and.to.be.equal(initTx);212 });213 });214215 it('Scheduled tasks should take correct fees', async function() {216 await requirePallets(this, [Pallets.TestUtils]);217218 await usingApi(async api => {219 const scheduledId = await makeScheduledId();220 const waitForBlocks = 8;221 const period = 2;222 const repetitions = 2;223224 const dummyTx = api.tx.testUtils.justTakeFee();225 226 const signingInfo = await api.derive.tx.signingInfo(alice.address);227228 // We need to sign the tx because229 // unsigned transactions does not have an inclusion fee230 dummyTx.sign(alice, {231 blockHash: api.genesisHash,232 genesisHash: api.genesisHash,233 runtimeVersion: api.runtimeVersion,234 nonce: signingInfo.nonce,235 });236237 const scheduledLen = dummyTx.callIndex.length;238239 const queryInfo = await api.call.transactionPaymentApi.queryInfo(240 dummyTx.toHex(),241 scheduledLen,242 );243244 const expectedScheduledFee = (await queryInfo as RuntimeDispatchInfo)245 .partialFee.toBigInt();246247 await expect(scheduleAfter(248 api,249 dummyTx,250 alice,251 waitForBlocks,252 scheduledId,253 period,254 repetitions,255 )).to.not.be.rejected;256257 await waitNewBlocks(1);258259 const aliceInitBalance = await getFreeBalance(alice);260 let diff;261262 await waitNewBlocks(waitForBlocks);263264 const aliceBalanceAfterFirst = await getFreeBalance(alice);265 expect(266 aliceBalanceAfterFirst < aliceInitBalance,267 '[after execution #1] Scheduled task should take a fee',268 ).to.be.true;269270 diff = aliceInitBalance - aliceBalanceAfterFirst;271 expect(diff).to.be.equal(272 expectedScheduledFee,273 'Scheduled task should take the right amount of fees',274 );275276 await waitNewBlocks(period);277278 const aliceBalanceAfterSecond = await getFreeBalance(alice);279 expect(280 aliceBalanceAfterSecond < aliceBalanceAfterFirst,281 '[after execution #2] Scheduled task should take a fee',282 ).to.be.true;283284 diff = aliceBalanceAfterFirst - aliceBalanceAfterSecond;285 expect(diff).to.be.equal(286 expectedScheduledFee,287 'Scheduled task should take the right amount of fees',288 );289 });290 });291292 // Check if we can cancel a scheduled periodic operation293 // in the same block in which it is running294 it('Can cancel the periodic sheduled tx when the tx is running', async () => {295 await usingApi(async api => {296 const currentBlockNumber = await getBlockNumber(api);297 const blocksBeforeExecution = 10;298 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;299 300 const scheduledId = await makeScheduledId();301 const scheduledCancelId = await makeScheduledId();302303 const period = 5;304 const repetitions = 5;305306 const initTestVal = 0;307 const incTestVal = initTestVal + 1;308 const finalTestVal = initTestVal + 2;309 await executeTransaction(310 api,311 alice,312 api.tx.testUtils.setTestValue(initTestVal),313 );314315 const incTx = api.tx.testUtils.incTestValue();316 const cancelTx = api.tx.scheduler.cancelNamed(scheduledId);317318 await expect(scheduleAt(319 api, 320 incTx,321 alice, 322 firstExecutionBlockNumber, 323 scheduledId, 324 period, 325 repetitions,326 )).to.not.be.rejected;327328 // Cancel the inc tx after 2 executions329 // *in the same block* in which the second execution is scheduled330 await expect(scheduleAt(331 api,332 cancelTx,333 alice,334 firstExecutionBlockNumber + period,335 scheduledCancelId,336 )).to.not.be.rejected;337338 await waitNewBlocks(blocksBeforeExecution);339340 // execution #0341 expect((await api.query.testUtils.testValue()).toNumber())342 .to.be.equal(incTestVal);343344 await waitNewBlocks(period);345346 // execution #1347 expect((await api.query.testUtils.testValue()).toNumber())348 .to.be.equal(finalTestVal);349350 for (let i = 1; i < repetitions; i++) {351 await waitNewBlocks(period);352 expect((await api.query.testUtils.testValue()).toNumber())353 .to.be.equal(finalTestVal);354 }355 });356 });357358 it('A scheduled operation can cancel itself', async () => {359 await usingApi(async api => {360 const scheduledId = await makeScheduledId();361 const waitForBlocks = 8;362 const period = 2;363 const repetitions = 5;364365 const initTestVal = 0;366 const maxTestVal = 2;367368 await executeTransaction(369 api,370 alice,371 api.tx.testUtils.setTestValue(initTestVal),372 );373374 const selfCancelingTx = api.tx.testUtils.selfCancelingInc(scheduledId, maxTestVal);375376 await expect(scheduleAfter(377 api,378 selfCancelingTx,379 alice,380 waitForBlocks,381 scheduledId,382 period,383 repetitions,384 )).to.not.be.rejected;385386 await waitNewBlocks(waitForBlocks + 1);387388 // execution #0389 expect((await api.query.testUtils.testValue()).toNumber())390 .to.be.equal(initTestVal + 1);391392 await waitNewBlocks(period);393394 // execution #1395 expect((await api.query.testUtils.testValue()).toNumber())396 .to.be.equal(initTestVal + 2);397398 await waitNewBlocks(period);399400 // <canceled>401 expect((await api.query.testUtils.testValue()).toNumber())402 .to.be.equal(initTestVal + 2);403 });404 });405});406407describe('Negative Test: Scheduling', () => {408 let alice: IKeyringPair;409 let bob: IKeyringPair;410411 before(async function() {412 await requirePallets(this, [Pallets.Scheduler]);413414 await usingApi(async (_, privateKeyWrapper) => {415 alice = privateKeyWrapper('//Alice');416 bob = privateKeyWrapper('//Bob');417 });418 });419420 it("Can't overwrite a scheduled ID", async () => {421 await usingApi(async api => {422 const collectionId = await createCollectionExpectSuccess();423 const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');424 const scheduledId = await makeScheduledId();425 const waitForBlocks = 4;426 const amount = 1;427428 await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, bob, amount, waitForBlocks, scheduledId);429 await expect(scheduleAfter(430 api, 431 api.tx.balances.transfer(alice.address, 1n * UNIQUE), 432 bob, 433 /* period = */ 2, 434 scheduledId,435 )).to.be.rejectedWith(/scheduler\.FailedToSchedule/);436437 const bobsBalanceBefore = await getFreeBalance(bob);438439 await waitNewBlocks(waitForBlocks + 1);440441 expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(bob.address));442 expect(bobsBalanceBefore).to.be.equal(await getFreeBalance(bob));443 });444 });445446 it("Can't cancel an operation which is not scheduled", async () => {447 await usingApi(async api => {448 const scheduledId = await makeScheduledId();449 await expect(cancelScheduled(api, alice, scheduledId)).to.be.rejectedWith(/scheduler\.NotFound/);450 });451 });452453 it("Can't cancel a non-owned scheduled operation", async () => {454 await usingApi(async api => {455 const collectionId = await createCollectionExpectSuccess();456 const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');457 const scheduledId = await makeScheduledId();458 const waitForBlocks = 8;459460 const amount = 1;461462 await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, bob, amount, waitForBlocks, scheduledId);463 await expect(cancelScheduled(api, bob, scheduledId)).to.be.rejectedWith(/BadOrigin/);464465 await waitNewBlocks(waitForBlocks + 1);466467 expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(bob.address));468 });469 });470});471472// Implementation of the functionality tested here was postponed/shelved473describe.skip('Sponsoring scheduling', () => {474 let alice: IKeyringPair;475 let bob: IKeyringPair;476477 before(async() => {478 await usingApi(async (_, privateKeyWrapper) => {479 alice = privateKeyWrapper('//Alice');480 bob = privateKeyWrapper('//Bob');481 });482 });483484 it('Can sponsor scheduling a transaction', async () => {485 const collectionId = await createCollectionExpectSuccess();486 await setCollectionSponsorExpectSuccess(collectionId, bob.address);487 await confirmSponsorshipExpectSuccess(collectionId, '//Bob');488489 await usingApi(async api => {490 const scheduledId = await makeScheduledId();491 const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);492493 const bobBalanceBefore = await getFreeBalance(bob);494 const waitForBlocks = 4;495 // no need to wait to check, fees must be deducted on scheduling, immediately496 await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, bob, 0, waitForBlocks, scheduledId);497 const bobBalanceAfter = await getFreeBalance(bob);498 // expect(aliceBalanceAfter == aliceBalanceBefore).to.be.true;499 expect(bobBalanceAfter < bobBalanceBefore).to.be.true;500 // wait for sequentiality matters501 await waitNewBlocks(waitForBlocks - 1);502 });503 });504505 it('Schedules and dispatches a transaction even if the caller has no funds at the time of the dispatch', async () => {506 await usingApi(async (api, privateKeyWrapper) => {507 // Find an empty, unused account508 const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);509510 const collectionId = await createCollectionExpectSuccess();511512 // Add zeroBalance address to allow list513 await enablePublicMintingExpectSuccess(alice, collectionId);514 await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);515516 // Grace zeroBalance with money, enough to cover future transactions517 const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);518 await submitTransactionAsync(alice, balanceTx);519520 // Mint a fresh NFT521 const tokenId = await createItemExpectSuccess(zeroBalance, collectionId, 'NFT');522 const scheduledId = await makeScheduledId();523524 // Schedule transfer of the NFT a few blocks ahead525 const waitForBlocks = 5;526 await scheduleTransferExpectSuccess(api, collectionId, tokenId, zeroBalance, alice, 1, waitForBlocks, scheduledId);527528 // Get rid of the account's funds before the scheduled transaction takes place529 const balanceTx2 = api.tx.balances.transfer(alice.address, UNIQUE * 68n / 100n);530 const events = await submitTransactionAsync(zeroBalance, balanceTx2);531 expect(getGenericResult(events).success).to.be.true;532 /*const emptyBalanceTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0); // do not null reserved?533 const sudoTx = api.tx.sudo.sudo(emptyBalanceTx as any);534 const events = await submitTransactionAsync(alice, sudoTx);535 expect(getGenericResult(events).success).to.be.true;*/536537 // Wait for a certain number of blocks, discarding the ones that already happened while accepting the late transactions538 await waitNewBlocks(waitForBlocks - 3);539540 expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(alice.address));541 });542 });543544 it('Sponsor going bankrupt does not impact a scheduled transaction', async () => {545 const collectionId = await createCollectionExpectSuccess();546547 await usingApi(async (api, privateKeyWrapper) => {548 const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);549 const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);550 await submitTransactionAsync(alice, balanceTx);551552 await setCollectionSponsorExpectSuccess(collectionId, zeroBalance.address);553 await confirmSponsorshipByKeyExpectSuccess(collectionId, zeroBalance);554555 const scheduledId = await makeScheduledId();556 const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);557558 const waitForBlocks = 5;559 await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, zeroBalance, 1, waitForBlocks, scheduledId);560561 const emptyBalanceSponsorTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0);562 const sudoTx = api.tx.sudo.sudo(emptyBalanceSponsorTx as any);563 const events = await submitTransactionAsync(alice, sudoTx);564 expect(getGenericResult(events).success).to.be.true;565566 // Wait for a certain number of blocks, save for the ones that already happened while accepting the late transactions567 await waitNewBlocks(waitForBlocks - 3);568569 expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(zeroBalance.address));570 });571 });572573 it('Exceeding sponsor rate limit without having enough funds prevents scheduling a periodic transaction', async () => {574 const collectionId = await createCollectionExpectSuccess();575 await setCollectionSponsorExpectSuccess(collectionId, bob.address);576 await confirmSponsorshipExpectSuccess(collectionId, '//Bob');577578 await usingApi(async (api, privateKeyWrapper) => {579 const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);580581 await enablePublicMintingExpectSuccess(alice, collectionId);582 await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);583584 const bobBalanceBefore = await getFreeBalance(bob);585586 const createData = {nft: {const_data: [], variable_data: []}};587 const creationTx = api.tx.unique.createItem(collectionId, normalizeAccountId(zeroBalance), createData as any);588 const scheduledId = await makeScheduledId();589590 /*const badTransaction = async function () {591 await submitTransactionExpectFailAsync(zeroBalance, zeroToAlice);592 };593 await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');*/594595 await expect(scheduleAfter(api, creationTx, zeroBalance, 3, scheduledId, 1, 3)).to.be.rejectedWith(/Inability to pay some fees/);596597 expect(await getFreeBalance(bob)).to.be.equal(bobBalanceBefore);598 });599 });600});