git.delta.rocks / unique-network / refs/commits / f71c05b56b64

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {expect} from 'chai';17import {expect} from 'chai';
18import {EthUniqueHelper, itEth} from './util';18import {EthUniqueHelper, itSchedEth} from './util';
19import {Pallets, usingPlaygrounds} from '../util';19import {Pallets, usingPlaygrounds} from '../util';
2020
21describe('Scheduing EVM smart contracts', () => {21describe('Scheduing EVM smart contracts', () => {
26    });26    });
27  });27  });
2828
29  itEth.ifWithPallets('Successfully schedules and periodically executes an EVM contract', [Pallets.Scheduler], async ({helper, privateKey}) => {29  itSchedEth.ifWithPallets('Successfully schedules and periodically executes an EVM contract', [Pallets.Scheduler], async (scheduleKind, {helper, privateKey}) => {
30    const donor = await privateKey({filename: __filename});30    const donor = await privateKey({filename: __filename});
31    const [alice] = await helper.arrange.createAccounts([1000n], donor);31    const [alice] = await helper.arrange.createAccounts([1000n], donor);
3232
33    const scheduledId = await helper.arrange.makeScheduledId();33    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
3434
35    const deployer = await helper.eth.createAccountWithBalance(alice);35    const deployer = await helper.eth.createAccountWithBalance(alice);
36    const flipper = await helper.eth.deployFlipper(deployer);36    const flipper = await helper.eth.deployFlipper(deployer);
44      repetitions: 2,44      repetitions: 2,
45    };45    };
4646
47    await helper.scheduler.scheduleAfter<EthUniqueHelper>(scheduledId, waitForBlocks, {periodic})47    await helper.scheduler.scheduleAfter<EthUniqueHelper>(waitForBlocks, {scheduledId, periodic})
48      .eth.sendEVM(48      .eth.sendEVM(
49        alice,49        alice,
50        flipper.options.address,50        flipper.options.address,

88
9import {EthUniqueHelper} from './playgrounds/unique.dev';9import {EthUniqueHelper} from './playgrounds/unique.dev';
10import {SilentLogger, SilentConsole} from '../../util/playgrounds/unique.dev';10import {SilentLogger, SilentConsole} from '../../util/playgrounds/unique.dev';
11import {SchedKind} from '../../util';
1112
12export {EthUniqueHelper} from './playgrounds/unique.dev';13export {EthUniqueHelper} from './playgrounds/unique.dev';
1314
82itEthIfWithPallet.skip = (name: string, required: string[], cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any) => itEthIfWithPallet(name, required, cb, {skip: true});83itEthIfWithPallet.skip = (name: string, required: string[], cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any) => itEthIfWithPallet(name, required, cb, {skip: true});
83itEth.ifWithPallets = itEthIfWithPallet;84itEth.ifWithPallets = itEthIfWithPallet;
85
86export function itSchedEth(
87  name: string,
88  cb: (schedKind: SchedKind, apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any,
89  opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {},
90) {
91  itEth(name + ' (anonymous scheduling)', (apis) => cb('anon', apis), opts);
92  itEth(name + ' (named scheduling)', (apis) => cb('named', apis), opts);
93}
94itSchedEth.only = (name: string, cb: (schedKind: SchedKind, apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any) => itSchedEth(name, cb, {only: true});
95itSchedEth.skip = (name: string, cb: (schedKind: SchedKind, apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any) => itSchedEth(name, cb, {skip: true});
96itSchedEth.ifWithPallets = itSchedIfWithPallets;
97
98function itSchedIfWithPallets(name: string, required: string[], cb: (schedKind: SchedKind, apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
99  return itSchedEth(name, cb, {requiredPallets: required, ...opts});
100}
84101

1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {ApiPromise} from '@polkadot/api';18import {ApiPromise} from '@polkadot/api';
19import {expect, itSub, Pallets, usingPlaygrounds} from './util';19import {expect, itSched, itSub, Pallets, usingPlaygrounds} from './util';
20import {itEth} from './eth/util';20import {itEth} from './eth/util';
2121
22async function maintenanceEnabled(api: ApiPromise): Promise<boolean> {22async function maintenanceEnabled(api: ApiPromise): Promise<boolean> {
162    await expect(helper.balance.transferToSubstrate(bob, superuser.address, 1n)).to.be.fulfilled;162    await expect(helper.balance.transferToSubstrate(bob, superuser.address, 1n)).to.be.fulfilled;
163  });163  });
164164
165  itSub.ifWithPallets('MM blocks scheduled calls and the scheduler itself', [Pallets.Scheduler], async ({helper}) => {165  itSched.ifWithPallets('MM blocks scheduled calls and the scheduler itself', [Pallets.Scheduler], async (scheduleKind, {helper}) => {
166    const collection = await helper.nft.mintCollection(bob);166    const collection = await helper.nft.mintCollection(bob);
167167
168    const nftBeforeMM = await collection.mintToken(bob);168    const nftBeforeMM = await collection.mintToken(bob);
175      scheduledIdBunkerThroughMM,175      scheduledIdBunkerThroughMM,
176      scheduledIdAttemptDuringMM,176      scheduledIdAttemptDuringMM,
177      scheduledIdAfterMM,177      scheduledIdAfterMM,
178    ] = await helper.arrange.makeScheduledIds(5);178    ] = scheduleKind == 'named'
179      ? helper.arrange.makeScheduledIds(5)
180      : new Array(5);
179181
180    const blocksToWait = 6;182    const blocksToWait = 6;
181183
182    // Scheduling works before the maintenance184    // Scheduling works before the maintenance
183    await nftBeforeMM.scheduleAfter(scheduledIdBeforeMM, blocksToWait)185    await nftBeforeMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdBeforeMM})
184      .transfer(bob, {Substrate: superuser.address});186      .transfer(bob, {Substrate: superuser.address});
185187
186    await helper.wait.newBlocks(blocksToWait + 1);188    await helper.wait.newBlocks(blocksToWait + 1);
187    expect(await nftBeforeMM.getOwner()).to.be.deep.equal({Substrate: superuser.address});189    expect(await nftBeforeMM.getOwner()).to.be.deep.equal({Substrate: superuser.address});
188190
189    // Schedule a transaction that should occur *during* the maintenance191    // Schedule a transaction that should occur *during* the maintenance
190    await nftDuringMM.scheduleAfter(scheduledIdDuringMM, blocksToWait)192    await nftDuringMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdDuringMM})
191      .transfer(bob, {Substrate: superuser.address});193      .transfer(bob, {Substrate: superuser.address});
192    194    
193    // Schedule a transaction that should occur *after* the maintenance195    // Schedule a transaction that should occur *after* the maintenance
194    await nftDuringMM.scheduleAfter(scheduledIdBunkerThroughMM, blocksToWait * 2)196    await nftDuringMM.scheduleAfter(blocksToWait * 2, {scheduledId: scheduledIdBunkerThroughMM})
195      .transfer(bob, {Substrate: superuser.address});197      .transfer(bob, {Substrate: superuser.address});
196198
197    await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);199    await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);
202    expect(await nftDuringMM.getOwner()).to.be.deep.equal({Substrate: bob.address});204    expect(await nftDuringMM.getOwner()).to.be.deep.equal({Substrate: bob.address});
203205
204    // Any attempts to schedule a tx during the MM should be rejected206    // Any attempts to schedule a tx during the MM should be rejected
205    await expect(nftDuringMM.scheduleAfter(scheduledIdAttemptDuringMM, blocksToWait)207    await expect(nftDuringMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdAttemptDuringMM})
206      .transfer(bob, {Substrate: superuser.address}))208      .transfer(bob, {Substrate: superuser.address}))
207      .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);209      .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);
208210
209    await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);211    await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);
210    expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;212    expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;
211213
212    // Scheduling works after the maintenance214    // Scheduling works after the maintenance
213    await nftAfterMM.scheduleAfter(scheduledIdAfterMM, blocksToWait)215    await nftAfterMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdAfterMM})
214      .transfer(bob, {Substrate: superuser.address});216      .transfer(bob, {Substrate: superuser.address});
215    217    
216    await helper.wait.newBlocks(blocksToWait + 1);218    await helper.wait.newBlocks(blocksToWait + 1);

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {expect, itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds} from './util';17import {expect, itSched, itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds} from './util';
18import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
19import {DevUniqueHelper} from './util/playgrounds/unique.dev';19import {DevUniqueHelper} from './util/playgrounds/unique.dev';
2020
36    });36    });
37  });37  });
38
39  beforeEach(async () => {
40    await usingPlaygrounds(async (helper) => {
41      await helper.wait.noScheduledTasks();
42    });
43  });
3844
39  itSub('Can delay a transfer of an owned token', async ({helper}) => {45  itSched('Can delay a transfer of an owned token', async (scheduleKind, {helper}) => {
40    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});46    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});
41    const token = await collection.mintToken(alice);47    const token = await collection.mintToken(alice);
42    const schedulerId = await helper.arrange.makeScheduledId();48    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
43    const blocksBeforeExecution = 4;49    const blocksBeforeExecution = 4;
44    50    
45    await token.scheduleAfter(schedulerId, blocksBeforeExecution)51    await token.scheduleAfter(blocksBeforeExecution, {scheduledId})
46      .transfer(alice, {Substrate: bob.address});52      .transfer(alice, {Substrate: bob.address});
47    const executionBlock = await helper.chain.getLatestBlockNumber() + blocksBeforeExecution + 1;53    const executionBlock = await helper.chain.getLatestBlockNumber() + blocksBeforeExecution + 1;
4854
53    expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});59    expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});
54  });60  });
5561
56  itSub('Can transfer funds periodically', async ({helper}) => {62  itSched('Can transfer funds periodically', async (scheduleKind, {helper}) => {
57    const scheduledId = await helper.arrange.makeScheduledId();63    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
58    const waitForBlocks = 1;64    const waitForBlocks = 1;
5965
60    const amount = 1n * helper.balance.getOneTokenNominal();66    const amount = 1n * helper.balance.getOneTokenNominal();
6571
66    const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);72    const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);
6773
68    await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})74    await helper.scheduler.scheduleAfter(waitForBlocks, {scheduledId, periodic})
69      .balance.transferToSubstrate(alice, bob.address, amount);75      .balance.transferToSubstrate(alice, bob.address, amount);
70    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;76    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
7177
92    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});98    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});
93    const token = await collection.mintToken(alice);99    const token = await collection.mintToken(alice);
94100
95    const scheduledId = await helper.arrange.makeScheduledId();101    const scheduledId = helper.arrange.makeScheduledId();
96    const waitForBlocks = 4;102    const waitForBlocks = 4;
97103
98    expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});104    expect(await token.getOwner()).to.be.deep.equal({Substrate: alice.address});
99105
100    await token.scheduleAfter(scheduledId, waitForBlocks)106    await token.scheduleAfter(waitForBlocks, {scheduledId})
101      .transfer(alice, {Substrate: bob.address});107      .transfer(alice, {Substrate: bob.address});
102    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;108    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
103109
115      repetitions: 2,121      repetitions: 2,
116    };122    };
117123
118    const scheduledId = await helper.arrange.makeScheduledId();124    const scheduledId = helper.arrange.makeScheduledId();
119125
120    const amount = 1n * helper.balance.getOneTokenNominal();126    const amount = 1n * helper.balance.getOneTokenNominal();
121127
122    const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);128    const bobsBalanceBefore = await helper.balance.getSubstrate(bob.address);
123129
124    await helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {periodic})130    await helper.scheduler.scheduleAfter(waitForBlocks, {scheduledId, periodic})
125      .balance.transferToSubstrate(alice, bob.address, amount);131      .balance.transferToSubstrate(alice, bob.address, amount);
126    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;132    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
127133
146      );152      );
147  });153  });
148154
149  itSub('scheduler will not insert more tasks than allowed', async ({helper}) => {155  itSched('scheduler will not insert more tasks than allowed', async (scheduleKind, {helper}) => {
150    const maxScheduledPerBlock = 50;156    const maxScheduledPerBlock = 50;
157    let fillScheduledIds = new Array(maxScheduledPerBlock);
158    let extraScheduledId = undefined;
159    
160    if (scheduleKind == 'named') {
151    const scheduledIds = await helper.arrange.makeScheduledIds(maxScheduledPerBlock + 1);161      const scheduledIds = helper.arrange.makeScheduledIds(maxScheduledPerBlock + 1);
152    const fillScheduledIds = scheduledIds.slice(0, maxScheduledPerBlock);162      fillScheduledIds = scheduledIds.slice(0, maxScheduledPerBlock);
153    const extraScheduledId = scheduledIds[maxScheduledPerBlock];163      extraScheduledId = scheduledIds[maxScheduledPerBlock];
164    }
154165
155    // Since the dev node has Instant Seal,166    // Since the dev node has Instant Seal,
156    // we need a larger gap between the current block and the target one.167    // we need a larger gap between the current block and the target one.
168179
169    // Fill the target block180    // Fill the target block
170    for (let i = 0; i < maxScheduledPerBlock; i++) {181    for (let i = 0; i < maxScheduledPerBlock; i++) {
171      await helper.scheduler.scheduleAt(fillScheduledIds[i], executionBlock)182      await helper.scheduler.scheduleAt(executionBlock, {scheduledId: fillScheduledIds[i]})
172        .balance.transferToSubstrate(superuser, bob.address, amount);183        .balance.transferToSubstrate(superuser, bob.address, amount);
173    }184    }
174185
175    // Try to schedule a task into a full block186    // Try to schedule a task into a full block
176    await expect(helper.scheduler.scheduleAt(extraScheduledId, executionBlock)187    await expect(helper.scheduler.scheduleAt(executionBlock, {scheduledId: extraScheduledId})
177      .balance.transferToSubstrate(superuser, bob.address, amount))188      .balance.transferToSubstrate(superuser, bob.address, amount))
178      .to.be.rejectedWith(/scheduler\.AgendaIsExhausted/);189      .to.be.rejectedWith(/scheduler\.AgendaIsExhausted/);
179190
187    expect(diff).to.be.equal(amount * BigInt(maxScheduledPerBlock));198    expect(diff).to.be.equal(amount * BigInt(maxScheduledPerBlock));
188  });199  });
189200
190  itSub.ifWithPallets('Scheduled tasks are transactional', [Pallets.TestUtils], async ({helper}) => {201  itSched.ifWithPallets('Scheduled tasks are transactional', [Pallets.TestUtils], async (scheduleKind, {helper}) => {
191    const scheduledId = await helper.arrange.makeScheduledId();202    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
192    const waitForBlocks = 4;203    const waitForBlocks = 4;
193204
194    const initTestVal = 42;205    const initTestVal = 42;
195    const changedTestVal = 111;206    const changedTestVal = 111;
196207
197    await helper.testUtils.setTestValue(alice, initTestVal);208    await helper.testUtils.setTestValue(alice, initTestVal);
198209
199    await helper.scheduler.scheduleAfter<DevUniqueHelper>(scheduledId, waitForBlocks)210    await helper.scheduler.scheduleAfter<DevUniqueHelper>(waitForBlocks, {scheduledId})
200      .testUtils.setTestValueAndRollback(alice, changedTestVal);211      .testUtils.setTestValueAndRollback(alice, changedTestVal);
201    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;212    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
202213
207      .to.be.equal(initTestVal);218      .to.be.equal(initTestVal);
208  });219  });
209220
210  itSub.ifWithPallets('Scheduled tasks should take correct fees', [Pallets.TestUtils], async function({helper}) {221  itSched.ifWithPallets('Scheduled tasks should take correct fees', [Pallets.TestUtils], async function(scheduleKind, {helper}) {
211    const scheduledId = await helper.arrange.makeScheduledId();222    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
212    const waitForBlocks = 4;223    const waitForBlocks = 4;
213    const periodic = {224    const periodic = {
214      period: 2,225      period: 2,
221    const expectedScheduledFee = (await helper.getPaymentInfo(alice, dummyTx, scheduledLen))232    const expectedScheduledFee = (await helper.getPaymentInfo(alice, dummyTx, scheduledLen))
222      .partialFee.toBigInt();233      .partialFee.toBigInt();
223234
224    await helper.scheduler.scheduleAfter<DevUniqueHelper>(scheduledId, waitForBlocks, {periodic})235    await helper.scheduler.scheduleAfter<DevUniqueHelper>(waitForBlocks, {scheduledId, periodic})
225      .testUtils.justTakeFee(alice);236      .testUtils.justTakeFee(alice);
226    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;237    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
227238
267    const [278    const [
268      scheduledId,279      scheduledId,
269      scheduledCancelId,280      scheduledCancelId,
270    ] = await helper.arrange.makeScheduledIds(2);281    ] = helper.arrange.makeScheduledIds(2);
271282
272    const periodic = {283    const periodic = {
273      period: 5,284      period: 5,
280291
281    await helper.testUtils.setTestValue(alice, initTestVal);292    await helper.testUtils.setTestValue(alice, initTestVal);
282293
283    await helper.scheduler.scheduleAt<DevUniqueHelper>(scheduledId, firstExecutionBlockNumber, {periodic})294    await helper.scheduler.scheduleAt<DevUniqueHelper>(firstExecutionBlockNumber, {scheduledId, periodic})
284      .testUtils.incTestValue(alice);295      .testUtils.incTestValue(alice);
285296
286    // Cancel the inc tx after 2 executions297    // Cancel the inc tx after 2 executions
287    // *in the same block* in which the second execution is scheduled298    // *in the same block* in which the second execution is scheduled
288    await helper.scheduler.scheduleAt(299    await helper.scheduler.scheduleAt(
289      scheduledCancelId,
290      firstExecutionBlockNumber + periodic.period,300      firstExecutionBlockNumber + periodic.period,
301      {scheduledId: scheduledCancelId},
291    ).scheduler.cancelScheduled(alice, scheduledId);302    ).scheduler.cancelScheduled(alice, scheduledId);
292303
293    await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber);304    await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber);
310  });321  });
311322
312  itSub.ifWithPallets('A scheduled operation can cancel itself', [Pallets.TestUtils], async ({helper}) => {323  itSub.ifWithPallets('A scheduled operation can cancel itself', [Pallets.TestUtils], async ({helper}) => {
313    const scheduledId = await helper.arrange.makeScheduledId();324    const scheduledId = helper.arrange.makeScheduledId();
314    const waitForBlocks = 4;325    const waitForBlocks = 4;
315    const periodic = {326    const periodic = {
316      period: 2,327      period: 2,
322333
323    await helper.testUtils.setTestValue(alice, initTestVal);334    await helper.testUtils.setTestValue(alice, initTestVal);
324335
325    await helper.scheduler.scheduleAfter<DevUniqueHelper>(scheduledId, waitForBlocks, {periodic})336    await helper.scheduler.scheduleAfter<DevUniqueHelper>(waitForBlocks, {scheduledId, periodic})
326      .testUtils.selfCancelingInc(alice, scheduledId, maxTestVal);337      .testUtils.selfCancelingInc(alice, scheduledId, maxTestVal);
327    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;338    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
328339
349    const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});360    const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});
350    const token = await collection.mintToken(bob);361    const token = await collection.mintToken(bob);
351362
352    const scheduledId = await helper.arrange.makeScheduledId();363    const scheduledId = helper.arrange.makeScheduledId();
353    const waitForBlocks = 4;364    const waitForBlocks = 4;
354365
355    await token.scheduleAfter(scheduledId, waitForBlocks)366    await token.scheduleAfter(waitForBlocks, {scheduledId})
356      .transfer(bob, {Substrate: alice.address});367      .transfer(bob, {Substrate: alice.address});
357    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;368    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
358369
363    expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});374    expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});
364  });375  });
365376
366  itSub('Root can set prioritized scheduled operation', async ({helper}) => {377  itSched('Root can set prioritized scheduled operation', async (scheduleKind, {helper}) => {
367    const scheduledId = await helper.arrange.makeScheduledId();378    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
368    const waitForBlocks = 4;379    const waitForBlocks = 4;
369380
370    const amount = 42n * helper.balance.getOneTokenNominal();381    const amount = 42n * helper.balance.getOneTokenNominal();
371382
372    const balanceBefore = await helper.balance.getSubstrate(charlie.address);383    const balanceBefore = await helper.balance.getSubstrate(charlie.address);
373384
374    await helper.getSudo()385    await helper.getSudo()
375      .scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42})386      .scheduler.scheduleAfter(waitForBlocks, {scheduledId, priority: 42})
376      .balance.forceTransferToSubstrate(superuser, bob.address, charlie.address, amount);387      .balance.forceTransferToSubstrate(superuser, bob.address, charlie.address, amount);
377    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;388    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
378389
390    const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});401    const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});
391    const token = await collection.mintToken(bob);402    const token = await collection.mintToken(bob);
392403
393    const scheduledId = await helper.arrange.makeScheduledId();404    const scheduledId = helper.arrange.makeScheduledId();
394    const waitForBlocks = 6;405    const waitForBlocks = 6;
395406
396    await token.scheduleAfter(scheduledId, waitForBlocks)407    await token.scheduleAfter(waitForBlocks, {scheduledId})
397      .transfer(bob, {Substrate: alice.address});408      .transfer(bob, {Substrate: alice.address});
398    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;409    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
399410
419    const [430    const [
420      scheduledFirstId,431      scheduledFirstId,
421      scheduledSecondId,432      scheduledSecondId,
422    ] = await helper.arrange.makeScheduledIds(2);433    ] = helper.arrange.makeScheduledIds(2);
423434
424    const currentBlockNumber = await helper.chain.getLatestBlockNumber();435    const currentBlockNumber = await helper.chain.getLatestBlockNumber();
425    const blocksBeforeExecution = 6;436    const blocksBeforeExecution = 6;
436    const amount = 1n * helper.balance.getOneTokenNominal();447    const amount = 1n * helper.balance.getOneTokenNominal();
437448
438    // Scheduler a task with a lower priority first, then with a higher priority449    // Scheduler a task with a lower priority first, then with a higher priority
439    await helper.getSudo().scheduler.scheduleAt(scheduledFirstId, firstExecutionBlockNumber, {priority: prioLow, periodic})450    await helper.getSudo().scheduler.scheduleAt(firstExecutionBlockNumber, {
451      scheduledId: scheduledFirstId,
452      priority: prioLow,
453      periodic,
440      .balance.forceTransferToSubstrate(superuser, alice.address, bob.address, amount);454    }).balance.forceTransferToSubstrate(superuser, alice.address, bob.address, amount);
441455
442    await helper.getSudo().scheduler.scheduleAt(scheduledSecondId, firstExecutionBlockNumber, {priority: prioHigh, periodic})456    await helper.getSudo().scheduler.scheduleAt(firstExecutionBlockNumber, {
457      scheduledId: scheduledSecondId,
458      priority: prioHigh,
459      periodic,
443      .balance.forceTransferToSubstrate(superuser, alice.address, bob.address, amount);460    }).balance.forceTransferToSubstrate(superuser, alice.address, bob.address, amount);
444461
445    const capture = await helper.arrange.captureEvents('scheduler', 'Dispatched');462    const capture = await helper.arrange.captureEvents('scheduler', 'Dispatched');
467    expect(secondExecuctionIds[1]).to.be.equal(scheduledSecondId);484    expect(secondExecuctionIds[1]).to.be.equal(scheduledSecondId);
468  });485  });
469486
470  itSub('Periodic operations always can be rescheduled', async ({helper}) => {487  itSched('Periodic operations always can be rescheduled', async (scheduleKind, {helper}) => {
471    const maxScheduledPerBlock = 50;488    const maxScheduledPerBlock = 50;
472    const numFilledBlocks = 3;489    const numFilledBlocks = 3;
473    const ids = await helper.arrange.makeScheduledIds(numFilledBlocks * maxScheduledPerBlock + 1);490    const ids = helper.arrange.makeScheduledIds(numFilledBlocks * maxScheduledPerBlock + 1);
474    const periodicId = ids[0];491    const periodicId = scheduleKind == 'named' ? ids[0] : undefined;
475    const fillIds = ids.slice(1);492    const fillIds = ids.slice(1);
493
494    const fillScheduleFn = scheduleKind == 'named' ? 'scheduleNamed' : 'schedule';
476495
477    const initTestVal = 0;496    const initTestVal = 0;
478    const firstExecTestVal = 1;497    const firstExecTestVal = 1;
498        const scheduledTx = helper.constructApiCall('api.tx.balances.transfer', [bob.address, 1n]);517        const scheduledTx = helper.constructApiCall('api.tx.balances.transfer', [bob.address, 1n]);
499518
500        const when = firstExecutionBlockNumber + period + offset;519        const when = firstExecutionBlockNumber + period + offset;
520        const mandatoryArgs = [when, null, null, scheduledTx];
501        const tx = helper.constructApiCall('api.tx.scheduler.scheduleNamed', [fillIds[i + offset * maxScheduledPerBlock], when, null, null, scheduledTx]);521        const scheduleArgs = scheduleKind == 'named'
522          ? [fillIds[i + offset * maxScheduledPerBlock], ...mandatoryArgs]
523          : mandatoryArgs;
524
525        const tx = helper.constructApiCall(`api.tx.scheduler.${fillScheduleFn}`, scheduleArgs);
502526
503        txs.push(tx);527        txs.push(tx);
504      }528      }
505    }529    }
506    await helper.executeExtrinsic(alice, 'api.tx.testUtils.batchAll', [txs], true);530    await helper.executeExtrinsic(alice, 'api.tx.testUtils.batchAll', [txs], true);
507531
508    await helper.scheduler.scheduleAt<DevUniqueHelper>(periodicId, firstExecutionBlockNumber, {periodic})532    await helper.scheduler.scheduleAt<DevUniqueHelper>(firstExecutionBlockNumber, {
533      scheduledId: periodicId,
534      periodic,
509      .testUtils.incTestValue(alice);535    }).testUtils.incTestValue(alice);
510536
511    await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber);537    await helper.wait.forParachainBlockNumber(firstExecutionBlockNumber);
522    expect(await helper.testUtils.testValue()).to.be.equal(secondExecTestVal);548    expect(await helper.testUtils.testValue()).to.be.equal(secondExecTestVal);
523  });549  });
524550
525  itSub('scheduled operations does not change nonce', async ({helper}) => {551  itSched('scheduled operations does not change nonce', async (scheduleKind, {helper}) => {
526    const scheduledId = await helper.arrange.makeScheduledId();552    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
527    const blocksBeforeExecution = 4;553    const blocksBeforeExecution = 4;
528554
529    await helper.scheduler555    await helper.scheduler
530      .scheduleAfter<DevUniqueHelper>(scheduledId, blocksBeforeExecution)556      .scheduleAfter<DevUniqueHelper>(blocksBeforeExecution, {scheduledId})
531      .balance.transferToSubstrate(alice, bob.address, 1n);557      .balance.transferToSubstrate(alice, bob.address, 1n);
532    const executionBlock = await helper.chain.getLatestBlockNumber() + blocksBeforeExecution + 1;558    const executionBlock = await helper.chain.getLatestBlockNumber() + blocksBeforeExecution + 1;
533559
560    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});586    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});
561    const token = await collection.mintToken(alice);587    const token = await collection.mintToken(alice);
562588
563    const scheduledId = await helper.arrange.makeScheduledId();589    const scheduledId = helper.arrange.makeScheduledId();
564    const waitForBlocks = 4;590    const waitForBlocks = 4;
565591
566    await token.scheduleAfter(scheduledId, waitForBlocks)592    await token.scheduleAfter(waitForBlocks, {scheduledId})
567      .transfer(alice, {Substrate: bob.address});593      .transfer(alice, {Substrate: bob.address});
568    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;594    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
569595
570    const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks);596    const scheduled = helper.scheduler.scheduleAfter(waitForBlocks, {scheduledId});
571    await expect(scheduled.balance.transferToSubstrate(alice, bob.address, 1n * helper.balance.getOneTokenNominal()))597    await expect(scheduled.balance.transferToSubstrate(alice, bob.address, 1n * helper.balance.getOneTokenNominal()))
572      .to.be.rejectedWith(/scheduler\.FailedToSchedule/);598      .to.be.rejectedWith(/scheduler\.FailedToSchedule/);
573599
582  });608  });
583609
584  itSub("Can't cancel an operation which is not scheduled", async ({helper}) => {610  itSub("Can't cancel an operation which is not scheduled", async ({helper}) => {
585    const scheduledId = await helper.arrange.makeScheduledId();611    const scheduledId = helper.arrange.makeScheduledId();
586    await expect(helper.scheduler.cancelScheduled(alice, scheduledId))612    await expect(helper.scheduler.cancelScheduled(alice, scheduledId))
587      .to.be.rejectedWith(/scheduler\.NotFound/);613      .to.be.rejectedWith(/scheduler\.NotFound/);
588  });614  });
591    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});617    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'schd'});
592    const token = await collection.mintToken(alice);618    const token = await collection.mintToken(alice);
593619
594    const scheduledId = await helper.arrange.makeScheduledId();620    const scheduledId = helper.arrange.makeScheduledId();
595    const waitForBlocks = 4;621    const waitForBlocks = 4;
596622
597    await token.scheduleAfter(scheduledId, waitForBlocks)623    await token.scheduleAfter(waitForBlocks, {scheduledId})
598      .transfer(alice, {Substrate: bob.address});624      .transfer(alice, {Substrate: bob.address});
599    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;625    const executionBlock = await helper.chain.getLatestBlockNumber() + waitForBlocks + 1;
600626
606    expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});632    expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});
607  });633  });
608634
609  itSub("Regular user can't set prioritized scheduled operation", async ({helper}) => {635  itSched("Regular user can't set prioritized scheduled operation", async (scheduleKind, {helper}) => {
610    const scheduledId = await helper.arrange.makeScheduledId();636    const scheduledId = scheduleKind == 'named' ? helper.arrange.makeScheduledId() : undefined;
611    const waitForBlocks = 4;637    const waitForBlocks = 4;
612638
613    const amount = 42n * helper.balance.getOneTokenNominal();639    const amount = 42n * helper.balance.getOneTokenNominal();
614640
615    const balanceBefore = await helper.balance.getSubstrate(bob.address);641    const balanceBefore = await helper.balance.getSubstrate(bob.address);
616642
617    const scheduled = helper.scheduler.scheduleAfter(scheduledId, waitForBlocks, {priority: 42});643    const scheduled = helper.scheduler.scheduleAfter(waitForBlocks, {scheduledId, priority: 42});
618    644    
619    await expect(scheduled.balance.transferToSubstrate(alice, bob.address, amount))645    await expect(scheduled.balance.transferToSubstrate(alice, bob.address, amount))
620      .to.be.rejectedWith(/BadOrigin/);646      .to.be.rejectedWith(/BadOrigin/);
632    const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});658    const collection = await helper.nft.mintCollection(bob, {tokenPrefix: 'schd'});
633    const token = await collection.mintToken(bob);659    const token = await collection.mintToken(bob);
634660
635    const scheduledId = await helper.arrange.makeScheduledId();661    const scheduledId = helper.arrange.makeScheduledId();
636    const waitForBlocks = 4;662    const waitForBlocks = 4;
637663
638    await token.scheduleAfter(scheduledId, waitForBlocks)664    await token.scheduleAfter(waitForBlocks, {scheduledId})
639      .transfer(bob, {Substrate: alice.address});665      .transfer(bob, {Substrate: alice.address});
640666
641    const priority = 112;667    const priority = 112;

130itSubIfWithPallet.skip = (name: string, required: string[], cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any) => itSubIfWithPallet(name, required, cb, {skip: true});130itSubIfWithPallet.skip = (name: string, required: string[], cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any) => itSubIfWithPallet(name, required, cb, {skip: true});
131itSub.ifWithPallets = itSubIfWithPallet;131itSub.ifWithPallets = itSubIfWithPallet;
132
133export type SchedKind = 'anon' | 'named';
134
135export function itSched(
136  name: string,
137  cb: (schedKind: SchedKind, apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any,
138  opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {},
139) {
140  itSub(name + ' (anonymous scheduling)', (apis) => cb('anon', apis), opts);
141  itSub(name + ' (named scheduling)', (apis) => cb('named', apis), opts);
142}
143itSched.only = (name: string, cb: (schedKind: SchedKind, apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any) => itSched(name, cb, {only: true});
144itSched.skip = (name: string, cb: (schedKind: SchedKind, apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any) => itSched(name, cb, {skip: true});
145itSched.ifWithPallets = itSchedIfWithPallets;
146
147function itSchedIfWithPallets(name: string, required: string[], cb: (schedKind: SchedKind, apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
148  return itSched(name, cb, {requiredPallets: required, ...opts});
149}
132150
133export function describeXCM(title: string, fn: (this: Mocha.Suite) => void, opts: {skip?: boolean} = {}) {151export function describeXCM(title: string, fn: (this: Mocha.Suite) => void, opts: {skip?: boolean} = {}) {
134  (process.env.RUN_XCM_TESTS && !opts.skip152  (process.env.RUN_XCM_TESTS && !opts.skip