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

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