git.delta.rocks / unique-network / refs/commits / 156a79ad752f

difftreelog

Tests fixes sync

Andrey Kuznetsov2022-05-30parent: #4153532.patch.diff
in: master

7 files changed

modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -47,7 +47,6 @@
     "testRemoveCollectionSponsor": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionSponsor.test.ts",
     "testRemoveFromAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromAllowList.test.ts",
     "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
-    "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
     "testContracts": "mocha --timeout 9999999 -r ts-node/register ./**/contracts.test.ts",
     "testCreateItem": "mocha --timeout 9999999 -r ts-node/register ./**/createItem.test.ts",
     "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts",
modifiedtests/src/burnItem.test.tsdiffbeforeafterboth
--- a/tests/src/burnItem.test.ts
+++ b/tests/src/burnItem.test.ts
@@ -217,22 +217,6 @@
     });
   });
 
-  it('Burn a token in a destroyed collection', async () => {
-    const createMode = 'NFT';
-    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
-    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
-    await destroyCollectionExpectSuccess(collectionId);
-
-    await usingApi(async (api) => {
-      const tx = api.tx.unique.burnItem(collectionId, tokenId, 0);
-      const badTransaction = async function () {
-        await submitTransactionExpectFailAsync(alice, tx);
-      };
-      await expect(badTransaction()).to.be.rejected;
-    });
-
-  });
-
   it('Burn a token that was never created', async () => {
     const createMode = 'NFT';
     const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
modifiedtests/src/check-event/createMultipleItemsEvent.test.tsdiffbeforeafterboth
--- a/tests/src/check-event/createMultipleItemsEvent.test.ts
+++ b/tests/src/check-event/createMultipleItemsEvent.test.ts
@@ -39,7 +39,7 @@
   it('Check event from createMultipleItems(): ', async () => {
     await usingApi(async (api: ApiPromise) => {
       const collectionID = await createCollectionExpectSuccess();
-      const args = [{NFT: ['0x31', '0x31']}, {NFT: ['0x32', '0x32']}, {NFT: ['0x33', '0x33']}];
+      const args = [{NFT: {}}, {NFT: {}}, {NFT: {}}];
       const createMultipleItems = api.tx.unique.createMultipleItems(collectionID, normalizeAccountId(alice.address), args);
       const events = await submitTransactionAsync(alice, createMultipleItems);
       const msg = JSON.stringify(uniqueEventMessage(events));
modifiedtests/src/createCollection.test.tsdiffbeforeafterboth
--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -63,17 +63,16 @@
       const bob = privateKey('//Bob');
       const tx = api.tx.unique.createCollectionEx({
         mode: {Fungible: 8},
-        //access: 'AllowList',
+        permissions: {
+          access: 'AllowList'
+        },
         name: [1],
         description: [2],
         tokenPrefix: '0x000000',
-        //offchainSchema: '0x111111',
-        //schemaVersion: 'Unique',
         pendingSponsor: bob.address,
         limits: {
           accountTokenOwnershipLimit: 3,
         },
-        //constOnChainSchema: '0x333333',
       });
       const events = await submitTransactionAsync(alice, tx);
       const result = getCreateCollectionResult(events);
@@ -81,15 +80,12 @@
       const collection = (await getDetailedCollectionInfo(api, result.collectionId))!;
       expect(collection.owner.toString()).to.equal(alice.address);
       expect(collection.mode.asFungible.toNumber()).to.equal(8);
-      //expect(collection.access.isAllowList).to.be.true;
+      expect(collection.permissions.access.toHuman()).to.equal('AllowList');
       expect(collection.name.map(v => v.toNumber())).to.deep.equal([1]);
       expect(collection.description.map(v => v.toNumber())).to.deep.equal([2]);
       expect(collection.tokenPrefix.toString()).to.equal('0x000000');
-      //expect(collection.offchainSchema.toString()).to.equal('0x111111');
-      //expect(collection.schemaVersion.isUnique).to.be.true;
       expect(collection.sponsorship.asUnconfirmed.toString()).to.equal(bob.address);
       expect(collection.limits.accountTokenOwnershipLimit.unwrap().toNumber()).to.equal(3);
-      //expect(collection.constOnChainSchema.toString()).to.equal('0x333333');
     });
   });
 });
modifiedtests/src/limits.test.tsdiffbeforeafterboth
before · tests/src/limits.test.ts
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 {IKeyringPair} from '@polkadot/types/types';18import privateKey from './substrate/privateKey';19import usingApi from './substrate/substrate-api';20import {21  createCollectionExpectSuccess,22  destroyCollectionExpectSuccess,23  setCollectionLimitsExpectSuccess,24  setCollectionSponsorExpectSuccess,25  confirmSponsorshipExpectSuccess,26  createItemExpectSuccess,27  createItemExpectFailure,28  transferExpectSuccess,29  getFreeBalance,30  waitNewBlocks,31} from './util/helpers';32import {expect} from 'chai';3334describe('Number of tokens per address (NFT)', () => {35  let alice: IKeyringPair;3637  before(async () => {38    await usingApi(async () => {39      alice = privateKey('//Alice');40    });41  });4243  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {4445    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});46    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});47    for(let i = 0; i < 10; i++){48      await createItemExpectSuccess(alice, collectionId, 'NFT');49    }50    await createItemExpectFailure(alice, collectionId, 'NFT');51    await destroyCollectionExpectSuccess(collectionId);52  });5354  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {5556    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});57    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});58    await createItemExpectSuccess(alice, collectionId, 'NFT');59    await createItemExpectFailure(alice, collectionId, 'NFT');60    await destroyCollectionExpectSuccess(collectionId);61  });62});6364describe('Number of tokens per address (ReFungible)', () => {65  let alice: IKeyringPair;6667  before(async () => {68    await usingApi(async () => {69      alice = privateKey('//Alice');70    });71  });7273  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {74    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});75    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});76    for(let i = 0; i < 10; i++){77      await createItemExpectSuccess(alice, collectionId, 'ReFungible');78    }79    await createItemExpectFailure(alice, collectionId, 'ReFungible');80    await destroyCollectionExpectSuccess(collectionId);81  });8283  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {84    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});85    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});86    await createItemExpectSuccess(alice, collectionId, 'ReFungible');87    await createItemExpectFailure(alice, collectionId, 'ReFungible');88    await destroyCollectionExpectSuccess(collectionId);89  });90});9192describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {93  let alice: IKeyringPair;94  let bob: IKeyringPair;95  let charlie: IKeyringPair;9697  before(async () => {98    await usingApi(async () => {99      alice = privateKey('//Alice');100      bob = privateKey('//Bob');101      charlie = privateKey('//Charlie');102    });103  });104105  it.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {106    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});107    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});108    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');109    await setCollectionSponsorExpectSuccess(collectionId, alice.address);110    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');111    await transferExpectSuccess(collectionId, tokenId, alice, bob);112    const aliceBalanceBefore = await getFreeBalance(alice);113114    // check setting SponsorTimeout = 5, fail115    await waitNewBlocks(5);116    await transferExpectSuccess(collectionId, tokenId, bob, charlie);117    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);118    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);119120    // check setting SponsorTimeout = 7, success121    await waitNewBlocks(2); // 5 + 2122    await transferExpectSuccess(collectionId, tokenId, charlie, bob);123    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);124    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;125    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);126    await destroyCollectionExpectSuccess(collectionId);127  });128129  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {130131    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});132    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});133    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');134    await setCollectionSponsorExpectSuccess(collectionId, alice.address);135    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');136    await transferExpectSuccess(collectionId, tokenId, alice, bob);137    const aliceBalanceBefore = await getFreeBalance(alice);138139    // check setting SponsorTimeout = 1, fail140    await waitNewBlocks(1);141    await transferExpectSuccess(collectionId, tokenId, bob, charlie);142    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);143    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);144145    // check setting SponsorTimeout = 5, success146    await waitNewBlocks(4);147    await transferExpectSuccess(collectionId, tokenId, charlie, bob);148    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);149    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;150    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);151    await destroyCollectionExpectSuccess(collectionId);152  });153});154155describe.skip('Sponsor timeout (Fungible) (only for special chain limits test)', () => {156  let alice: IKeyringPair;157  let bob: IKeyringPair;158  let charlie: IKeyringPair;159160  before(async () => {161    await usingApi(async () => {162      alice = privateKey('//Alice');163      bob = privateKey('//Bob');164      charlie = privateKey('//Charlie');165    });166  });167168  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {169    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});170    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});171    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');172    await setCollectionSponsorExpectSuccess(collectionId, alice.address);173    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');174    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');175    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');176    const aliceBalanceBefore = await getFreeBalance(alice);177178    // check setting SponsorTimeout = 5, fail179    await waitNewBlocks(5);180    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');181    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);182    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);183184    // check setting SponsorTimeout = 7, success185    await waitNewBlocks(2); // 5 + 2186    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');187    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);188    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;189    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);190191    await destroyCollectionExpectSuccess(collectionId);192  });193194  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {195196    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});197    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});198    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');199    await setCollectionSponsorExpectSuccess(collectionId, alice.address);200    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');201    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');202    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');203    const aliceBalanceBefore = await getFreeBalance(alice);204205    // check setting SponsorTimeout = 1, fail206    await waitNewBlocks(1);207    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');208    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);209    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);210211    // check setting SponsorTimeout = 5, success212    await waitNewBlocks(4);213    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');214    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);215    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;216    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);217218    await destroyCollectionExpectSuccess(collectionId);219  });220});221222describe.skip('Sponsor timeout (ReFungible) (only for special chain limits test)', () => {223  let alice: IKeyringPair;224  let bob: IKeyringPair;225  let charlie: IKeyringPair;226227  before(async () => {228    await usingApi(async () => {229      alice = privateKey('//Alice');230      bob = privateKey('//Bob');231      charlie = privateKey('//Charlie');232    });233  });234235  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {236    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});237    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});238    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');239    await setCollectionSponsorExpectSuccess(collectionId, alice.address);240    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');241    await transferExpectSuccess(collectionId, tokenId, alice, bob, 100, 'ReFungible');242    const aliceBalanceBefore = await getFreeBalance(alice);243244    // check setting SponsorTimeout = 5, fail245    await waitNewBlocks(5);246    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');247    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);248    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);249250    // check setting SponsorTimeout = 7, success251    await waitNewBlocks(2); // 5 + 2252    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');253    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);254    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;255    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);256    await destroyCollectionExpectSuccess(collectionId);257  });258259  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {260261    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});262    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});263    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');264    await setCollectionSponsorExpectSuccess(collectionId, alice.address);265    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');266    await transferExpectSuccess(collectionId, tokenId, alice, bob);267    const aliceBalanceBefore = await getFreeBalance(alice);268269    // check setting SponsorTimeout = 1, fail270    await waitNewBlocks(1);271    await transferExpectSuccess(collectionId, tokenId, bob, charlie);272    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);273    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);274275    // check setting SponsorTimeout = 5, success276    await waitNewBlocks(4);277    await transferExpectSuccess(collectionId, tokenId, charlie, bob);278    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);279    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;280    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);281    await destroyCollectionExpectSuccess(collectionId);282  });283});284285describe('Collection zero limits (NFT)', () => {286  let alice: IKeyringPair;287  let bob: IKeyringPair;288  let charlie: IKeyringPair;289290  before(async () => {291    await usingApi(async () => {292      alice = privateKey('//Alice');293      bob = privateKey('//Bob');294      charlie = privateKey('//Charlie');295    });296  });297298  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {299    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});300    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});301    for(let i = 0; i < 10; i++){302      await createItemExpectSuccess(alice, collectionId, 'NFT');303    }304    await createItemExpectFailure(alice, collectionId, 'NFT');305  });306307  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {308309    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});310    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});311    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');312    await setCollectionSponsorExpectSuccess(collectionId, alice.address);313    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');314    await transferExpectSuccess(collectionId, tokenId, alice, bob);315    const aliceBalanceBefore = await getFreeBalance(alice);316317    // check setting SponsorTimeout = 0, success with next block318    await waitNewBlocks(1);319    await transferExpectSuccess(collectionId, tokenId, bob, charlie);320    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);321    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;322    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);323  });324});325326describe('Collection zero limits (Fungible)', () => {327  let alice: IKeyringPair;328  let bob: IKeyringPair;329  let charlie: IKeyringPair;330331  before(async () => {332    await usingApi(async () => {333      alice = privateKey('//Alice');334      bob = privateKey('//Bob');335      charlie = privateKey('//Charlie');336    });337  });338339  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {340    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});341    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});342    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');343    await setCollectionSponsorExpectSuccess(collectionId, alice.address);344    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');345    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');346    const aliceBalanceBefore = await getFreeBalance(alice);347    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');348349    // check setting SponsorTimeout = 0, success with next block350    await waitNewBlocks(1);351    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');352    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);353    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;354    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);355  });356});357358describe('Collection zero limits (ReFungible)', () => {359  let alice: IKeyringPair;360  let bob: IKeyringPair;361  let charlie: IKeyringPair;362363  before(async () => {364    await usingApi(async () => {365      alice = privateKey('//Alice');366      bob = privateKey('//Bob');367      charlie = privateKey('//Charlie');368    });369  });370371  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {372    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});373    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});374    for(let i = 0; i < 10; i++){375      await createItemExpectSuccess(alice, collectionId, 'ReFungible');376    }377    await createItemExpectFailure(alice, collectionId, 'ReFungible');378  });379380  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {381382    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});383    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});384    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');385    await setCollectionSponsorExpectSuccess(collectionId, alice.address);386    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');387    await transferExpectSuccess(collectionId, tokenId, alice, bob, 100, 'ReFungible');388    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');389    const aliceBalanceBefore = await getFreeBalance(alice);390391    // check setting SponsorTimeout = 0, success with next block392    await waitNewBlocks(1);393    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');394    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);395    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;396    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);397  });398  399  it('Effective collection limits', async () => {400    await usingApi(async (api) => {401      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});402      403      { // Check that limits is undefined404        const collection = await api.rpc.unique.collectionById(collectionId);405        expect(collection.isSome).to.be.true;406        const limits = collection.unwrap().limits;407        expect(limits).to.be.any;408        409        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.null;410        expect(limits.sponsoredDataSize.toHuman()).to.be.null;411        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.null;412        expect(limits.tokenLimit.toHuman()).to.be.null;413        expect(limits.sponsorTransferTimeout.toHuman()).to.be.null;414        expect(limits.sponsorApproveTimeout.toHuman()).to.be.null;415        expect(limits.ownerCanTransfer.toHuman()).to.be.null;416        expect(limits.ownerCanDestroy.toHuman()).to.be.null;417        expect(limits.transfersEnabled.toHuman()).to.be.null;418      }419  420      { // Check that limits is undefined for non-existent collection421        const limits = await api.rpc.unique.effectiveCollectionLimits(11111);422        expect(limits.toHuman()).to.be.null;423      }424  425      { // Check that default values defined for collection limits426        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);427        expect(limitsOpt.isNone).to.be.false;428        const limits = limitsOpt.unwrap();429  430        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('100,000');431        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('2,048');432        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');433        expect(limits.tokenLimit.toHuman()).to.be.eq('4,294,967,295');434        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');435        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');436        expect(limits.ownerCanTransfer.toHuman()).to.be.true;437        expect(limits.ownerCanDestroy.toHuman()).to.be.true;438        expect(limits.transfersEnabled.toHuman()).to.be.true;439      }440441      { //Check the values for collection limits442        await setCollectionLimitsExpectSuccess(alice, collectionId, {443          accountTokenOwnershipLimit: 99_999,444          sponsoredDataSize: 1024,445          tokenLimit: 123,446          transfersEnabled: false,447        });448449        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);450        expect(limitsOpt.isNone).to.be.false;451        const limits = limitsOpt.unwrap();452  453        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('99,999');454        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('1,024');455        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');456        expect(limits.tokenLimit.toHuman()).to.be.eq('123');457        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');458        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');459        expect(limits.ownerCanTransfer.toHuman()).to.be.true;460        expect(limits.ownerCanDestroy.toHuman()).to.be.true;461        expect(limits.transfersEnabled.toHuman()).to.be.false;462      }463    });464  });465});466467
after · tests/src/limits.test.ts
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 {IKeyringPair} from '@polkadot/types/types';18import privateKey from './substrate/privateKey';19import usingApi from './substrate/substrate-api';20import {21  createCollectionExpectSuccess,22  destroyCollectionExpectSuccess,23  setCollectionLimitsExpectSuccess,24  setCollectionSponsorExpectSuccess,25  confirmSponsorshipExpectSuccess,26  createItemExpectSuccess,27  createItemExpectFailure,28  transferExpectSuccess,29  getFreeBalance,30  waitNewBlocks, burnItemExpectSuccess,31} from './util/helpers';32import {expect} from 'chai';3334describe('Number of tokens per address (NFT)', () => {35  let alice: IKeyringPair;3637  before(async () => {38    await usingApi(async () => {39      alice = privateKey('//Alice');40    });41  });4243  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {4445    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});46    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});47    for(let i = 0; i < 10; i++){48      await createItemExpectSuccess(alice, collectionId, 'NFT');49    }50    await createItemExpectFailure(alice, collectionId, 'NFT');51    for(let i = 1; i < 11; i++) {52      await burnItemExpectSuccess(alice, collectionId, i);53    }54    await destroyCollectionExpectSuccess(collectionId);55  });5657  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {5859    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});60    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});61    await createItemExpectSuccess(alice, collectionId, 'NFT');62    await createItemExpectFailure(alice, collectionId, 'NFT');63    await burnItemExpectSuccess(alice, collectionId, 1);64    await destroyCollectionExpectSuccess(collectionId);65  });66});6768describe('Number of tokens per address (ReFungible)', () => {69  let alice: IKeyringPair;7071  before(async () => {72    await usingApi(async () => {73      alice = privateKey('//Alice');74    });75  });7677  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {78    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});79    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});80    for(let i = 0; i < 10; i++){81      await createItemExpectSuccess(alice, collectionId, 'ReFungible');82    }83    await createItemExpectFailure(alice, collectionId, 'ReFungible');84    for(let i = 1; i < 11; i++) {85      await burnItemExpectSuccess(alice, collectionId, i, 100);86    }87    await destroyCollectionExpectSuccess(collectionId);88  });8990  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {91    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});92    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});93    await createItemExpectSuccess(alice, collectionId, 'ReFungible');94    await createItemExpectFailure(alice, collectionId, 'ReFungible');95    await burnItemExpectSuccess(alice, collectionId, 1, 100);96    await destroyCollectionExpectSuccess(collectionId);97  });98});99100describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {101  let alice: IKeyringPair;102  let bob: IKeyringPair;103  let charlie: IKeyringPair;104105  before(async () => {106    await usingApi(async () => {107      alice = privateKey('//Alice');108      bob = privateKey('//Bob');109      charlie = privateKey('//Charlie');110    });111  });112113  it.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {114    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});115    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});116    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');117    await setCollectionSponsorExpectSuccess(collectionId, alice.address);118    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');119    await transferExpectSuccess(collectionId, tokenId, alice, bob);120    const aliceBalanceBefore = await getFreeBalance(alice);121122    // check setting SponsorTimeout = 5, fail123    await waitNewBlocks(5);124    await transferExpectSuccess(collectionId, tokenId, bob, charlie);125    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);126    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);127128    // check setting SponsorTimeout = 7, success129    await waitNewBlocks(2); // 5 + 2130    await transferExpectSuccess(collectionId, tokenId, charlie, bob);131    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);132    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;133    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);134    await destroyCollectionExpectSuccess(collectionId);135  });136137  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {138139    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});140    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});141    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');142    await setCollectionSponsorExpectSuccess(collectionId, alice.address);143    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');144    await transferExpectSuccess(collectionId, tokenId, alice, bob);145    const aliceBalanceBefore = await getFreeBalance(alice);146147    // check setting SponsorTimeout = 1, fail148    await waitNewBlocks(1);149    await transferExpectSuccess(collectionId, tokenId, bob, charlie);150    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);151    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);152153    // check setting SponsorTimeout = 5, success154    await waitNewBlocks(4);155    await transferExpectSuccess(collectionId, tokenId, charlie, bob);156    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);157    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;158    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);159    await destroyCollectionExpectSuccess(collectionId);160  });161});162163describe.skip('Sponsor timeout (Fungible) (only for special chain limits test)', () => {164  let alice: IKeyringPair;165  let bob: IKeyringPair;166  let charlie: IKeyringPair;167168  before(async () => {169    await usingApi(async () => {170      alice = privateKey('//Alice');171      bob = privateKey('//Bob');172      charlie = privateKey('//Charlie');173    });174  });175176  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {177    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});178    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});179    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');180    await setCollectionSponsorExpectSuccess(collectionId, alice.address);181    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');182    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');183    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');184    const aliceBalanceBefore = await getFreeBalance(alice);185186    // check setting SponsorTimeout = 5, fail187    await waitNewBlocks(5);188    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');189    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);190    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);191192    // check setting SponsorTimeout = 7, success193    await waitNewBlocks(2); // 5 + 2194    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');195    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);196    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;197    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);198199    await destroyCollectionExpectSuccess(collectionId);200  });201202  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {203204    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});205    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});206    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');207    await setCollectionSponsorExpectSuccess(collectionId, alice.address);208    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');209    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');210    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');211    const aliceBalanceBefore = await getFreeBalance(alice);212213    // check setting SponsorTimeout = 1, fail214    await waitNewBlocks(1);215    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');216    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);217    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);218219    // check setting SponsorTimeout = 5, success220    await waitNewBlocks(4);221    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');222    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);223    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;224    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);225226    await destroyCollectionExpectSuccess(collectionId);227  });228});229230describe.skip('Sponsor timeout (ReFungible) (only for special chain limits test)', () => {231  let alice: IKeyringPair;232  let bob: IKeyringPair;233  let charlie: IKeyringPair;234235  before(async () => {236    await usingApi(async () => {237      alice = privateKey('//Alice');238      bob = privateKey('//Bob');239      charlie = privateKey('//Charlie');240    });241  });242243  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {244    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});245    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});246    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');247    await setCollectionSponsorExpectSuccess(collectionId, alice.address);248    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');249    await transferExpectSuccess(collectionId, tokenId, alice, bob, 100, 'ReFungible');250    const aliceBalanceBefore = await getFreeBalance(alice);251252    // check setting SponsorTimeout = 5, fail253    await waitNewBlocks(5);254    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');255    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);256    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);257258    // check setting SponsorTimeout = 7, success259    await waitNewBlocks(2); // 5 + 2260    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');261    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);262    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;263    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);264    await destroyCollectionExpectSuccess(collectionId);265  });266267  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {268269    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});270    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});271    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');272    await setCollectionSponsorExpectSuccess(collectionId, alice.address);273    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');274    await transferExpectSuccess(collectionId, tokenId, alice, bob);275    const aliceBalanceBefore = await getFreeBalance(alice);276277    // check setting SponsorTimeout = 1, fail278    await waitNewBlocks(1);279    await transferExpectSuccess(collectionId, tokenId, bob, charlie);280    const aliceBalanceAfterUnsponsoredTransaction = await getFreeBalance(alice);281    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);282283    // check setting SponsorTimeout = 5, success284    await waitNewBlocks(4);285    await transferExpectSuccess(collectionId, tokenId, charlie, bob);286    const aliceBalanceAfterSponsoredTransaction = await getFreeBalance(alice);287    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;288    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);289    await destroyCollectionExpectSuccess(collectionId);290  });291});292293describe('Collection zero limits (NFT)', () => {294  let alice: IKeyringPair;295  let bob: IKeyringPair;296  let charlie: IKeyringPair;297298  before(async () => {299    await usingApi(async () => {300      alice = privateKey('//Alice');301      bob = privateKey('//Bob');302      charlie = privateKey('//Charlie');303    });304  });305306  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {307    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});308    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});309    for(let i = 0; i < 10; i++){310      await createItemExpectSuccess(alice, collectionId, 'NFT');311    }312    await createItemExpectFailure(alice, collectionId, 'NFT');313  });314315  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {316317    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});318    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});319    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');320    await setCollectionSponsorExpectSuccess(collectionId, alice.address);321    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');322    await transferExpectSuccess(collectionId, tokenId, alice, bob);323    const aliceBalanceBefore = await getFreeBalance(alice);324325    // check setting SponsorTimeout = 0, success with next block326    await waitNewBlocks(1);327    await transferExpectSuccess(collectionId, tokenId, bob, charlie);328    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);329    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;330    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);331  });332});333334describe('Collection zero limits (Fungible)', () => {335  let alice: IKeyringPair;336  let bob: IKeyringPair;337  let charlie: IKeyringPair;338339  before(async () => {340    await usingApi(async () => {341      alice = privateKey('//Alice');342      bob = privateKey('//Bob');343      charlie = privateKey('//Charlie');344    });345  });346347  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {348    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});349    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});350    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');351    await setCollectionSponsorExpectSuccess(collectionId, alice.address);352    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');353    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');354    const aliceBalanceBefore = await getFreeBalance(alice);355    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');356357    // check setting SponsorTimeout = 0, success with next block358    await waitNewBlocks(1);359    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');360    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);361    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;362    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);363  });364});365366describe('Collection zero limits (ReFungible)', () => {367  let alice: IKeyringPair;368  let bob: IKeyringPair;369  let charlie: IKeyringPair;370371  before(async () => {372    await usingApi(async () => {373      alice = privateKey('//Alice');374      bob = privateKey('//Bob');375      charlie = privateKey('//Charlie');376    });377  });378379  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {380    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});381    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});382    for(let i = 0; i < 10; i++){383      await createItemExpectSuccess(alice, collectionId, 'ReFungible');384    }385    await createItemExpectFailure(alice, collectionId, 'ReFungible');386  });387388  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {389390    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});391    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});392    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');393    await setCollectionSponsorExpectSuccess(collectionId, alice.address);394    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');395    await transferExpectSuccess(collectionId, tokenId, alice, bob, 100, 'ReFungible');396    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');397    const aliceBalanceBefore = await getFreeBalance(alice);398399    // check setting SponsorTimeout = 0, success with next block400    await waitNewBlocks(1);401    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');402    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);403    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;404    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);405  });406  407  it('Effective collection limits', async () => {408    await usingApi(async (api) => {409      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});410      411      { // Check that limits is undefined412        const collection = await api.rpc.unique.collectionById(collectionId);413        expect(collection.isSome).to.be.true;414        const limits = collection.unwrap().limits;415        expect(limits).to.be.any;416        417        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.null;418        expect(limits.sponsoredDataSize.toHuman()).to.be.null;419        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.null;420        expect(limits.tokenLimit.toHuman()).to.be.null;421        expect(limits.sponsorTransferTimeout.toHuman()).to.be.null;422        expect(limits.sponsorApproveTimeout.toHuman()).to.be.null;423        expect(limits.ownerCanTransfer.toHuman()).to.be.null;424        expect(limits.ownerCanDestroy.toHuman()).to.be.null;425        expect(limits.transfersEnabled.toHuman()).to.be.null;426      }427  428      { // Check that limits is undefined for non-existent collection429        const limits = await api.rpc.unique.effectiveCollectionLimits(11111);430        expect(limits.toHuman()).to.be.null;431      }432  433      { // Check that default values defined for collection limits434        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);435        expect(limitsOpt.isNone).to.be.false;436        const limits = limitsOpt.unwrap();437  438        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('100,000');439        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('2,048');440        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');441        expect(limits.tokenLimit.toHuman()).to.be.eq('4,294,967,295');442        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');443        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');444        expect(limits.ownerCanTransfer.toHuman()).to.be.true;445        expect(limits.ownerCanDestroy.toHuman()).to.be.true;446        expect(limits.transfersEnabled.toHuman()).to.be.true;447      }448449      { //Check the values for collection limits450        await setCollectionLimitsExpectSuccess(alice, collectionId, {451          accountTokenOwnershipLimit: 99_999,452          sponsoredDataSize: 1024,453          tokenLimit: 123,454          transfersEnabled: false,455        });456457        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);458        expect(limitsOpt.isNone).to.be.false;459        const limits = limitsOpt.unwrap();460  461        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('99,999');462        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('1,024');463        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');464        expect(limits.tokenLimit.toHuman()).to.be.eq('123');465        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');466        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');467        expect(limits.ownerCanTransfer.toHuman()).to.be.true;468        expect(limits.ownerCanDestroy.toHuman()).to.be.true;469        expect(limits.transfersEnabled.toHuman()).to.be.false;470      }471    });472  });473});474475
modifiedtests/src/nextSponsoring.test.tsdiffbeforeafterboth
--- a/tests/src/nextSponsoring.test.ts
+++ b/tests/src/nextSponsoring.test.ts
@@ -68,7 +68,7 @@
 
       // After transfer
       await transferExpectSuccess(collectionId, itemId, alice, bob, 1);
-      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.equal(5);
+      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.lessThanOrEqual(5);
 
       // Not existing token 
       expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId+1)).to.be.equal(-1);
@@ -86,7 +86,7 @@
       expect(await getNextSponsored(api, funCollectionId, normalizeAccountId(alice), 0)).to.be.equal(0);
 
       await transferExpectSuccess(funCollectionId, 0, alice, bob, 10, 'Fungible');
-      expect(await getNextSponsored(api, funCollectionId, normalizeAccountId(alice), 0)).to.be.equal(5);
+      expect(await getNextSponsored(api, funCollectionId, normalizeAccountId(alice), 0)).to.be.lessThanOrEqual(5);
     });
   });
 
@@ -101,7 +101,7 @@
       expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId)).to.be.equal(0);
 
       await transferExpectSuccess(refunCollectionId, refunItemId, alice, bob, 10, 'ReFungible');
-      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId)).to.be.equal(5);
+      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId)).to.be.lessThanOrEqual(5);
 
       // Not existing token 
       expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId+1)).to.be.equal(-1);
modifiedtests/src/transfer.test.tsdiffbeforeafterboth
--- a/tests/src/transfer.test.ts
+++ b/tests/src/transfer.test.ts
@@ -168,17 +168,20 @@
     // nft
     const nftCollectionId = await createCollectionExpectSuccess();
     const newNftTokenId = await createItemExpectSuccess(alice, nftCollectionId, 'NFT');
+    await burnItemExpectSuccess(alice, nftCollectionId, newNftTokenId);
     await destroyCollectionExpectSuccess(nftCollectionId);
     await transferExpectFailure(nftCollectionId, newNftTokenId, alice, bob, 1);
     // fungible
     const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
     const newFungibleTokenId = await createItemExpectSuccess(alice, fungibleCollectionId, 'Fungible');
+    await burnItemExpectSuccess(alice, fungibleCollectionId, newFungibleTokenId, 10);
     await destroyCollectionExpectSuccess(fungibleCollectionId);
     await transferExpectFailure(fungibleCollectionId, newFungibleTokenId, alice, bob, 1);
     // reFungible
     const reFungibleCollectionId = await
     createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
     const newReFungibleTokenId = await createItemExpectSuccess(alice, reFungibleCollectionId, 'ReFungible');
+    await burnItemExpectSuccess(alice, reFungibleCollectionId, newReFungibleTokenId, 100);
     await destroyCollectionExpectSuccess(reFungibleCollectionId);
     await transferExpectFailure(
       reFungibleCollectionId,