difftreelog
fix use wait.forParachainBlockNumber
in: master
1 file changed
tests/src/scheduler.seqtest.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 {expect, itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds} from './util';18import {IKeyringPair} from '@polkadot/types/types';19import {DevUniqueHelper} from './util/playgrounds/unique.dev';2021describe('Scheduling token and balance transfers', () => {22 let superuser: IKeyringPair;23 let alice: IKeyringPair;24 let bob: IKeyringPair;25 let charlie: IKeyringPair;2627 before(async function() {28 await usingPlaygrounds(async (helper, privateKey) => {29 requirePalletsOrSkip(this, helper, [Pallets.Scheduler]);3031 superuser = await privateKey('//Alice');32 const donor = await privateKey({filename: __filename});33 [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);3435 await helper.testUtils.enable();36 });37 });3839 itSub('Can delay a transfer of an owned token', async ({helper}) => {40 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});41 const token = await collection.mintToken(alice);42 const schedulerId = await helper.arrange.makeScheduledId();43 const blocksBeforeExecution = 4;4445 await token.scheduleAfter(schedulerId, blocksBeforeExecution)46 .transfer(alice, {Substrate: bob.address});4748 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});4950 await helper.wait.newBlocks(blocksBeforeExecution + 1);5152 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});53 });5455 itSub('Can transfer funds periodically', async ({helper}) => {56 const scheduledId = await helper.arrange.makeScheduledId();57 const waitForBlocks = 1;5859 const amount = 1n * helper.balance.getOneTokenNominal();60 const periodic = {61 period: 2,62 repetitions: 2,63 };6465 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);6667 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})68 .balance.transferToSubstrate(alice, bob.address, amount);6970 await helper.wait.newBlocks(waitForBlocks + 1);7172 const bobsBalanceAfterFirst = await helper.balance.getSubstrate(bob.address);73 expect(bobsBalanceAfterFirst)74 .to.be.equal(75 bobsBalanceBefore + 1n * amount,76 '#1 Balance of the recipient should be increased by 1 * amount',77 );7879 await helper.wait.newBlocks(periodic.period);8081 const bobsBalanceAfterSecond = await helper.balance.getSubstrate(bob.address);82 expect(bobsBalanceAfterSecond)83 .to.be.equal(84 bobsBalanceBefore + 2n * amount,85 '#2 Balance of the recipient should be increased by 2 * amount',86 );87 });8889 itSub('Can cancel a scheduled operation which has not yet taken effect', async ({helper}) => {90 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});91 const token = await collection.mintToken(alice);9293 const scheduledId = await helper.arrange.makeScheduledId();94 const waitForBlocks = 4;9596 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});9798 await token.scheduleAfter(scheduledId, waitForBlocks)99 .transfer(alice, {Substrate: bob.address});100101 await helper.scheduler.cancelScheduled(alice, scheduledId);102103 await helper.wait.newBlocks(waitForBlocks + 1);104105 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});106 });107108 itSub('Can cancel a periodic operation (transfer of funds)', async ({helper}) => {109 const waitForBlocks = 1;110 const periodic = {111 period: 3,112 repetitions: 2,113 };114115 const scheduledId = await helper.arrange.makeScheduledId();116117 const amount = 1n * helper.balance.getOneTokenNominal();118119 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);120121 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})122 .balance.transferToSubstrate(alice, bob.address, amount);123124 await helper.wait.newBlocks(waitForBlocks + 1);125126 const bobsBalanceAfterFirst = await helper.balance.getSubstrate(bob.address);127128 expect(bobsBalanceAfterFirst)129 .to.be.equal(130 bobsBalanceBefore + 1n * amount,131 '#1 Balance of the recipient should be increased by 1 * amount',132 );133134 await helper.scheduler.cancelScheduled(alice, scheduledId);135 await helper.wait.newBlocks(periodic.period);136137 const bobsBalanceAfterSecond = await helper.balance.getSubstrate(bob.address);138 expect(bobsBalanceAfterSecond)139 .to.be.equal(140 bobsBalanceAfterFirst,141 '#2 Balance of the recipient should not be changed',142 );143 });144145 itSub.ifWithPallets('Scheduled tasks are transactional', [Pallets.TestUtils], async ({helper}) => {146 const scheduledId = await helper.arrange.makeScheduledId();147 const waitForBlocks = 4;148149 const initTestVal = 42;150 const changedTestVal = 111;151152 await helper.testUtils.setTestValue(alice, initTestVal);153154 await helper.scheduler.scheduleAfter<DevUniqueHelper>(scheduledId, waitForBlocks)155 .testUtils.setTestValueAndRollback(alice, changedTestVal);156157 await helper.wait.newBlocks(waitForBlocks + 1);158159 const testVal = await helper.testUtils.testValue();160 expect(testVal, 'The test value should NOT be commited')161 .to.be.equal(initTestVal);162 });163164 itSub.ifWithPallets('Scheduled tasks should take correct fees', [Pallets.TestUtils], async function({helper}) {165 const scheduledId = await helper.arrange.makeScheduledId();166 const waitForBlocks = 4;167 const periodic = {168 period: 2,169 repetitions: 2,170 };171172 const dummyTx = helper.constructApiCall('api.tx.testUtils.justTakeFee', []);173 const scheduledLen = dummyTx.callIndex.length;174175 const expectedScheduledFee = (await helper.getPaymentInfo(alice, dummyTx, scheduledLen))176 .partialFee.toBigInt();177178 await helper.scheduler.scheduleAfter<DevUniqueHelper>(scheduledId, waitForBlocks, {periodic})179 .testUtils.justTakeFee(alice);180181 await helper.wait.newBlocks(1);182183 const aliceInitBalance = await helper.balance.getSubstrate(alice.address);184 let diff;185186 await helper.wait.newBlocks(waitForBlocks);187188 const aliceBalanceAfterFirst = await helper.balance.getSubstrate(alice.address);189 expect(190 aliceBalanceAfterFirst < aliceInitBalance,191 '[after execution #1] Scheduled task should take a fee',192 ).to.be.true;193194 diff = aliceInitBalance - aliceBalanceAfterFirst;195 expect(diff).to.be.equal(196 expectedScheduledFee,197 'Scheduled task should take the right amount of fees',198 );199200 await helper.wait.newBlocks(periodic.period);201202 const aliceBalanceAfterSecond = await helper.balance.getSubstrate(alice.address);203 expect(204 aliceBalanceAfterSecond < aliceBalanceAfterFirst,205 '[after execution #2] Scheduled task should take a fee',206 ).to.be.true;207208 diff = aliceBalanceAfterFirst - aliceBalanceAfterSecond;209 expect(diff).to.be.equal(210 expectedScheduledFee,211 'Scheduled task should take the right amount of fees',212 );213 });214215 // Check if we can cancel a scheduled periodic operation216 // in the same block in which it is running217 itSub.ifWithPallets('Can cancel the periodic sheduled tx when the tx is running', [Pallets.TestUtils], async ({helper}) => {218 const currentBlockNumber = await helper.chain.getLatestBlockNumber();219 const blocksBeforeExecution = 10;220 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;221222 const [223 scheduledId,224 scheduledCancelId,225 ] = await helper.arrange.makeScheduledIds(2);226227 const periodic = {228 period: 5,229 repetitions: 5,230 };231232 const initTestVal = 0;233 const incTestVal = initTestVal + 1;234 const finalTestVal = initTestVal + 2;235236 await helper.testUtils.setTestValue(alice, initTestVal);237238 await helper.scheduler.scheduleAt<DevUniqueHelper>(scheduledId, firstExecutionBlockNumber, {periodic})239 .testUtils.incTestValue(alice);240241 // Cancel the inc tx after 2 executions242 // *in the same block* in which the second execution is scheduled243 await helper.scheduler.scheduleAt(244 scheduledCancelId,245 firstExecutionBlockNumber + periodic.period,246 ).scheduler.cancelScheduled(alice, scheduledId);247248 await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber);249250 // execution #0251 expect(await helper.testUtils.testValue())252 .to.be.equal(incTestVal);253254 await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber + periodic.period);255256 // execution #1257 expect(await helper.testUtils.testValue())258 .to.be.equal(finalTestVal);259260 for (let i = 1; i < periodic.repetitions; i++) {261 await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber + periodic.period * (i + 1));262 expect(await helper.testUtils.testValue())263 .to.be.equal(finalTestVal);264 }265 });266267 itSub.ifWithPallets('A scheduled operation can cancel itself', [Pallets.TestUtils], async ({helper}) => {268 const scheduledId = await helper.arrange.makeScheduledId();269 const waitForBlocks = 4;270 const periodic = {271 period: 2,272 repetitions: 5,273 };274275 const initTestVal = 0;276 const maxTestVal = 2;277278 await helper.testUtils.setTestValue(alice, initTestVal);279280 await helper.scheduler.scheduleAfter<DevUniqueHelper>(scheduledId, waitForBlocks, {periodic})281 .testUtils.selfCancelingInc(alice, scheduledId, maxTestVal);282283 await helper.wait.newBlocks(waitForBlocks + 1);284285 // execution #0286 expect(await helper.testUtils.testValue())287 .to.be.equal(initTestVal + 1);288289 await helper.wait.newBlocks(periodic.period);290291 // execution #1292 expect(await helper.testUtils.testValue())293 .to.be.equal(initTestVal + 2);294295 await helper.wait.newBlocks(periodic.period);296297 // <canceled>298 expect(await helper.testUtils.testValue())299 .to.be.equal(initTestVal + 2);300 });301302 itSub('Root can cancel any scheduled operation', async ({helper}) => {303 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});304 const token = await collection.mintToken(bob);305306 const scheduledId = await helper.arrange.makeScheduledId();307 const waitForBlocks = 4;308309 await token.scheduleAfter(scheduledId, waitForBlocks)310 .transfer(bob, {Substrate: alice.address});311312 await helper.getSudo().scheduler.cancelScheduled(superuser, scheduledId);313314 await helper.wait.newBlocks(waitForBlocks + 1);315316 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});317 });318319 itSub('Root can set prioritized scheduled operation', async ({helper}) => {320 const scheduledId = await helper.arrange.makeScheduledId();321 const waitForBlocks = 4;322323 const amount = 42n * helper.balance.getOneTokenNominal();324325 const balanceBefore = await helper.balance.getSubstrate(charlie.address);326327 await helper.getSudo()328 .scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42})329 .balance.forceTransferToSubstrate(superuser, bob.address, charlie.address, amount);330331 await helper.wait.newBlocks(waitForBlocks + 1);332333 const balanceAfter = await helper.balance.getSubstrate(charlie.address);334335 expect(balanceAfter > balanceBefore).to.be.true;336337 const diff = balanceAfter - balanceBefore;338 expect(diff).to.be.equal(amount);339 });340341 itSub("Root can change scheduled operation's priority", async ({helper}) => {342 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});343 const token = await collection.mintToken(bob);344345 const scheduledId = await helper.arrange.makeScheduledId();346 const waitForBlocks = 6;347348 await token.scheduleAfter(scheduledId, waitForBlocks)349 .transfer(bob, {Substrate: alice.address});350351 const priority = 112;352 await helper.getSudo().scheduler.changePriority(superuser, scheduledId, priority);353354 const priorityChanged = await helper.wait.event(355 waitForBlocks,356 'scheduler',357 'PriorityChanged',358 );359360 expect(priorityChanged !== null).to.be.true;361 expect(priorityChanged!.event.data[2].toString()).to.be.equal(priority.toString());362 });363364 itSub('Prioritized operations execute in valid order', async ({helper}) => {365 const [366 scheduledFirstId,367 scheduledSecondId,368 ] = await helper.arrange.makeScheduledIds(2);369370 const currentBlockNumber = await helper.chain.getLatestBlockNumber();371 const blocksBeforeExecution = 6;372 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;373374 const prioHigh = 0;375 const prioLow = 255;376377 const periodic = {378 period: 6,379 repetitions: 2,380 };381382 const amount = 1n * helper.balance.getOneTokenNominal();383384 // Scheduler a task with a lower priority first, then with a higher priority385 await helper.getSudo().scheduler.scheduleAt(scheduledFirstId, firstExecutionBlockNumber, {priority: prioLow, periodic})386 .balance.forceTransferToSubstrate(superuser, alice.address, bob.address, amount);387388 await helper.getSudo().scheduler.scheduleAt(scheduledSecondId, firstExecutionBlockNumber, {priority: prioHigh, periodic})389 .balance.forceTransferToSubstrate(superuser, alice.address, bob.address, amount);390391 const capture = await helper.arrange.captureEvents('scheduler', 'Dispatched');392393 await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber);394395 // Flip priorities396 await helper.getSudo().scheduler.changePriority(superuser, scheduledFirstId, prioHigh);397 await helper.getSudo().scheduler.changePriority(superuser, scheduledSecondId, prioLow);398399 await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber + periodic.period);400401 const dispatchEvents = capture.extractCapturedEvents();402 expect(dispatchEvents.length).to.be.equal(4);403404 const dispatchedIds = dispatchEvents.map(r => r.event.data[1].toString());405406 const firstExecuctionIds = [dispatchedIds[0], dispatchedIds[1]];407 const secondExecuctionIds = [dispatchedIds[2], dispatchedIds[3]];408409 expect(firstExecuctionIds[0]).to.be.equal(scheduledSecondId);410 expect(firstExecuctionIds[1]).to.be.equal(scheduledFirstId);411412 expect(secondExecuctionIds[0]).to.be.equal(scheduledFirstId);413 expect(secondExecuctionIds[1]).to.be.equal(scheduledSecondId);414 });415416 itSub('Periodic operations always can be rescheduled', async ({helper}) => {417 const maxScheduledPerBlock = 50;418 const numFilledBlocks = 3;419 const ids = await helper.arrange.makeScheduledIds(numFilledBlocks * maxScheduledPerBlock + 1);420 const periodicId = ids[0];421 const fillIds = ids.slice(1);422423 const initTestVal = 0;424 const firstExecTestVal = 1;425 const secondExecTestVal = 2;426 await helper.testUtils.setTestValue(alice, initTestVal);427428 const currentBlockNumber = await helper.chain.getLatestBlockNumber();429 const blocksBeforeExecution = 8;430 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;431432 const period = 5;433434 const periodic = {435 period,436 repetitions: 2,437 };438439 // Fill `numFilledBlocks` blocks beginning from the block in which the second execution should occur440 const txs = [];441 for (let offset = 0; offset < numFilledBlocks; offset ++) {442 for (let i = 0; i < maxScheduledPerBlock; i++) {443444 const scheduledTx = helper.constructApiCall('api.tx.balances.transfer', [bob.address, 1n]);445446 const when = firstExecutionBlockNumber + period + offset;447 const tx = helper.constructApiCall('api.tx.scheduler.scheduleNamed', [fillIds[i + offset * maxScheduledPerBlock], when, null, null, scheduledTx]);448449 txs.push(tx);450 }451 }452 await helper.executeExtrinsic(alice, 'api.tx.testUtils.batchAll', [txs], true);453454 await helper.scheduler.scheduleAt<DevUniqueHelper>(periodicId, firstExecutionBlockNumber, {periodic})455 .testUtils.incTestValue(alice);456457 await helper.wait.newBlocks(blocksBeforeExecution);458 expect(await helper.testUtils.testValue()).to.be.equal(firstExecTestVal);459460 await helper.wait.newBlocks(period + numFilledBlocks);461462 // The periodic operation should be postponed by `numFilledBlocks`463 for (let i = 0; i < numFilledBlocks; i++) {464 expect(await helper.testUtils.testValue(firstExecutionBlockNumber + period + i)).to.be.equal(firstExecTestVal);465 }466467 // After the `numFilledBlocks` the periodic operation will eventually be executed468 expect(await helper.testUtils.testValue()).to.be.equal(secondExecTestVal);469 });470471 itSub('scheduled operations does not change nonce', async ({helper}) => {472 const scheduledId = await helper.arrange.makeScheduledId();473 const blocksBeforeExecution = 4;474475 await helper.scheduler476 .scheduleAfter<DevUniqueHelper>(scheduledId, blocksBeforeExecution)477 .balance.transferToSubstrate(alice, bob.address, 1n);478479 const initNonce = await helper.chain.getNonce(alice.address);480481 await helper.wait.newBlocks(blocksBeforeExecution + 1);482483 const finalNonce = await helper.chain.getNonce(alice.address);484485 expect(initNonce).to.be.equal(finalNonce);486 });487});488489describe('Negative Test: Scheduling', () => {490 let alice: IKeyringPair;491 let bob: IKeyringPair;492493 before(async function() {494 await usingPlaygrounds(async (helper, privateKey) => {495 requirePalletsOrSkip(this, helper, [Pallets.Scheduler]);496497 const donor = await privateKey({filename: __filename});498 [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);499500 await helper.testUtils.enable();501 });502 });503504 itSub("Can't overwrite a scheduled ID", async ({helper}) => {505 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});506 const token = await collection.mintToken(alice);507508 const scheduledId = await helper.arrange.makeScheduledId();509 const waitForBlocks = 4;510511 await token.scheduleAfter(scheduledId, waitForBlocks)512 .transfer(alice, {Substrate: bob.address});513514 const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks);515 await expect(scheduled.balance.transferToSubstrate(alice, bob.address, 1n * helper.balance.getOneTokenNominal()))516 .to.be.rejectedWith(/scheduler\.FailedToSchedule/);517518 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);519520 await helper.wait.newBlocks(waitForBlocks + 1);521522 const bobsBalanceAfter = await helper.balance.getSubstrate(bob.address);523524 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});525 expect(bobsBalanceBefore).to.be.equal(bobsBalanceAfter);526 });527528 itSub("Can't cancel an operation which is not scheduled", async ({helper}) => {529 const scheduledId = await helper.arrange.makeScheduledId();530 await expect(helper.scheduler.cancelScheduled(alice, scheduledId))531 .to.be.rejectedWith(/scheduler\.NotFound/);532 });533534 itSub("Can't cancel a non-owned scheduled operation", async ({helper}) => {535 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});536 const token = await collection.mintToken(alice);537538 const scheduledId = await helper.arrange.makeScheduledId();539 const waitForBlocks = 4;540541 await token.scheduleAfter(scheduledId, waitForBlocks)542 .transfer(alice, {Substrate: bob.address});543544 await expect(helper.scheduler.cancelScheduled(bob, scheduledId))545 .to.be.rejectedWith(/BadOrigin/);546547 await helper.wait.newBlocks(waitForBlocks + 1);548549 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});550 });551552 itSub("Regular user can't set prioritized scheduled operation", async ({helper}) => {553 const scheduledId = await helper.arrange.makeScheduledId();554 const waitForBlocks = 4;555556 const amount = 42n * helper.balance.getOneTokenNominal();557558 const balanceBefore = await helper.balance.getSubstrate(bob.address);559560 const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42});561 562 await expect(scheduled.balance.transferToSubstrate(alice, bob.address, amount))563 .to.be.rejectedWith(/BadOrigin/);564565 await helper.wait.newBlocks(waitForBlocks + 1);566567 const balanceAfter = await helper.balance.getSubstrate(bob.address);568569 expect(balanceAfter).to.be.equal(balanceBefore);570 });571572 itSub("Regular user can't change scheduled operation's priority", async ({helper}) => {573 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});574 const token = await collection.mintToken(bob);575576 const scheduledId = await helper.arrange.makeScheduledId();577 const waitForBlocks = 4;578579 await token.scheduleAfter(scheduledId, waitForBlocks)580 .transfer(bob, {Substrate: alice.address});581582 const priority = 112;583 await expect(helper.scheduler.changePriority(alice, scheduledId, priority))584 .to.be.rejectedWith(/BadOrigin/);585586 const priorityChanged = await helper.wait.event(587 waitForBlocks,588 'scheduler',589 'PriorityChanged',590 );591592 expect(priorityChanged === null).to.be.true;593 });594});595596// Implementation of the functionality tested here was postponed/shelved597describe.skip('Sponsoring scheduling', () => {598 // let alice: IKeyringPair;599 // let bob: IKeyringPair;600601 // before(async() => {602 // await usingApi(async (_, privateKey) => {603 // alice = privateKey('//Alice');604 // bob = privateKey('//Bob');605 // });606 // });607608 it('Can sponsor scheduling a transaction', async () => {609 // const collectionId = await createCollectionExpectSuccess();610 // await setCollectionSponsorExpectSuccess(collectionId, bob.address);611 // await confirmSponsorshipExpectSuccess(collectionId, '//Bob');612613 // await usingApi(async api => {614 // const scheduledId = await makeScheduledId();615 // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);616617 // const bobBalanceBefore = await getFreeBalance(bob);618 // const waitForBlocks = 4;619 // // no need to wait to check, fees must be deducted on scheduling, immediately620 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, bob, 0, waitForBlocks, scheduledId);621 // const bobBalanceAfter = await getFreeBalance(bob);622 // // expect(aliceBalanceAfter == aliceBalanceBefore).to.be.true;623 // expect(bobBalanceAfter < bobBalanceBefore).to.be.true;624 // // wait for sequentiality matters625 // await waitNewBlocks(waitForBlocks - 1);626 // });627 });628629 it('Schedules and dispatches a transaction even if the caller has no funds at the time of the dispatch', async () => {630 // await usingApi(async (api, privateKey) => {631 // // Find an empty, unused account632 // const zeroBalance = await findUnusedAddress(api, privateKey);633634 // const collectionId = await createCollectionExpectSuccess();635636 // // Add zeroBalance address to allow list637 // await enablePublicMintingExpectSuccess(alice, collectionId);638 // await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);639640 // // Grace zeroBalance with money, enough to cover future transactions641 // const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);642 // await submitTransactionAsync(alice, balanceTx);643644 // // Mint a fresh NFT645 // const tokenId = await createItemExpectSuccess(zeroBalance, collectionId, 'NFT');646 // const scheduledId = await makeScheduledId();647648 // // Schedule transfer of the NFT a few blocks ahead649 // const waitForBlocks = 5;650 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, zeroBalance, alice, 1, waitForBlocks, scheduledId);651652 // // Get rid of the account's funds before the scheduled transaction takes place653 // const balanceTx2 = api.tx.balances.transfer(alice.address, UNIQUE * 68n / 100n);654 // const events = await submitTransactionAsync(zeroBalance, balanceTx2);655 // expect(getGenericResult(events).success).to.be.true;656 // /*const emptyBalanceTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0); // do not null reserved?657 // const sudoTx = api.tx.sudo.sudo(emptyBalanceTx as any);658 // const events = await submitTransactionAsync(alice, sudoTx);659 // expect(getGenericResult(events).success).to.be.true;*/660661 // // Wait for a certain number of blocks, discarding the ones that already happened while accepting the late transactions662 // await waitNewBlocks(waitForBlocks - 3);663664 // expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(alice.address));665 // });666 });667668 it('Sponsor going bankrupt does not impact a scheduled transaction', async () => {669 // const collectionId = await createCollectionExpectSuccess();670671 // await usingApi(async (api, privateKey) => {672 // const zeroBalance = await findUnusedAddress(api, privateKey);673 // const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);674 // await submitTransactionAsync(alice, balanceTx);675676 // await setCollectionSponsorExpectSuccess(collectionId, zeroBalance.address);677 // await confirmSponsorshipByKeyExpectSuccess(collectionId, zeroBalance);678679 // const scheduledId = await makeScheduledId();680 // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);681682 // const waitForBlocks = 5;683 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, zeroBalance, 1, waitForBlocks, scheduledId);684685 // const emptyBalanceSponsorTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0);686 // const sudoTx = api.tx.sudo.sudo(emptyBalanceSponsorTx as any);687 // const events = await submitTransactionAsync(alice, sudoTx);688 // expect(getGenericResult(events).success).to.be.true;689690 // // Wait for a certain number of blocks, save for the ones that already happened while accepting the late transactions691 // await waitNewBlocks(waitForBlocks - 3);692693 // expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(zeroBalance.address));694 // });695 });696697 it('Exceeding sponsor rate limit without having enough funds prevents scheduling a periodic transaction', async () => {698 // const collectionId = await createCollectionExpectSuccess();699 // await setCollectionSponsorExpectSuccess(collectionId, bob.address);700 // await confirmSponsorshipExpectSuccess(collectionId, '//Bob');701702 // await usingApi(async (api, privateKey) => {703 // const zeroBalance = await findUnusedAddress(api, privateKey);704705 // await enablePublicMintingExpectSuccess(alice, collectionId);706 // await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);707708 // const bobBalanceBefore = await getFreeBalance(bob);709710 // const createData = {nft: {const_data: [], variable_data: []}};711 // const creationTx = api.tx.unique.createItem(collectionId, normalizeAccountId(zeroBalance), createData as any);712 // const scheduledId = await makeScheduledId();713714 // /*const badTransaction = async function () {715 // await submitTransactionExpectFailAsync(zeroBalance, zeroToAlice);716 // };717 // await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');*/718719 // await expect(scheduleAfter(api, creationTx, zeroBalance, 3, scheduledId, 1, 3)).to.be.rejectedWith(/Inability to pay some fees/);720721 // expect(await getFreeBalance(bob)).to.be.equal(bobBalanceBefore);722 // });723 });724});