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

35    const defaultTokenId = await collection.getLastTokenId();35    const defaultTokenId = await collection.getLastTokenId();
36    expect(defaultTokenId).to.be.equal(0);36    expect(defaultTokenId).to.be.equal(0);
3737
38    await collection.mint(alice, {Substrate: alice.address}, U128_MAX);38    await collection.mint(alice, U128_MAX);
39    const aliceBalance = await collection.getBalance({Substrate: alice.address});39    const aliceBalance = await collection.getBalance({Substrate: alice.address});
40    const itemCountAfter = await collection.getLastTokenId();40    const itemCountAfter = await collection.getLastTokenId();
4141
4949
50    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});50    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
5151
52    await collection.mint(alice, {Substrate: alice.address}, U128_MAX);52    await collection.mint(alice, U128_MAX);
5353
54    await collection.transfer(alice, {Substrate: bob.address}, 1000n);54    await collection.transfer(alice, {Substrate: bob.address}, 1000n);
55    await collection.transfer(alice, ethAcc, 900n);55    await collection.transfer(alice, ethAcc, 900n);
72  itSub('Transfer token', async ({helper}) => {72  itSub('Transfer token', async ({helper}) => {
73    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};73    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
74    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});74    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
75    await collection.mint(alice, {Substrate: alice.address}, 500n);75    await collection.mint(alice, 500n);
7676
77    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);77    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
78    expect(await collection.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;78    expect(await collection.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
88  itSub('Tokens multiple creation', async ({helper}) => {88  itSub('Tokens multiple creation', async ({helper}) => {
89    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});89    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
9090
91    await collection.mintWithOneOwner(alice, {Substrate: alice.address}, [91    await collection.mintWithOneOwner(alice, [
92      {value: 500n},92      {value: 500n},
93      {value: 400n},93      {value: 400n},
94      {value: 300n},94      {value: 300n},
9999
100  itSub('Burn some tokens ', async ({helper}) => {100  itSub('Burn some tokens ', async ({helper}) => {
101    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});101    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
102    await collection.mint(alice, {Substrate: alice.address}, 500n);102    await collection.mint(alice, 500n);
103103
104    expect(await collection.isTokenExists(0)).to.be.true;104    expect(await collection.isTokenExists(0)).to.be.true;
105    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);105    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
110  110  
111  itSub('Burn all tokens ', async ({helper}) => {111  itSub('Burn all tokens ', async ({helper}) => {
112    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});112    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
113    await collection.mint(alice, {Substrate: alice.address}, 500n);113    await collection.mint(alice, 500n);
114114
115    expect(await collection.isTokenExists(0)).to.be.true;115    expect(await collection.isTokenExists(0)).to.be.true;
116    expect(await collection.burnTokens(alice, 500n)).to.be.true;116    expect(await collection.burnTokens(alice, 500n)).to.be.true;
123  itSub('Set allowance for token', async ({helper}) => {123  itSub('Set allowance for token', async ({helper}) => {
124    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});124    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
125    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};125    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
126    await collection.mint(alice, {Substrate: alice.address}, 100n);126    await collection.mint(alice, 100n);
127127
128    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(100n);128    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(100n);
129    129    

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 {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import usingApi from './substrate/substrate-api';18import {expect, itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds} from './util/playgrounds';
19import {
20  createCollectionExpectSuccess,
21  destroyCollectionExpectSuccess,
22  setCollectionLimitsExpectSuccess,
23  setCollectionSponsorExpectSuccess,
24  confirmSponsorshipExpectSuccess,
25  createItemExpectSuccess,
26  createItemExpectFailure,
27  transferExpectSuccess,
28  getFreeBalance,
29  waitNewBlocks, burnItemExpectSuccess,
30  requirePallets,
31  Pallets,
32} from './util/helpers';
33import {expect} from 'chai';
3419
35describe('Number of tokens per address (NFT)', () => {20describe('Number of tokens per address (NFT)', () => {
36  let alice: IKeyringPair;21  let alice: IKeyringPair;
3722
38  before(async () => {23  before(async () => {
39    await usingApi(async (api, privateKeyWrapper) => {24    await usingPlaygrounds(async (helper, privateKey) => {
40      alice = privateKeyWrapper('//Alice');25      const donor = privateKey('//Alice');
26      [alice] = await helper.arrange.createAccounts([10n], donor);
41    });27    });
42  });28  });
4329
44  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {30  itSub.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async ({helper}) => {
45
46    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});31    const collection = await helper.nft.mintCollection(alice, {});
47    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});32    await collection.setLimits(alice, {accountTokenOwnershipLimit: 20});
33    
48    for(let i = 0; i < 10; i++){34    for(let i = 0; i < 10; i++){
49      await createItemExpectSuccess(alice, collectionId, 'NFT');35      await expect(collection.mintToken(alice)).to.be.not.rejected;
50    }36    }
51    await createItemExpectFailure(alice, collectionId, 'NFT');37    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
52    for(let i = 1; i < 11; i++) {38    for(let i = 1; i < 11; i++) {
53      await burnItemExpectSuccess(alice, collectionId, i);39      await expect(collection.burnToken(alice, i)).to.be.not.rejected;
54    }40    }
55    await destroyCollectionExpectSuccess(collectionId);41    await collection.burn(alice);
56  });42  });
43  
44  itSub('Collection limits allow lower number than chain limits, collection limits are enforced', async ({helper}) => {
45    const collection = await helper.nft.mintCollection(alice, {});
46    await collection.setLimits(alice, {accountTokenOwnershipLimit: 1});
5747
58  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {48    await collection.mintToken(alice);
59
60    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
61    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});49    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
62    await createItemExpectSuccess(alice, collectionId, 'NFT');
63    await createItemExpectFailure(alice, collectionId, 'NFT');50    
64    await burnItemExpectSuccess(alice, collectionId, 1);51    await collection.burnToken(alice, 1);
65    await destroyCollectionExpectSuccess(collectionId);52    await expect(collection.burn(alice)).to.be.not.rejected;
66  });53  });
67});54});
6855
69describe('Number of tokens per address (ReFungible)', () => {56describe('Number of tokens per address (ReFungible)', () => {
70  let alice: IKeyringPair;57  let alice: IKeyringPair;
7158
72  before(async function() {59  before(async function() {
73    await requirePallets(this, [Pallets.ReFungible]);60    await usingPlaygrounds(async (helper, privateKey) => {
61      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
7462
75    await usingApi(async (api, privateKeyWrapper) => {63      const donor = privateKey('//Alice');
76      alice = privateKeyWrapper('//Alice');64      [alice] = await helper.arrange.createAccounts([10n], donor);
77    });65    });
78  });66  });
7967
80  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {68  itSub.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async ({helper}) => {
81    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});69    const collection = await helper.rft.mintCollection(alice, {});
82    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});70    await collection.setLimits(alice, {accountTokenOwnershipLimit: 20});
71    
83    for(let i = 0; i < 10; i++){72    for(let i = 0; i < 10; i++){
84      await createItemExpectSuccess(alice, collectionId, 'ReFungible');73      await expect(collection.mintToken(alice, 10n)).to.be.not.rejected;
85    }74    }
86    await createItemExpectFailure(alice, collectionId, 'ReFungible');75    await expect(collection.mintToken(alice, 10n)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
87    for(let i = 1; i < 11; i++) {76    for(let i = 1; i < 11; i++) {
88      await burnItemExpectSuccess(alice, collectionId, i, 100);77      await expect(collection.burnToken(alice, i, 10n)).to.be.not.rejected;
89    }78    }
90    await destroyCollectionExpectSuccess(collectionId);79    await collection.burn(alice);
91  });80  });
9281
93  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {82  itSub('Collection limits allow lower number than chain limits, collection limits are enforced', async ({helper}) => {
94    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});83    const collection = await helper.rft.mintCollection(alice, {});
95    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});84    await collection.setLimits(alice, {accountTokenOwnershipLimit: 1});
85
96    await createItemExpectSuccess(alice, collectionId, 'ReFungible');86    await collection.mintToken(alice);
97    await createItemExpectFailure(alice, collectionId, 'ReFungible');87    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
98    await burnItemExpectSuccess(alice, collectionId, 1, 100);88    
89    await collection.burnToken(alice, 1);
99    await destroyCollectionExpectSuccess(collectionId);90    await expect(collection.burn(alice)).to.be.not.rejected;
100  });91  });
101});92});
10293
94// todo:playgrounds skipped ~ postponed
103describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {95describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {
104  let alice: IKeyringPair;96  /*let alice: IKeyringPair;
105  let bob: IKeyringPair;97  let bob: IKeyringPair;
106  let charlie: IKeyringPair;98  let charlie: IKeyringPair;
10799
113    });105    });
114  });106  });
115107
116  it.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {108  itSub.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
117    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});109    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
118    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});110    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
119    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');111    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
137    await destroyCollectionExpectSuccess(collectionId);129    await destroyCollectionExpectSuccess(collectionId);
138  });130  });
139131
140  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {132  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
141133
142    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});134    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
143    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});135    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
176    });168    });
177  });169  });
178170
179  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {171  itSub('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
180    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});172    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
181    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});173    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
182    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');174    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');
202    await destroyCollectionExpectSuccess(collectionId);194    await destroyCollectionExpectSuccess(collectionId);
203  });195  });
204196
205  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {197  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
206198
207    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});199    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
208    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});200    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
243    });235    });
244  });236  });
245237
246  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {238  itSub('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
247    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});239    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
248    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});240    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
249    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');241    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');
267    await destroyCollectionExpectSuccess(collectionId);259    await destroyCollectionExpectSuccess(collectionId);
268  });260  });
269261
270  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {262  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
271263
272    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});264    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
273    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});265    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
290    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;282    expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;
291    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);283    //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
292    await destroyCollectionExpectSuccess(collectionId);284    await destroyCollectionExpectSuccess(collectionId);
293  });285  });*/
294});286});
295287
296describe('Collection zero limits (NFT)', () => {288describe('Collection zero limits (NFT)', () => {
299  let charlie: IKeyringPair;291  let charlie: IKeyringPair;
300292
301  before(async () => {293  before(async () => {
302    await usingApi(async (api, privateKeyWrapper) => {294    await usingPlaygrounds(async (helper, privateKey) => {
303      alice = privateKeyWrapper('//Alice');295      const donor = privateKey('//Alice');
304      bob = privateKeyWrapper('//Bob');296      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
305      charlie = privateKeyWrapper('//Charlie');
306    });297    });
307  });298  });
308299
309  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {300  itSub.skip('Limits have 0 in tokens per address field, the chain limits are applied', async ({helper}) => {
310    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});301    const collection = await helper.nft.mintCollection(alice, {});
311    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});302    await collection.setLimits(alice, {accountTokenOwnershipLimit: 0});
303
312    for(let i = 0; i < 10; i++){304    for(let i = 0; i < 10; i++){
313      await createItemExpectSuccess(alice, collectionId, 'NFT');305      await collection.mintToken(alice);
314    }306    }
315    await createItemExpectFailure(alice, collectionId, 'NFT');307    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
316  });308  });
317309
318  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {310  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
311    const collection = await helper.nft.mintCollection(alice, {});
312    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
313    const token = await collection.mintToken(alice);
319314
320    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});315    await collection.setSponsor(alice, alice.address);
321    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});
322    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
323    await setCollectionSponsorExpectSuccess(collectionId, alice.address);316    await collection.confirmSponsorship(alice);
324    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');317    
325    await transferExpectSuccess(collectionId, tokenId, alice, bob);318    await token.transfer(alice, {Substrate: bob.address});
326    const aliceBalanceBefore = await getFreeBalance(alice);319    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
327320
328    // check setting SponsorTimeout = 0, success with next block321    // check setting SponsorTimeout = 0, success with next block
329    await waitNewBlocks(1);322    await helper.wait.newBlocks(1);
330    await transferExpectSuccess(collectionId, tokenId, bob, charlie);323    await token.transfer(bob, {Substrate: charlie.address});
331    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);324    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
332    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;325    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
333    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
334  });326  });
335});327});
336328
340  let charlie: IKeyringPair;332  let charlie: IKeyringPair;
341333
342  before(async () => {334  before(async () => {
343    await usingApi(async (api, privateKeyWrapper) => {335    await usingPlaygrounds(async (helper, privateKey) => {
344      alice = privateKeyWrapper('//Alice');336      const donor = privateKey('//Alice');
345      bob = privateKeyWrapper('//Bob');337      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
346      charlie = privateKeyWrapper('//Charlie');
347    });338    });
348  });339  });
349340
350  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {341  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
351    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});342    const collection = await helper.ft.mintCollection(alice, {});
352    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});343    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
353    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');344    await collection.mint(alice, 3n);
354    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
355    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
356    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');
357    const aliceBalanceBefore = await getFreeBalance(alice);
358    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');
359345
346    await collection.setSponsor(alice, alice.address);
347    await collection.confirmSponsorship(alice);
348    
349    await collection.transfer(alice, {Substrate: bob.address}, 2n);
350    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
351
360    // check setting SponsorTimeout = 0, success with next block352    // check setting SponsorTimeout = 0, success with next block
361    await waitNewBlocks(1);353    await helper.wait.newBlocks(1);
362    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');354    await collection.transfer(bob, {Substrate: charlie.address});
363    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);355    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
364    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;356    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
365    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
366  });357  });
367});358});
368359
372  let charlie: IKeyringPair;363  let charlie: IKeyringPair;
373364
374  before(async function() {365  before(async function() {
375    await requirePallets(this, [Pallets.ReFungible]);366    await usingPlaygrounds(async (helper, privateKey) => {
367      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
376368
377    await usingApi(async (api, privateKeyWrapper) => {369      const donor = privateKey('//Alice');
378      alice = privateKeyWrapper('//Alice');
379      bob = privateKeyWrapper('//Bob');370      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
380      charlie = privateKeyWrapper('//Charlie');
381    });371    });
382  });372  });
383373
384  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {374  itSub.skip('Limits have 0 in tokens per address field, the chain limits are applied', async ({helper}) => {
385    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});375    const collection = await helper.rft.mintCollection(alice, {});
386    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});376    await collection.setLimits(alice, {accountTokenOwnershipLimit: 0});
387    for(let i = 0; i < 10; i++){377    for(let i = 0; i < 10; i++){
388      await createItemExpectSuccess(alice, collectionId, 'ReFungible');378      await collection.mintToken(alice);
389    }379    }
390    await createItemExpectFailure(alice, collectionId, 'ReFungible');380    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
391  });381  });
392382
393  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {383  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
384    const collection = await helper.rft.mintCollection(alice, {});
385    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
386    const token = await collection.mintToken(alice, 3n);
394387
395    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});388    await collection.setSponsor(alice, alice.address);
396    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});
397    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');
398    await setCollectionSponsorExpectSuccess(collectionId, alice.address);389    await collection.confirmSponsorship(alice);
399    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');390    
400    await transferExpectSuccess(collectionId, tokenId, alice, bob, 100, 'ReFungible');391    await token.transfer(alice, {Substrate: bob.address}, 2n);
401    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');
402    const aliceBalanceBefore = await getFreeBalance(alice);392    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
403393
404    // check setting SponsorTimeout = 0, success with next block394    // check setting SponsorTimeout = 0, success with next block
405    await waitNewBlocks(1);395    await helper.wait.newBlocks(1);
406    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');396    await token.transfer(bob, {Substrate: charlie.address});
407    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);397    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
408    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;398    expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
409    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
410  });399  });
411  
412  it('Effective collection limits', async () => {
413    await usingApi(async (api) => {
414      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});400});
415      await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true});
416      
417      { // Check that limits is undefined
418        const collection = await api.rpc.unique.collectionById(collectionId);
419        expect(collection.isSome).to.be.true;
420        const limits = collection.unwrap().limits;
421        expect(limits).to.be.any;
422        
423        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.null;
424        expect(limits.sponsoredDataSize.toHuman()).to.be.null;
425        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.null;
426        expect(limits.tokenLimit.toHuman()).to.be.null;
427        expect(limits.sponsorTransferTimeout.toHuman()).to.be.null;
428        expect(limits.sponsorApproveTimeout.toHuman()).to.be.null;
429        expect(limits.ownerCanTransfer.toHuman()).to.be.true;
430        expect(limits.ownerCanDestroy.toHuman()).to.be.null;
431        expect(limits.transfersEnabled.toHuman()).to.be.null;
432      }
433  
434      { // Check that limits is undefined for non-existent collection
435        const limits = await api.rpc.unique.effectiveCollectionLimits(11111);
436        expect(limits.toHuman()).to.be.null;
437      }
438  
439      { // Check that default values defined for collection limits
440        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);
441        expect(limitsOpt.isNone).to.be.false;
442        const limits = limitsOpt.unwrap();
443  
444        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('100,000');
445        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('2,048');
446        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');
447        expect(limits.tokenLimit.toHuman()).to.be.eq('4,294,967,295');
448        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');
449        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');
450        expect(limits.ownerCanTransfer.toHuman()).to.be.true;
451        expect(limits.ownerCanDestroy.toHuman()).to.be.true;
452        expect(limits.transfersEnabled.toHuman()).to.be.true;
453      }
454401
455      { //Check the values for collection limits402describe('Effective collection limits (NFT)', () => {
456        await setCollectionLimitsExpectSuccess(alice, collectionId, {
457          accountTokenOwnershipLimit: 99_999,403  let alice: IKeyringPair;
458          sponsoredDataSize: 1024,
459          tokenLimit: 123,
460          transfersEnabled: false,
461        });
462404
463        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);405  before(async () => {
464        expect(limitsOpt.isNone).to.be.false;
465        const limits = limitsOpt.unwrap();
466  406    await usingPlaygrounds(async (helper, privateKey) => {
467        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('99,999');
468        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('1,024');
469        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');
470        expect(limits.tokenLimit.toHuman()).to.be.eq('123');
471        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');407      const donor = privateKey('//Alice');
472        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');
473        expect(limits.ownerCanTransfer.toHuman()).to.be.true;408      [alice] = await helper.arrange.createAccounts([10n], donor);
474        expect(limits.ownerCanDestroy.toHuman()).to.be.true;
475        expect(limits.transfersEnabled.toHuman()).to.be.false;
476      }
477    });409    });
478  });410  });
411  
479});412  itSub('Effective collection limits', async ({helper}) => {
413    const collection = await helper.nft.mintCollection(alice, {});
414    await collection.setLimits(alice, {ownerCanTransfer: true});    
415    
416    { 
417      // Check that limits are undefined
418      const collectionInfo = await collection.getData();
419      const limits = collectionInfo?.raw.limits;
420      expect(limits).to.be.any;
421      
422      expect(limits.accountTokenOwnershipLimit).to.be.null;
423      expect(limits.sponsoredDataSize).to.be.null;
424      expect(limits.sponsoredDataRateLimit).to.be.null;
425      expect(limits.tokenLimit).to.be.null;
426      expect(limits.sponsorTransferTimeout).to.be.null;
427      expect(limits.sponsorApproveTimeout).to.be.null;
428      expect(limits.ownerCanTransfer).to.be.true;
429      expect(limits.ownerCanDestroy).to.be.null;
430      expect(limits.transfersEnabled).to.be.null;
431    }
480432
433    { // Check that limits is undefined for non-existent collection
434      const limits = await helper.collection.getEffectiveLimits(999999);
435      expect(limits).to.be.null;
436    }
481437
438    { // Check that default values defined for collection limits
439      const limits = await collection.getEffectiveLimits();
440
441      expect(limits.accountTokenOwnershipLimit).to.be.eq(100000);
442      expect(limits.sponsoredDataSize).to.be.eq(2048);
443      expect(limits.sponsoredDataRateLimit).to.be.deep.eq({sponsoringDisabled: null});
444      expect(limits.tokenLimit).to.be.eq(4294967295);
445      expect(limits.sponsorTransferTimeout).to.be.eq(5);
446      expect(limits.sponsorApproveTimeout).to.be.eq(5);
447      expect(limits.ownerCanTransfer).to.be.true;
448      expect(limits.ownerCanDestroy).to.be.true;
449      expect(limits.transfersEnabled).to.be.true;
450    }
451
452    { 
453      // Check the values for collection limits
454      await collection.setLimits(alice, {
455        accountTokenOwnershipLimit: 99_999,
456        sponsoredDataSize: 1024,
457        tokenLimit: 123,
458        transfersEnabled: false,
459      });
460
461      const limits = await collection.getEffectiveLimits();
462
463      expect(limits.accountTokenOwnershipLimit).to.be.eq(99999);
464      expect(limits.sponsoredDataSize).to.be.eq(1024);
465      expect(limits.sponsoredDataRateLimit).to.be.deep.eq({sponsoringDisabled: null});
466      expect(limits.tokenLimit).to.be.eq(123);
467      expect(limits.sponsorTransferTimeout).to.be.eq(5);
468      expect(limits.sponsorApproveTimeout).to.be.eq(5);
469      expect(limits.ownerCanTransfer).to.be.true;
470      expect(limits.ownerCanDestroy).to.be.true;
471      expect(limits.transfersEnabled).to.be.false;
472    }
473  });
474});
482475

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 {ApiPromise} from '@polkadot/api';
18import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
19import chai from 'chai';
20import chaiAsPromised from 'chai-as-promised';
21import {default as usingApi} from './substrate/substrate-api';
22import {18import {expect, itSub, Pallets, usingPlaygrounds} from './util/playgrounds';
23  createCollectionExpectSuccess,19
24  setCollectionSponsorExpectSuccess,
25  confirmSponsorshipExpectSuccess,
26  createItemExpectSuccess,
27  transferExpectSuccess,
28  normalizeAccountId,
29  getNextSponsored,
30  requirePallets,
31  Pallets,
32} from './util/helpers';
33
34chai.use(chaiAsPromised);
35const expect = chai.expect;20const SPONSORING_TIMEOUT = 5;
36
37
3821
41  let bob: IKeyringPair;24  let bob: IKeyringPair;
4225
43  before(async () => {26  before(async () => {
44    await usingApi(async (api, privateKeyWrapper) => {27    await usingPlaygrounds(async (helper, privateKey) => {
45      alice = privateKeyWrapper('//Alice');28      const donor = privateKey('//Alice');
46      bob = privateKeyWrapper('//Bob');29      [alice, bob] = await helper.arrange.createAccounts([20n, 10n], donor);
47    });30    });
48  });31  });
4932
50  it('NFT', async () => {33  itSub('NFT', async ({helper}) => {
51    await usingApi(async (api: ApiPromise) => {
52
53      // Not existing collection 34    // Non-existing collection
54      expect(await getNextSponsored(api, 0, normalizeAccountId(alice), 0)).to.be.equal(-1);35    expect(await helper.collection.getTokenNextSponsored(0, 0, {Substrate: alice.address})).to.be.null;
5536
56      const collectionId = await createCollectionExpectSuccess();37    const collection = await helper.nft.mintCollection(alice, {});
57      const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);38    const token = await collection.mintToken(alice);
5839
59      // Check with Disabled sponsoring state40    // Check with Disabled sponsoring state
60      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.equal(-1);41    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.null;
42    
43    // Check with Unconfirmed sponsoring state
61      await setCollectionSponsorExpectSuccess(collectionId, bob.address);44    await collection.setSponsor(alice, bob.address);
62
63      // Check with Unconfirmed sponsoring state
64      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.equal(-1);45    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.null;
46
47    // Check with Confirmed sponsoring state
65      await confirmSponsorshipExpectSuccess(collectionId, '//Bob');48    await collection.confirmSponsorship(bob);
66
67      // Check with Confirmed sponsoring state
68      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.equal(0);49    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.equal(0);
6950
70      // After transfer51    // Check after transfer
71      await transferExpectSuccess(collectionId, itemId, alice, bob, 1);52    await token.transfer(alice, {Substrate: bob.address});
72      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.lessThanOrEqual(5);53    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.lessThanOrEqual(SPONSORING_TIMEOUT);
7354
74      // Not existing token 55    // Non-existing token 
75      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId+1)).to.be.equal(-1);56    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.null;
76    });
77  });57  });
7858
79  it('Fungible', async () => {59  itSub('Fungible', async ({helper}) => {
80    await usingApi(async (api: ApiPromise) => {
81
82      const createMode = 'Fungible';60    const collection = await helper.ft.mintCollection(alice, {});
83      const funCollectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});61    await collection.mint(alice, 10n);
62
63    // Check with Disabled sponsoring state
84      await createItemExpectSuccess(alice, funCollectionId, createMode);64    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.null;
65
85      await setCollectionSponsorExpectSuccess(funCollectionId, bob.address);66    await collection.setSponsor(alice, bob.address);
86      await confirmSponsorshipExpectSuccess(funCollectionId, '//Bob');67    await collection.confirmSponsorship(bob);
68    
69    // Check with Confirmed sponsoring state
87      expect(await getNextSponsored(api, funCollectionId, normalizeAccountId(alice), 0)).to.be.equal(0);70    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.equal(0);
8871
72    // Check after transfer
89      await transferExpectSuccess(funCollectionId, 0, alice, bob, 10, 'Fungible');73    await collection.transfer(alice, {Substrate: bob.address});
90      expect(await getNextSponsored(api, funCollectionId, normalizeAccountId(alice), 0)).to.be.lessThanOrEqual(5);74    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.lessThanOrEqual(SPONSORING_TIMEOUT);
91    });
92  });75  });
9376
94  it('ReFungible', async function() {77  itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => {
95    await requirePallets(this, [Pallets.ReFungible]);
96
97    await usingApi(async (api: ApiPromise) => {
98
99      const createMode = 'ReFungible';78    const collection = await helper.rft.mintCollection(alice, {});
100      const refunCollectionId = await createCollectionExpectSuccess({mode: {type: createMode}});79    const token = await collection.mintToken(alice, 10n);
80
81    // Check with Disabled sponsoring state
101      const refunItemId = await createItemExpectSuccess(alice, refunCollectionId, createMode);82    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.null;
83
102      await setCollectionSponsorExpectSuccess(refunCollectionId, bob.address);84    await collection.setSponsor(alice, bob.address);
103      await confirmSponsorshipExpectSuccess(refunCollectionId, '//Bob');85    await collection.confirmSponsorship(bob);
86
87    // Check with Confirmed sponsoring state
104      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId)).to.be.equal(0);88    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.equal(0);
10589
90    // Check after transfer
106      await transferExpectSuccess(refunCollectionId, refunItemId, alice, bob, 10, 'ReFungible');91    await token.transfer(alice, {Substrate: bob.address});
107      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId)).to.be.lessThanOrEqual(5);92    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.lessThanOrEqual(SPONSORING_TIMEOUT);
10893
109      // Not existing token 94    // Non-existing token 
110      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId+1)).to.be.equal(-1);95    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.null;
111    });96  });
112  });
113});97});
11498

35    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});35    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
3636
37    const itemCountBefore = await collection.getLastTokenId();37    const itemCountBefore = await collection.getLastTokenId();
38    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);38    const token = await collection.mintToken(alice, 100n);
39    39    
40    const itemCountAfter = await collection.getLastTokenId();40    const itemCountAfter = await collection.getLastTokenId();
41    41    
48  itSub('Checking RPC methods when interacting with maximum allowed values (MAX_REFUNGIBLE_PIECES)', async ({helper}) => {48  itSub('Checking RPC methods when interacting with maximum allowed values (MAX_REFUNGIBLE_PIECES)', async ({helper}) => {
49    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});49    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
50    50    
51    const token = await collection.mintToken(alice, {Substrate: alice.address}, MAX_REFUNGIBLE_PIECES);51    const token = await collection.mintToken(alice, MAX_REFUNGIBLE_PIECES);
52    52    
53    expect(await collection.getTokenBalance(token.tokenId, {Substrate: alice.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);53    expect(await collection.getTokenBalance(token.tokenId, {Substrate: alice.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);
54    54    
55    await collection.transferToken(alice, token.tokenId, {Substrate: bob.address}, MAX_REFUNGIBLE_PIECES);55    await collection.transferToken(alice, token.tokenId, {Substrate: bob.address}, MAX_REFUNGIBLE_PIECES);
56    expect(await collection.getTokenBalance(token.tokenId, {Substrate: bob.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);56    expect(await collection.getTokenBalance(token.tokenId, {Substrate: bob.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);
57    expect(await token.getTotalPieces()).to.be.equal(MAX_REFUNGIBLE_PIECES);57    expect(await token.getTotalPieces()).to.be.equal(MAX_REFUNGIBLE_PIECES);
58    58    
59    await expect(collection.mintToken(alice, {Substrate: alice.address}, MAX_REFUNGIBLE_PIECES + 1n))59    await expect(collection.mintToken(alice, MAX_REFUNGIBLE_PIECES + 1n))
60      .to.eventually.be.rejectedWith(/refungible\.WrongRefungiblePieces/);60      .to.eventually.be.rejectedWith(/refungible\.WrongRefungiblePieces/);
61  });61  });
62  62  
6666
67    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});67    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
6868
69    const token = await collection.mintToken(alice, {Substrate: alice.address}, 10_000n);69    const token = await collection.mintToken(alice, 10_000n);
7070
71    await token.transfer(alice, {Substrate: bob.address}, 1000n);71    await token.transfer(alice, {Substrate: bob.address}, 1000n);
72    await token.transfer(alice, ethAcc, 900n);72    await token.transfer(alice, ethAcc, 900n);
88  88  
89  itSub('Transfer token pieces', async ({helper}) => {89  itSub('Transfer token pieces', async ({helper}) => {
90    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});90    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
91    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);91    const token = await collection.mintToken(alice, 100n);
9292
93    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);93    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
94    expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;94    expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
120120
121  itSub('Burn some pieces', async ({helper}) => {121  itSub('Burn some pieces', async ({helper}) => {
122    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});122    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
123    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);123    const token = await collection.mintToken(alice, 100n);
124    expect(await collection.isTokenExists(token.tokenId)).to.be.true;124    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
125    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);125    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
126    expect((await token.burn(alice, 99n)).success).to.be.true;126    expect((await token.burn(alice, 99n)).success).to.be.true;
130130
131  itSub('Burn all pieces', async ({helper}) => {131  itSub('Burn all pieces', async ({helper}) => {
132    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});132    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
133    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);133    const token = await collection.mintToken(alice, 100n);
134    134    
135    expect(await collection.isTokenExists(token.tokenId)).to.be.true;135    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
136    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);136    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
141141
142  itSub('Burn some pieces for multiple users', async ({helper}) => {142  itSub('Burn some pieces for multiple users', async ({helper}) => {
143    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});143    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
144    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);144    const token = await collection.mintToken(alice, 100n);
145145
146    expect(await collection.isTokenExists(token.tokenId)).to.be.true;146    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
147    147    
168168
169  itSub('Set allowance for token', async ({helper}) => {169  itSub('Set allowance for token', async ({helper}) => {
170    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});170    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
171    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);171    const token = await collection.mintToken(alice, 100n);
172    172    
173    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);173    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
174174
183183
184  itSub('Repartition', async ({helper}) => {184  itSub('Repartition', async ({helper}) => {
185    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});185    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
186    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);186    const token = await collection.mintToken(alice, 100n);
187187
188    expect(await token.repartition(alice, 200n)).to.be.true;188    expect(await token.repartition(alice, 200n)).to.be.true;
189    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(200n);189    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(200n);
207207
208  itSub('Repartition with increased amount', async ({helper}) => {208  itSub('Repartition with increased amount', async ({helper}) => {
209    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});209    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
210    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);210    const token = await collection.mintToken(alice, 100n);
211    await token.repartition(alice, 200n);211    await token.repartition(alice, 200n);
212    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);212    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
213    expect(chainEvents).to.include.deep.members([{213    expect(chainEvents).to.include.deep.members([{
225225
226  itSub('Repartition with decreased amount', async ({helper}) => {226  itSub('Repartition with decreased amount', async ({helper}) => {
227    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});227    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
228    const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);228    const token = await collection.mintToken(alice, 100n);
229    await token.repartition(alice, 50n);229    await token.repartition(alice, 50n);
230    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);230    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
231    expect(chainEvents).to.include.deep.members([{231    expect(chainEvents).to.include.deep.members([{