difftreelog
fix(scheduler) minimize wait time in test, comment sponsorship, remove unused imports
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 {18 default as usingApi,19 submitTransactionAsync,20 submitTransactionExpectFailAsync,21} from '../substrate/substrate-api';22import {23 createItemExpectSuccess,24 createCollectionExpectSuccess,25 scheduleTransferExpectSuccess,26 setCollectionSponsorExpectSuccess,27 confirmSponsorshipExpectSuccess,28 findUnusedAddress,29 UNIQUE,30 enablePublicMintingExpectSuccess,31 addToAllowListExpectSuccess,32 waitNewBlocks,33 normalizeAccountId,34 getTokenOwner,35 getGenericResult,36 getFreeBalance,37 confirmSponsorshipByKeyExpectSuccess,38 scheduleExpectFailure,39 scheduleAfter,40} from './util/helpers';41import {expect, itSub, Pallets, usingPlaygrounds} from './util/playgrounds';42import {IKeyringPair} from '@polkadot/types/types';4344describe('Scheduling token and balance transfers', () => {45 let alice: IKeyringPair;46 let bob: IKeyringPair;47 let charlie: IKeyringPair;4849 before(async () => {50 await usingPlaygrounds(async (_, privateKeyWrapper) => {51 alice = privateKeyWrapper('//Alice');52 bob = privateKeyWrapper('//Bob');53 charlie = privateKeyWrapper('//Charlie');54 });55 });5657 itSub.ifWithPallets('Can delay a transfer of an owned token', [Pallets.Scheduler], async ({helper}) => {58 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});59 const token = await collection.mintToken(alice);60 const schedulerId = await helper.arrange.makeScheduledId();61 const blocksBeforeExecution = 4;6263 await token.scheduleAfter(schedulerId, blocksBeforeExecution)64 .transfer(alice, {Substrate: bob.address});6566 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});6768 await helper.wait.newBlocks(blocksBeforeExecution + 1);6970 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});71 });7273 itSub.ifWithPallets('Can transfer funds periodically', [Pallets.Scheduler], async ({helper}) => {74 const scheduledId = await helper.arrange.makeScheduledId();75 const waitForBlocks = 1;7677 const amount = 1n * UNIQUE;78 const periodic = {79 period: 2,80 repetitions: 2,81 };8283 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);8485 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})86 .balance.transferToSubstrate(alice, bob.address, amount);8788 await helper.wait.newBlocks(waitForBlocks + 1);8990 const bobsBalanceAfterFirst = await helper.balance.getSubstrate(bob.address);91 expect(bobsBalanceAfterFirst)92 .to.be.equal(93 bobsBalanceBefore + 1n * amount,94 '#1 Balance of the recipient should be increased by 1 * amount',95 );9697 await helper.wait.newBlocks(periodic.period);9899 const bobsBalanceAfterSecond = await helper.balance.getSubstrate(bob.address);100 expect(bobsBalanceAfterSecond)101 .to.be.equal(102 bobsBalanceBefore + 2n * amount,103 '#2 Balance of the recipient should be increased by 2 * amount',104 );105 });106107 itSub.ifWithPallets('Can cancel a scheduled operation which has not yet taken effect', [Pallets.Scheduler], async ({helper}) => {108 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});109 const token = await collection.mintToken(alice);110111 const scheduledId = await helper.arrange.makeScheduledId();112 const waitForBlocks = 4;113114 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});115116 await token.scheduleAfter(scheduledId, waitForBlocks)117 .transfer(alice, {Substrate: bob.address});118119 await helper.scheduler.cancelScheduled(alice, scheduledId);120121 await waitNewBlocks(waitForBlocks + 1);122123 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});124 });125126 itSub.ifWithPallets('Can cancel a periodic operation (transfer of funds)', [Pallets.Scheduler], async ({helper}) => {127 const waitForBlocks = 1;128 const periodic = {129 period: 3,130 repetitions: 2,131 };132133 const scheduledId = await helper.arrange.makeScheduledId();134135 const amount = 1n * UNIQUE;136137 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);138139 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})140 .balance.transferToSubstrate(alice, bob.address, amount);141142 await helper.wait.newBlocks(waitForBlocks + 1);143144 const bobsBalanceAfterFirst = await helper.balance.getSubstrate(bob.address);145146 expect(bobsBalanceAfterFirst)147 .to.be.equal(148 bobsBalanceBefore + 1n * amount,149 '#1 Balance of the recipient should be increased by 1 * amount',150 );151152 await helper.scheduler.cancelScheduled(alice, scheduledId);153 await helper.wait.newBlocks(periodic.period);154155 const bobsBalanceAfterSecond = await helper.balance.getSubstrate(bob.address);156 expect(bobsBalanceAfterSecond)157 .to.be.equal(158 bobsBalanceAfterFirst,159 '#2 Balance of the recipient should not be changed',160 );161 });162163 itSub.ifWithPallets('Scheduled tasks are transactional', [Pallets.Scheduler, Pallets.TestUtils], async ({helper}) => {164 const scheduledId = await helper.arrange.makeScheduledId();165 const waitForBlocks = 4;166167 const initTestVal = 42;168 const changedTestVal = 111;169170 await helper.executeExtrinsic(171 alice,172 'api.tx.testUtils.setTestValue',173 [initTestVal],174 true,175 );176177 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks)178 .executeExtrinsic(179 alice,180 'api.tx.testUtils.setTestValueAndRollback',181 [changedTestVal],182 true,183 );184185 await helper.wait.newBlocks(waitForBlocks + 1);186187 const testVal = (await helper.api!.query.testUtils.testValue()).toNumber();188 expect(testVal, 'The test value should NOT be commited')189 .to.be.equal(initTestVal);190 });191192 itSub.ifWithPallets('Scheduled tasks should take correct fees', [Pallets.Scheduler, Pallets.TestUtils], async function({helper}) {193 const scheduledId = await helper.arrange.makeScheduledId();194 const waitForBlocks = 8;195 const periodic = {196 period: 2,197 repetitions: 2,198 };199200 const dummyTx = helper.constructApiCall('api.tx.testUtils.justTakeFee', []);201 const scheduledLen = dummyTx.callIndex.length;202203 const expectedScheduledFee = (await helper.getPaymentInfo(alice, dummyTx, scheduledLen))204 .partialFee.toBigInt();205206 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})207 .executeExtrinsic(alice, 'api.tx.testUtils.justTakeFee', [], true);208209 await helper.wait.newBlocks(1);210211 const aliceInitBalance = await helper.balance.getSubstrate(alice.address);212 let diff;213214 await helper.wait.newBlocks(waitForBlocks);215216 const aliceBalanceAfterFirst = await helper.balance.getSubstrate(alice.address);217 expect(218 aliceBalanceAfterFirst < aliceInitBalance,219 '[after execution #1] Scheduled task should take a fee',220 ).to.be.true;221222 diff = aliceInitBalance - aliceBalanceAfterFirst;223 expect(diff).to.be.equal(224 expectedScheduledFee,225 'Scheduled task should take the right amount of fees',226 );227228 await helper.wait.newBlocks(periodic.period);229230 const aliceBalanceAfterSecond = await helper.balance.getSubstrate(alice.address);231 expect(232 aliceBalanceAfterSecond < aliceBalanceAfterFirst,233 '[after execution #2] Scheduled task should take a fee',234 ).to.be.true;235236 diff = aliceBalanceAfterFirst - aliceBalanceAfterSecond;237 expect(diff).to.be.equal(238 expectedScheduledFee,239 'Scheduled task should take the right amount of fees',240 );241 });242243 // Check if we can cancel a scheduled periodic operation244 // in the same block in which it is running245 itSub.ifWithPallets('Can cancel the periodic sheduled tx when the tx is running', [Pallets.Scheduler, Pallets.TestUtils], async ({helper}) => {246 const currentBlockNumber = await helper.chain.getLatestBlockNumber();247 const blocksBeforeExecution = 10;248 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;249250 const [251 scheduledId,252 scheduledCancelId,253 ] = await helper.arrange.makeScheduledIds(2);254255 const periodic = {256 period: 5,257 repetitions: 5,258 };259260 const initTestVal = 0;261 const incTestVal = initTestVal + 1;262 const finalTestVal = initTestVal + 2;263264 await helper.executeExtrinsic(265 alice,266 'api.tx.testUtils.setTestValue',267 [initTestVal],268 true,269 );270271 await helper.scheduler.scheduleAt(scheduledId, firstExecutionBlockNumber, {periodic})272 .executeExtrinsic(273 alice,274 'api.tx.testUtils.incTestValue',275 [],276 true,277 );278279 // Cancel the inc tx after 2 executions280 // *in the same block* in which the second execution is scheduled281 await helper.scheduler.scheduleAt(282 scheduledCancelId,283 firstExecutionBlockNumber + periodic.period,284 ).scheduler.cancelScheduled(alice, scheduledId);285286 await helper.wait.newBlocks(blocksBeforeExecution);287288 // execution #0289 expect((await helper.api!.query.testUtils.testValue()).toNumber())290 .to.be.equal(incTestVal);291292 await helper.wait.newBlocks(periodic.period);293294 // execution #1295 expect((await helper.api!.query.testUtils.testValue()).toNumber())296 .to.be.equal(finalTestVal);297298 for (let i = 1; i < periodic.repetitions; i++) {299 await waitNewBlocks(periodic.period);300 expect((await helper.api!.query.testUtils.testValue()).toNumber())301 .to.be.equal(finalTestVal);302 }303 });304305 itSub.ifWithPallets('A scheduled operation can cancel itself', [Pallets.Scheduler, Pallets.TestUtils], async ({helper}) => {306 const scheduledId = await helper.arrange.makeScheduledId();307 const waitForBlocks = 8;308 const periodic = {309 period: 2,310 repetitions: 5,311 };312313 const initTestVal = 0;314 const maxTestVal = 2;315316 await helper.executeExtrinsic(317 alice,318 'api.tx.testUtils.setTestValue',319 [initTestVal],320 true,321 );322323 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})324 .executeExtrinsic(325 alice,326 'api.tx.testUtils.selfCancelingInc',327 [scheduledId, maxTestVal],328 true,329 );330331 await helper.wait.newBlocks(waitForBlocks + 1);332333 // execution #0334 expect((await helper.api!.query.testUtils.testValue()).toNumber())335 .to.be.equal(initTestVal + 1);336337 await helper.wait.newBlocks(periodic.period);338339 // execution #1340 expect((await helper.api!.query.testUtils.testValue()).toNumber())341 .to.be.equal(initTestVal + 2);342343 await helper.wait.newBlocks(periodic.period);344345 // <canceled>346 expect((await helper.api!.query.testUtils.testValue()).toNumber())347 .to.be.equal(initTestVal + 2);348 });349350 itSub.ifWithPallets('Root can cancel any scheduled operation', [Pallets.Scheduler], async ({helper}) => {351 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});352 const token = await collection.mintToken(bob);353354 const scheduledId = await helper.arrange.makeScheduledId();355 const waitForBlocks = 4;356357 await token.scheduleAfter(scheduledId, waitForBlocks)358 .transfer(bob, {Substrate: alice.address});359360 await helper.getSudo().scheduler.cancelScheduled(alice, scheduledId);361362 await helper.wait.newBlocks(waitForBlocks + 1);363364 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});365 });366367 itSub.ifWithPallets('Root can set prioritized scheduled operation', [Pallets.Scheduler], async ({helper}) => {368 const scheduledId = await helper.arrange.makeScheduledId();369 const waitForBlocks = 4;370371 const amount = 42n * UNIQUE;372373 const balanceBefore = await helper.balance.getSubstrate(charlie.address);374375 await helper.getSudo()376 .scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42})377 .balance.forceTransferToSubstrate(alice, bob.address, charlie.address, amount);378379 await helper.wait.newBlocks(waitForBlocks + 1);380381 const balanceAfter = await helper.balance.getSubstrate(charlie.address);382383 expect(balanceAfter > balanceBefore).to.be.true;384385 const diff = balanceAfter - balanceBefore;386 expect(diff).to.be.equal(amount);387 });388389 itSub.ifWithPallets("Root can change scheduled operation's priority", [Pallets.Scheduler], async ({helper}) => {390 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});391 const token = await collection.mintToken(bob);392393 const scheduledId = await helper.arrange.makeScheduledId();394 const waitForBlocks = 4;395396 await token.scheduleAfter(scheduledId, waitForBlocks)397 .transfer(bob, {Substrate: alice.address});398399 const priority = 112;400 await helper.getSudo().scheduler.changePriority(alice, scheduledId, priority);401402 const priorityChanged = await helper.wait.event(403 waitForBlocks,404 'scheduler',405 'PriorityChanged',406 );407408 expect(priorityChanged !== null).to.be.true;409 expect(priorityChanged!.event.data[2].toString()).to.be.equal(priority.toString());410 });411412 itSub.ifWithPallets('Prioritized operations executes in valid order', [Pallets.Scheduler], async ({helper}) => {413 const [414 scheduledFirstId,415 scheduledSecondId,416 ] = await helper.arrange.makeScheduledIds(2);417418 const currentBlockNumber = await helper.chain.getLatestBlockNumber();419 const blocksBeforeExecution = 4;420 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;421422 const prioHigh = 0;423 const prioLow = 255;424425 const periodic = {426 period: 8,427 repetitions: 2,428 };429430 const amount = 1n * UNIQUE;431432 // Scheduler a task with a lower priority first, then with a higher priority433 await helper.getSudo().scheduler.scheduleAt(scheduledFirstId, firstExecutionBlockNumber, {priority: prioLow, periodic})434 .balance.forceTransferToSubstrate(alice, alice.address, bob.address, amount);435436 await helper.getSudo().scheduler.scheduleAt(scheduledSecondId, firstExecutionBlockNumber, {priority: prioHigh, periodic})437 .balance.forceTransferToSubstrate(alice, alice.address, bob.address, amount);438439 const capture = await helper.arrange.captureEvents('scheduler', 'Dispatched');440441 await helper.wait.newBlocks(blocksBeforeExecution);442443 // Flip priorities444 await helper.getSudo().scheduler.changePriority(alice, scheduledFirstId, prioHigh);445 await helper.getSudo().scheduler.changePriority(alice, scheduledSecondId, prioLow);446447 await helper.wait.newBlocks(periodic.period);448449 const dispatchEvents = capture.extractCapturedEvents();450 expect(dispatchEvents.length).to.be.equal(4);451452 const dispatchedIds = dispatchEvents.map(r => r.event.data[1].toString());453454 const firstExecuctionIds = [dispatchedIds[0], dispatchedIds[1]];455 const secondExecuctionIds = [dispatchedIds[2], dispatchedIds[3]];456457 expect(firstExecuctionIds[0]).to.be.equal(scheduledSecondId);458 expect(firstExecuctionIds[1]).to.be.equal(scheduledFirstId);459460 expect(secondExecuctionIds[0]).to.be.equal(scheduledFirstId);461 expect(secondExecuctionIds[1]).to.be.equal(scheduledSecondId);462 });463});464465describe('Negative Test: Scheduling', () => {466 let alice: IKeyringPair;467 let bob: IKeyringPair;468469 before(async () => {470 await usingPlaygrounds(async (_, privateKeyWrapper) => {471 alice = privateKeyWrapper('//Alice');472 bob = privateKeyWrapper('//Bob');473 });474 });475476 itSub.ifWithPallets("Can't overwrite a scheduled ID", [Pallets.Scheduler], async ({helper}) => {477 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});478 const token = await collection.mintToken(alice);479480 const scheduledId = await helper.arrange.makeScheduledId();481 const waitForBlocks = 4;482483 await token.scheduleAfter(scheduledId, waitForBlocks)484 .transfer(alice, {Substrate: bob.address});485486 const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks);487 await expect(scheduled.balance.transferToSubstrate(alice, bob.address, 1n * UNIQUE))488 .to.be.rejectedWith(/scheduler\.FailedToSchedule/);489490 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);491492 await helper.wait.newBlocks(waitForBlocks + 1);493494 const bobsBalanceAfter = await helper.balance.getSubstrate(bob.address);495496 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});497 expect(bobsBalanceBefore).to.be.equal(bobsBalanceAfter);498 });499500 itSub.ifWithPallets("Can't cancel an operation which is not scheduled", [Pallets.Scheduler], async ({helper}) => {501 const scheduledId = await helper.arrange.makeScheduledId();502 await expect(helper.scheduler.cancelScheduled(alice, scheduledId))503 .to.be.rejectedWith(/scheduler\.NotFound/);504 });505506 itSub.ifWithPallets("Can't cancel a non-owned scheduled operation", [Pallets.Scheduler], async ({helper}) => {507 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});508 const token = await collection.mintToken(alice);509510 const scheduledId = await helper.arrange.makeScheduledId();511 const waitForBlocks = 8;512513 await token.scheduleAfter(scheduledId, waitForBlocks)514 .transfer(alice, {Substrate: bob.address});515516 await expect(helper.scheduler.cancelScheduled(bob, scheduledId))517 .to.be.rejectedWith(/badOrigin/);518519 await helper.wait.newBlocks(waitForBlocks + 1);520521 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});522 });523524 itSub.ifWithPallets("Regular user can't set prioritized scheduled operation", [Pallets.Scheduler], async ({helper}) => {525 const scheduledId = await helper.arrange.makeScheduledId();526 const waitForBlocks = 4;527528 const amount = 42n * UNIQUE;529530 const balanceBefore = await helper.balance.getSubstrate(bob.address);531532 const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42});533 534 await expect(scheduled.balance.transferToSubstrate(alice, bob.address, amount))535 .to.be.rejectedWith(/badOrigin/);536537 await helper.wait.newBlocks(waitForBlocks + 1);538539 const balanceAfter = await helper.balance.getSubstrate(bob.address);540541 expect(balanceAfter).to.be.equal(balanceBefore);542 });543544 itSub.ifWithPallets("Regular user can't change scheduled operation's priority", [Pallets.Scheduler], async ({helper}) => {545 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});546 const token = await collection.mintToken(bob);547548 const scheduledId = await helper.arrange.makeScheduledId();549 const waitForBlocks = 4;550551 await token.scheduleAfter(scheduledId, waitForBlocks)552 .transfer(bob, {Substrate: alice.address});553554 const priority = 112;555 await expect(helper.scheduler.changePriority(alice, scheduledId, priority))556 .to.be.rejectedWith(/badOrigin/);557558 const priorityChanged = await helper.wait.event(559 waitForBlocks,560 'scheduler',561 'PriorityChanged',562 );563564 expect(priorityChanged === null).to.be.true;565 });566});567568// Implementation of the functionality tested here was postponed/shelved569describe.skip('Sponsoring scheduling', () => {570 let alice: IKeyringPair;571 let bob: IKeyringPair;572573 before(async() => {574 await usingApi(async (_, privateKeyWrapper) => {575 alice = privateKeyWrapper('//Alice');576 bob = privateKeyWrapper('//Bob');577 });578 });579580 it('Can sponsor scheduling a transaction', async () => {581 // const collectionId = await createCollectionExpectSuccess();582 // await setCollectionSponsorExpectSuccess(collectionId, bob.address);583 // await confirmSponsorshipExpectSuccess(collectionId, '//Bob');584585 // await usingApi(async api => {586 // const scheduledId = await makeScheduledId();587 // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);588589 // const bobBalanceBefore = await getFreeBalance(bob);590 // const waitForBlocks = 4;591 // // no need to wait to check, fees must be deducted on scheduling, immediately592 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, bob, 0, waitForBlocks, scheduledId);593 // const bobBalanceAfter = await getFreeBalance(bob);594 // // expect(aliceBalanceAfter == aliceBalanceBefore).to.be.true;595 // expect(bobBalanceAfter < bobBalanceBefore).to.be.true;596 // // wait for sequentiality matters597 // await waitNewBlocks(waitForBlocks - 1);598 // });599 });600601 it('Schedules and dispatches a transaction even if the caller has no funds at the time of the dispatch', async () => {602 // await usingApi(async (api, privateKeyWrapper) => {603 // // Find an empty, unused account604 // const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);605606 // const collectionId = await createCollectionExpectSuccess();607608 // // Add zeroBalance address to allow list609 // await enablePublicMintingExpectSuccess(alice, collectionId);610 // await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);611612 // // Grace zeroBalance with money, enough to cover future transactions613 // const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);614 // await submitTransactionAsync(alice, balanceTx);615616 // // Mint a fresh NFT617 // const tokenId = await createItemExpectSuccess(zeroBalance, collectionId, 'NFT');618 // const scheduledId = await makeScheduledId();619620 // // Schedule transfer of the NFT a few blocks ahead621 // const waitForBlocks = 5;622 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, zeroBalance, alice, 1, waitForBlocks, scheduledId);623624 // // Get rid of the account's funds before the scheduled transaction takes place625 // const balanceTx2 = api.tx.balances.transfer(alice.address, UNIQUE * 68n / 100n);626 // const events = await submitTransactionAsync(zeroBalance, balanceTx2);627 // expect(getGenericResult(events).success).to.be.true;628 // /*const emptyBalanceTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0); // do not null reserved?629 // const sudoTx = api.tx.sudo.sudo(emptyBalanceTx as any);630 // const events = await submitTransactionAsync(alice, sudoTx);631 // expect(getGenericResult(events).success).to.be.true;*/632633 // // Wait for a certain number of blocks, discarding the ones that already happened while accepting the late transactions634 // await waitNewBlocks(waitForBlocks - 3);635636 // expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(alice.address));637 // });638 });639640 it('Sponsor going bankrupt does not impact a scheduled transaction', async () => {641 // const collectionId = await createCollectionExpectSuccess();642643 // await usingApi(async (api, privateKeyWrapper) => {644 // const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);645 // const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);646 // await submitTransactionAsync(alice, balanceTx);647648 // await setCollectionSponsorExpectSuccess(collectionId, zeroBalance.address);649 // await confirmSponsorshipByKeyExpectSuccess(collectionId, zeroBalance);650651 // const scheduledId = await makeScheduledId();652 // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);653654 // const waitForBlocks = 5;655 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, zeroBalance, 1, waitForBlocks, scheduledId);656657 // const emptyBalanceSponsorTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0);658 // const sudoTx = api.tx.sudo.sudo(emptyBalanceSponsorTx as any);659 // const events = await submitTransactionAsync(alice, sudoTx);660 // expect(getGenericResult(events).success).to.be.true;661662 // // Wait for a certain number of blocks, save for the ones that already happened while accepting the late transactions663 // await waitNewBlocks(waitForBlocks - 3);664665 // expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(zeroBalance.address));666 // });667 });668669 it('Exceeding sponsor rate limit without having enough funds prevents scheduling a periodic transaction', async () => {670 // const collectionId = await createCollectionExpectSuccess();671 // await setCollectionSponsorExpectSuccess(collectionId, bob.address);672 // await confirmSponsorshipExpectSuccess(collectionId, '//Bob');673674 // await usingApi(async (api, privateKeyWrapper) => {675 // const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);676677 // await enablePublicMintingExpectSuccess(alice, collectionId);678 // await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);679680 // const bobBalanceBefore = await getFreeBalance(bob);681682 // const createData = {nft: {const_data: [], variable_data: []}};683 // const creationTx = api.tx.unique.createItem(collectionId, normalizeAccountId(zeroBalance), createData as any);684 // const scheduledId = await makeScheduledId();685686 // /*const badTransaction = async function () {687 // await submitTransactionExpectFailAsync(zeroBalance, zeroToAlice);688 // };689 // await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');*/690691 // await expect(scheduleAfter(api, creationTx, zeroBalance, 3, scheduledId, 1, 3)).to.be.rejectedWith(/Inability to pay some fees/);692693 // expect(await getFreeBalance(bob)).to.be.equal(bobBalanceBefore);694 // });695 });696});