difftreelog
fix use playgrounds wait
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 UNIQUE,19 waitNewBlocks,20} from './util/helpers';21import {expect, itSub, Pallets, usingPlaygrounds} from './util/playgrounds';22import {IKeyringPair} from '@polkadot/types/types';2324describe('Scheduling token and balance transfers', () => {25 let alice: IKeyringPair;26 let bob: IKeyringPair;27 let charlie: IKeyringPair;2829 before(async () => {30 await usingPlaygrounds(async (_, privateKeyWrapper) => {31 alice = privateKeyWrapper('//Alice');32 bob = privateKeyWrapper('//Bob');33 charlie = privateKeyWrapper('//Charlie');34 });35 });3637 itSub.ifWithPallets('Can delay a transfer of an owned token', [Pallets.Scheduler], async ({helper}) => {38 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});39 const token = await collection.mintToken(alice);40 const schedulerId = await helper.arrange.makeScheduledId();41 const blocksBeforeExecution = 4;4243 await token.scheduleAfter(schedulerId, blocksBeforeExecution)44 .transfer(alice, {Substrate: bob.address});4546 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});4748 await helper.wait.newBlocks(blocksBeforeExecution + 1);4950 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});51 });5253 itSub.ifWithPallets('Can transfer funds periodically', [Pallets.Scheduler], async ({helper}) => {54 const scheduledId = await helper.arrange.makeScheduledId();55 const waitForBlocks = 1;5657 const amount = 1n * UNIQUE;58 const periodic = {59 period: 2,60 repetitions: 2,61 };6263 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);6465 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})66 .balance.transferToSubstrate(alice, bob.address, amount);6768 await helper.wait.newBlocks(waitForBlocks + 1);6970 const bobsBalanceAfterFirst = await helper.balance.getSubstrate(bob.address);71 expect(bobsBalanceAfterFirst)72 .to.be.equal(73 bobsBalanceBefore + 1n * amount,74 '#1 Balance of the recipient should be increased by 1 * amount',75 );7677 await helper.wait.newBlocks(periodic.period);7879 const bobsBalanceAfterSecond = await helper.balance.getSubstrate(bob.address);80 expect(bobsBalanceAfterSecond)81 .to.be.equal(82 bobsBalanceBefore + 2n * amount,83 '#2 Balance of the recipient should be increased by 2 * amount',84 );85 });8687 itSub.ifWithPallets('Can cancel a scheduled operation which has not yet taken effect', [Pallets.Scheduler], async ({helper}) => {88 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});89 const token = await collection.mintToken(alice);9091 const scheduledId = await helper.arrange.makeScheduledId();92 const waitForBlocks = 4;9394 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});9596 await token.scheduleAfter(scheduledId, waitForBlocks)97 .transfer(alice, {Substrate: bob.address});9899 await helper.scheduler.cancelScheduled(alice, scheduledId);100101 await waitNewBlocks(waitForBlocks + 1);102103 expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});104 });105106 itSub.ifWithPallets('Can cancel a periodic operation (transfer of funds)', [Pallets.Scheduler], async ({helper}) => {107 const waitForBlocks = 1;108 const periodic = {109 period: 3,110 repetitions: 2,111 };112113 const scheduledId = await helper.arrange.makeScheduledId();114115 const amount = 1n * UNIQUE;116117 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);118119 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})120 .balance.transferToSubstrate(alice, bob.address, amount);121122 await helper.wait.newBlocks(waitForBlocks + 1);123124 const bobsBalanceAfterFirst = await helper.balance.getSubstrate(bob.address);125126 expect(bobsBalanceAfterFirst)127 .to.be.equal(128 bobsBalanceBefore + 1n * amount,129 '#1 Balance of the recipient should be increased by 1 * amount',130 );131132 await helper.scheduler.cancelScheduled(alice, scheduledId);133 await helper.wait.newBlocks(periodic.period);134135 const bobsBalanceAfterSecond = await helper.balance.getSubstrate(bob.address);136 expect(bobsBalanceAfterSecond)137 .to.be.equal(138 bobsBalanceAfterFirst,139 '#2 Balance of the recipient should not be changed',140 );141 });142143 itSub.ifWithPallets('Scheduled tasks are transactional', [Pallets.Scheduler, Pallets.TestUtils], async ({helper}) => {144 const scheduledId = await helper.arrange.makeScheduledId();145 const waitForBlocks = 4;146147 const initTestVal = 42;148 const changedTestVal = 111;149150 await helper.executeExtrinsic(151 alice,152 'api.tx.testUtils.setTestValue',153 [initTestVal],154 true,155 );156157 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks)158 .executeExtrinsic(159 alice,160 'api.tx.testUtils.setTestValueAndRollback',161 [changedTestVal],162 true,163 );164165 await helper.wait.newBlocks(waitForBlocks + 1);166167 const testVal = (await helper.api!.query.testUtils.testValue()).toNumber();168 expect(testVal, 'The test value should NOT be commited')169 .to.be.equal(initTestVal);170 });171172 itSub.ifWithPallets('Scheduled tasks should take correct fees', [Pallets.Scheduler, Pallets.TestUtils], async function({helper}) {173 const scheduledId = await helper.arrange.makeScheduledId();174 const waitForBlocks = 4;175 const periodic = {176 period: 2,177 repetitions: 2,178 };179180 const dummyTx = helper.constructApiCall('api.tx.testUtils.justTakeFee', []);181 const scheduledLen = dummyTx.callIndex.length;182183 const expectedScheduledFee = (await helper.getPaymentInfo(alice, dummyTx, scheduledLen))184 .partialFee.toBigInt();185186 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})187 .executeExtrinsic(alice, 'api.tx.testUtils.justTakeFee', [], true);188189 await helper.wait.newBlocks(1);190191 const aliceInitBalance = await helper.balance.getSubstrate(alice.address);192 let diff;193194 await helper.wait.newBlocks(waitForBlocks);195196 const aliceBalanceAfterFirst = await helper.balance.getSubstrate(alice.address);197 expect(198 aliceBalanceAfterFirst < aliceInitBalance,199 '[after execution #1] Scheduled task should take a fee',200 ).to.be.true;201202 diff = aliceInitBalance - aliceBalanceAfterFirst;203 expect(diff).to.be.equal(204 expectedScheduledFee,205 'Scheduled task should take the right amount of fees',206 );207208 await helper.wait.newBlocks(periodic.period);209210 const aliceBalanceAfterSecond = await helper.balance.getSubstrate(alice.address);211 expect(212 aliceBalanceAfterSecond < aliceBalanceAfterFirst,213 '[after execution #2] Scheduled task should take a fee',214 ).to.be.true;215216 diff = aliceBalanceAfterFirst - aliceBalanceAfterSecond;217 expect(diff).to.be.equal(218 expectedScheduledFee,219 'Scheduled task should take the right amount of fees',220 );221 });222223 // Check if we can cancel a scheduled periodic operation224 // in the same block in which it is running225 itSub.ifWithPallets('Can cancel the periodic sheduled tx when the tx is running', [Pallets.Scheduler, Pallets.TestUtils], async ({helper}) => {226 const currentBlockNumber = await helper.chain.getLatestBlockNumber();227 const blocksBeforeExecution = 10;228 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;229230 const [231 scheduledId,232 scheduledCancelId,233 ] = await helper.arrange.makeScheduledIds(2);234235 const periodic = {236 period: 5,237 repetitions: 5,238 };239240 const initTestVal = 0;241 const incTestVal = initTestVal + 1;242 const finalTestVal = initTestVal + 2;243244 await helper.executeExtrinsic(245 alice,246 'api.tx.testUtils.setTestValue',247 [initTestVal],248 true,249 );250251 await helper.scheduler.scheduleAt(scheduledId, firstExecutionBlockNumber, {periodic})252 .executeExtrinsic(253 alice,254 'api.tx.testUtils.incTestValue',255 [],256 true,257 );258259 // Cancel the inc tx after 2 executions260 // *in the same block* in which the second execution is scheduled261 await helper.scheduler.scheduleAt(262 scheduledCancelId,263 firstExecutionBlockNumber + periodic.period,264 ).scheduler.cancelScheduled(alice, scheduledId);265266 await helper.wait.newBlocks(blocksBeforeExecution);267268 // execution #0269 expect((await helper.api!.query.testUtils.testValue()).toNumber())270 .to.be.equal(incTestVal);271272 await helper.wait.newBlocks(periodic.period);273274 // execution #1275 expect((await helper.api!.query.testUtils.testValue()).toNumber())276 .to.be.equal(finalTestVal);277278 for (let i = 1; i < periodic.repetitions; i++) {279 await waitNewBlocks(periodic.period);280 expect((await helper.api!.query.testUtils.testValue()).toNumber())281 .to.be.equal(finalTestVal);282 }283 });284285 itSub.ifWithPallets('A scheduled operation can cancel itself', [Pallets.Scheduler, Pallets.TestUtils], async ({helper}) => {286 const scheduledId = await helper.arrange.makeScheduledId();287 const waitForBlocks = 4;288 const periodic = {289 period: 2,290 repetitions: 5,291 };292293 const initTestVal = 0;294 const maxTestVal = 2;295296 await helper.executeExtrinsic(297 alice,298 'api.tx.testUtils.setTestValue',299 [initTestVal],300 true,301 );302303 await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})304 .executeExtrinsic(305 alice,306 'api.tx.testUtils.selfCancelingInc',307 [scheduledId, maxTestVal],308 true,309 );310311 await helper.wait.newBlocks(waitForBlocks + 1);312313 // execution #0314 expect((await helper.api!.query.testUtils.testValue()).toNumber())315 .to.be.equal(initTestVal + 1);316317 await helper.wait.newBlocks(periodic.period);318319 // execution #1320 expect((await helper.api!.query.testUtils.testValue()).toNumber())321 .to.be.equal(initTestVal + 2);322323 await helper.wait.newBlocks(periodic.period);324325 // <canceled>326 expect((await helper.api!.query.testUtils.testValue()).toNumber())327 .to.be.equal(initTestVal + 2);328 });329330 itSub.ifWithPallets('Root can cancel any scheduled operation', [Pallets.Scheduler], async ({helper}) => {331 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});332 const token = await collection.mintToken(bob);333334 const scheduledId = await helper.arrange.makeScheduledId();335 const waitForBlocks = 4;336337 await token.scheduleAfter(scheduledId, waitForBlocks)338 .transfer(bob, {Substrate: alice.address});339340 await helper.getSudo().scheduler.cancelScheduled(alice, scheduledId);341342 await helper.wait.newBlocks(waitForBlocks + 1);343344 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});345 });346347 itSub.ifWithPallets('Root can set prioritized scheduled operation', [Pallets.Scheduler], async ({helper}) => {348 const scheduledId = await helper.arrange.makeScheduledId();349 const waitForBlocks = 4;350351 const amount = 42n * UNIQUE;352353 const balanceBefore = await helper.balance.getSubstrate(charlie.address);354355 await helper.getSudo()356 .scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42})357 .balance.forceTransferToSubstrate(alice, bob.address, charlie.address, amount);358359 await helper.wait.newBlocks(waitForBlocks + 1);360361 const balanceAfter = await helper.balance.getSubstrate(charlie.address);362363 expect(balanceAfter > balanceBefore).to.be.true;364365 const diff = balanceAfter - balanceBefore;366 expect(diff).to.be.equal(amount);367 });368369 itSub.ifWithPallets("Root can change scheduled operation's priority", [Pallets.Scheduler], async ({helper}) => {370 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});371 const token = await collection.mintToken(bob);372373 const scheduledId = await helper.arrange.makeScheduledId();374 const waitForBlocks = 6;375376 await token.scheduleAfter(scheduledId, waitForBlocks)377 .transfer(bob, {Substrate: alice.address});378379 const priority = 112;380 await helper.getSudo().scheduler.changePriority(alice, scheduledId, priority);381382 const priorityChanged = await helper.wait.event(383 waitForBlocks,384 'scheduler',385 'PriorityChanged',386 );387388 expect(priorityChanged !== null).to.be.true;389 expect(priorityChanged!.event.data[2].toString()).to.be.equal(priority.toString());390 });391392 itSub.ifWithPallets('Prioritized operations executes in valid order', [Pallets.Scheduler], async ({helper}) => {393 const [394 scheduledFirstId,395 scheduledSecondId,396 ] = await helper.arrange.makeScheduledIds(2);397398 const currentBlockNumber = await helper.chain.getLatestBlockNumber();399 const blocksBeforeExecution = 4;400 const firstExecutionBlockNumber = currentBlockNumber + blocksBeforeExecution;401402 const prioHigh = 0;403 const prioLow = 255;404405 const periodic = {406 period: 6,407 repetitions: 2,408 };409410 const amount = 1n * UNIQUE;411412 // Scheduler a task with a lower priority first, then with a higher priority413 await helper.getSudo().scheduler.scheduleAt(scheduledFirstId, firstExecutionBlockNumber, {priority: prioLow, periodic})414 .balance.forceTransferToSubstrate(alice, alice.address, bob.address, amount);415416 await helper.getSudo().scheduler.scheduleAt(scheduledSecondId, firstExecutionBlockNumber, {priority: prioHigh, periodic})417 .balance.forceTransferToSubstrate(alice, alice.address, bob.address, amount);418419 const capture = await helper.arrange.captureEvents('scheduler', 'Dispatched');420421 await helper.wait.newBlocks(blocksBeforeExecution);422423 // Flip priorities424 await helper.getSudo().scheduler.changePriority(alice, scheduledFirstId, prioHigh);425 await helper.getSudo().scheduler.changePriority(alice, scheduledSecondId, prioLow);426427 await helper.wait.newBlocks(periodic.period);428429 const dispatchEvents = capture.extractCapturedEvents();430 expect(dispatchEvents.length).to.be.equal(4);431432 const dispatchedIds = dispatchEvents.map(r => r.event.data[1].toString());433434 const firstExecuctionIds = [dispatchedIds[0], dispatchedIds[1]];435 const secondExecuctionIds = [dispatchedIds[2], dispatchedIds[3]];436437 expect(firstExecuctionIds[0]).to.be.equal(scheduledSecondId);438 expect(firstExecuctionIds[1]).to.be.equal(scheduledFirstId);439440 expect(secondExecuctionIds[0]).to.be.equal(scheduledFirstId);441 expect(secondExecuctionIds[1]).to.be.equal(scheduledSecondId);442 });443});444445describe('Negative Test: Scheduling', () => {446 let alice: IKeyringPair;447 let bob: IKeyringPair;448449 before(async () => {450 await usingPlaygrounds(async (_, privateKeyWrapper) => {451 alice = privateKeyWrapper('//Alice');452 bob = privateKeyWrapper('//Bob');453 });454 });455456 itSub.ifWithPallets("Can't overwrite a scheduled ID", [Pallets.Scheduler], async ({helper}) => {457 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});458 const token = await collection.mintToken(alice);459460 const scheduledId = await helper.arrange.makeScheduledId();461 const waitForBlocks = 4;462463 await token.scheduleAfter(scheduledId, waitForBlocks)464 .transfer(alice, {Substrate: bob.address});465466 const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks);467 await expect(scheduled.balance.transferToSubstrate(alice, bob.address, 1n * UNIQUE))468 .to.be.rejectedWith(/scheduler\.FailedToSchedule/);469470 const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);471472 await helper.wait.newBlocks(waitForBlocks + 1);473474 const bobsBalanceAfter = await helper.balance.getSubstrate(bob.address);475476 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});477 expect(bobsBalanceBefore).to.be.equal(bobsBalanceAfter);478 });479480 itSub.ifWithPallets("Can't cancel an operation which is not scheduled", [Pallets.Scheduler], async ({helper}) => {481 const scheduledId = await helper.arrange.makeScheduledId();482 await expect(helper.scheduler.cancelScheduled(alice, scheduledId))483 .to.be.rejectedWith(/scheduler\.NotFound/);484 });485486 itSub.ifWithPallets("Can't cancel a non-owned scheduled operation", [Pallets.Scheduler], async ({helper}) => {487 const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});488 const token = await collection.mintToken(alice);489490 const scheduledId = await helper.arrange.makeScheduledId();491 const waitForBlocks = 4;492493 await token.scheduleAfter(scheduledId, waitForBlocks)494 .transfer(alice, {Substrate: bob.address});495496 await expect(helper.scheduler.cancelScheduled(bob, scheduledId))497 .to.be.rejectedWith(/BadOrigin/);498499 await helper.wait.newBlocks(waitForBlocks + 1);500501 expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});502 });503504 itSub.ifWithPallets("Regular user can't set prioritized scheduled operation", [Pallets.Scheduler], async ({helper}) => {505 const scheduledId = await helper.arrange.makeScheduledId();506 const waitForBlocks = 4;507508 const amount = 42n * UNIQUE;509510 const balanceBefore = await helper.balance.getSubstrate(bob.address);511512 const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42});513 514 await expect(scheduled.balance.transferToSubstrate(alice, bob.address, amount))515 .to.be.rejectedWith(/BadOrigin/);516517 await helper.wait.newBlocks(waitForBlocks + 1);518519 const balanceAfter = await helper.balance.getSubstrate(bob.address);520521 expect(balanceAfter).to.be.equal(balanceBefore);522 });523524 itSub.ifWithPallets("Regular user can't change scheduled operation's priority", [Pallets.Scheduler], async ({helper}) => {525 const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});526 const token = await collection.mintToken(bob);527528 const scheduledId = await helper.arrange.makeScheduledId();529 const waitForBlocks = 4;530531 await token.scheduleAfter(scheduledId, waitForBlocks)532 .transfer(bob, {Substrate: alice.address});533534 const priority = 112;535 await expect(helper.scheduler.changePriority(alice, scheduledId, priority))536 .to.be.rejectedWith(/BadOrigin/);537538 const priorityChanged = await helper.wait.event(539 waitForBlocks,540 'scheduler',541 'PriorityChanged',542 );543544 expect(priorityChanged === null).to.be.true;545 });546});547548// Implementation of the functionality tested here was postponed/shelved549describe.skip('Sponsoring scheduling', () => {550 // let alice: IKeyringPair;551 // let bob: IKeyringPair;552553 // before(async() => {554 // await usingApi(async (_, privateKeyWrapper) => {555 // alice = privateKeyWrapper('//Alice');556 // bob = privateKeyWrapper('//Bob');557 // });558 // });559560 it('Can sponsor scheduling a transaction', async () => {561 // const collectionId = await createCollectionExpectSuccess();562 // await setCollectionSponsorExpectSuccess(collectionId, bob.address);563 // await confirmSponsorshipExpectSuccess(collectionId, '//Bob');564565 // await usingApi(async api => {566 // const scheduledId = await makeScheduledId();567 // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);568569 // const bobBalanceBefore = await getFreeBalance(bob);570 // const waitForBlocks = 4;571 // // no need to wait to check, fees must be deducted on scheduling, immediately572 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, bob, 0, waitForBlocks, scheduledId);573 // const bobBalanceAfter = await getFreeBalance(bob);574 // // expect(aliceBalanceAfter == aliceBalanceBefore).to.be.true;575 // expect(bobBalanceAfter < bobBalanceBefore).to.be.true;576 // // wait for sequentiality matters577 // await waitNewBlocks(waitForBlocks - 1);578 // });579 });580581 it('Schedules and dispatches a transaction even if the caller has no funds at the time of the dispatch', async () => {582 // await usingApi(async (api, privateKeyWrapper) => {583 // // Find an empty, unused account584 // const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);585586 // const collectionId = await createCollectionExpectSuccess();587588 // // Add zeroBalance address to allow list589 // await enablePublicMintingExpectSuccess(alice, collectionId);590 // await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);591592 // // Grace zeroBalance with money, enough to cover future transactions593 // const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);594 // await submitTransactionAsync(alice, balanceTx);595596 // // Mint a fresh NFT597 // const tokenId = await createItemExpectSuccess(zeroBalance, collectionId, 'NFT');598 // const scheduledId = await makeScheduledId();599600 // // Schedule transfer of the NFT a few blocks ahead601 // const waitForBlocks = 5;602 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, zeroBalance, alice, 1, waitForBlocks, scheduledId);603604 // // Get rid of the account's funds before the scheduled transaction takes place605 // const balanceTx2 = api.tx.balances.transfer(alice.address, UNIQUE * 68n / 100n);606 // const events = await submitTransactionAsync(zeroBalance, balanceTx2);607 // expect(getGenericResult(events).success).to.be.true;608 // /*const emptyBalanceTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0); // do not null reserved?609 // const sudoTx = api.tx.sudo.sudo(emptyBalanceTx as any);610 // const events = await submitTransactionAsync(alice, sudoTx);611 // expect(getGenericResult(events).success).to.be.true;*/612613 // // Wait for a certain number of blocks, discarding the ones that already happened while accepting the late transactions614 // await waitNewBlocks(waitForBlocks - 3);615616 // expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(alice.address));617 // });618 });619620 it('Sponsor going bankrupt does not impact a scheduled transaction', async () => {621 // const collectionId = await createCollectionExpectSuccess();622623 // await usingApi(async (api, privateKeyWrapper) => {624 // const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);625 // const balanceTx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);626 // await submitTransactionAsync(alice, balanceTx);627628 // await setCollectionSponsorExpectSuccess(collectionId, zeroBalance.address);629 // await confirmSponsorshipByKeyExpectSuccess(collectionId, zeroBalance);630631 // const scheduledId = await makeScheduledId();632 // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);633634 // const waitForBlocks = 5;635 // await scheduleTransferExpectSuccess(api, collectionId, tokenId, alice, zeroBalance, 1, waitForBlocks, scheduledId);636637 // const emptyBalanceSponsorTx = api.tx.balances.setBalance(zeroBalance.address, 0, 0);638 // const sudoTx = api.tx.sudo.sudo(emptyBalanceSponsorTx as any);639 // const events = await submitTransactionAsync(alice, sudoTx);640 // expect(getGenericResult(events).success).to.be.true;641642 // // Wait for a certain number of blocks, save for the ones that already happened while accepting the late transactions643 // await waitNewBlocks(waitForBlocks - 3);644645 // expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(normalizeAccountId(zeroBalance.address));646 // });647 });648649 it('Exceeding sponsor rate limit without having enough funds prevents scheduling a periodic transaction', async () => {650 // const collectionId = await createCollectionExpectSuccess();651 // await setCollectionSponsorExpectSuccess(collectionId, bob.address);652 // await confirmSponsorshipExpectSuccess(collectionId, '//Bob');653654 // await usingApi(async (api, privateKeyWrapper) => {655 // const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);656657 // await enablePublicMintingExpectSuccess(alice, collectionId);658 // await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);659660 // const bobBalanceBefore = await getFreeBalance(bob);661662 // const createData = {nft: {const_data: [], variable_data: []}};663 // const creationTx = api.tx.unique.createItem(collectionId, normalizeAccountId(zeroBalance), createData as any);664 // const scheduledId = await makeScheduledId();665666 // /*const badTransaction = async function () {667 // await submitTransactionExpectFailAsync(zeroBalance, zeroToAlice);668 // };669 // await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');*/670671 // await expect(scheduleAfter(api, creationTx, zeroBalance, 3, scheduledId, 1, 3)).to.be.rejectedWith(/Inability to pay some fees/);672673 // expect(await getFreeBalance(bob)).to.be.equal(bobBalanceBefore);674 // });675 });676});