git.delta.rocks / unique-network / refs/commits / 3069e4dc18ce

--- a/tests/src/allowLists.test.ts
+++ b/tests/src/allowLists.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute itSub and/or modify
-// itSub under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that itSub will be useful,
+// Unique Network is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.

--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute itSub and/or modify
-// itSub under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that itSub will be useful,
+// Unique Network is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.

--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute itSub and/or modify
-// itSub under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that itSub will be useful,
+// Unique Network is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -17,6 +17,18 @@
 import {IKeyringPair} from '@polkadot/types/types';
 import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 
+async function setSponsorHelper(collection: any, signer: IKeyringPair, sponsorAddress: string) {
+  await collection.setSponsor(signer, sponsorAddress);
+  const raw = (await collection.getData())?.raw;
+  expect(raw.sponsorship.Unconfirmed).to.be.equal(sponsorAddress);
+}
+
+async function confirmSponsorHelper(collection: any, signer: IKeyringPair) {
+  await collection.confirmSponsorship(signer);
+  const raw = (await collection.getData())?.raw;
+  expect(raw.sponsorship.Confirmed).to.be.equal(signer.address);
+}
+
 describe('integration test: ext. confirmSponsorship():', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
@@ -32,21 +44,21 @@
 
   itSub('Confirm collection sponsorship', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    await collection.setSponsor(alice, bob.address);
-    await collection.confirmSponsorship(bob);
+    await setSponsorHelper(collection, alice, bob.address);
+    await confirmSponsorHelper(collection, bob);
   });
 
   itSub('Add sponsor to a collection after the same sponsor was already added and confirmed', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    await collection.setSponsor(alice, bob.address);
-    await collection.confirmSponsorship(bob);
-    await collection.setSponsor(alice, bob.address);
+    await setSponsorHelper(collection, alice, bob.address);
+    await confirmSponsorHelper(collection, bob);
+    await setSponsorHelper(collection, alice, bob.address);
   });
   itSub('Add new sponsor to a collection after another sponsor was already added and confirmed', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    await collection.setSponsor(alice, bob.address);
-    await collection.confirmSponsorship(bob);
-    await collection.setSponsor(alice, charlie.address);
+    await setSponsorHelper(collection, alice, bob.address);
+    await confirmSponsorHelper(collection, bob);
+    await setSponsorHelper(collection, alice, charlie.address);
   });
 
   itSub('NFT: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {

--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute itSub and/or modify
-// itSub under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that itSub will be useful,
+// Unique Network is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
@@ -16,7 +16,33 @@
 
 import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 import {IKeyringPair} from '@polkadot/types/types';
-import {IProperty} from './util/playgrounds/types';
+import {ICollectionCreationOptions, IProperty} from './util/playgrounds/types';
+import {DevUniqueHelper} from './util/playgrounds/unique.dev';
+
+async function mintCollectionHelper(helper: DevUniqueHelper, signer: IKeyringPair, options: ICollectionCreationOptions, type?: 'nft' | 'fungible' | 'refungible') {
+  let collection;
+  if (type === 'nft') {
+    collection = await helper.nft.mintCollection(signer, options);
+  } else if (type === 'fungible') {
+    collection = await helper.ft.mintCollection(signer, options, 0);
+  } else {
+    collection = await helper.rft.mintCollection(signer, options);
+  }
+  const data = await collection.getData();
+  expect(data?.normalizedOwner).to.be.equal(signer.address);
+  expect(data?.name).to.be.equal(options.name);
+  expect(data?.description).to.be.equal(options.description);
+  expect(data?.raw.tokenPrefix).to.be.equal(options.tokenPrefix);
+  if (options.properties) {
+    expect(data?.raw.properties).to.be.deep.equal(options.properties);
+  }
+
+  if (options.tokenPropertyPermissions) {
+    expect(data?.raw.tokenPropertyPermissions).to.be.deep.equal(options.tokenPropertyPermissions);
+  }
+
+  return collection;
+}
 
 describe('integration test: ext. createCollection():', () => {
   let alice: IKeyringPair;
@@ -29,41 +55,41 @@
   });
   itSub('Create new NFT collection', async ({helper}) => {
 
-    await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await mintCollectionHelper(helper, alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 'nft');
   });
   itSub('Create new NFT collection whith collection_name of maximum length (64 bytes)', async ({helper}) => {
 
-    await helper.nft.mintCollection(alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'});
+    await mintCollectionHelper(helper, alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'}, 'nft');
   });
   itSub('Create new NFT collection whith collection_description of maximum length (256 bytes)', async ({helper}) => {
 
-    await helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'});
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'}, 'nft');
   });
   itSub('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async ({helper}) => {
 
-    await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)});
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)}, 'nft');
   });
   itSub('Create new Fungible collection', async ({helper}) => {
 
-    await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'fungible');
   });
   itSub.ifWithPallets('Create new ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
 
-    await helper.rft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'refungible');
   });
 
   itSub('create new collection with properties', async ({helper}) => {
 
-    await helper.nft.mintCollection(alice, {
+    await mintCollectionHelper(helper, alice, {
       name: 'name', description: 'descr', tokenPrefix: 'COL',
       properties: [{key: 'key1', value: 'val1'}],
       tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
-    });
+    }, 'nft');
   });
 
   itSub('Create new collection with extra fields', async ({helper}) => {
 
-    const collection = await helper.ft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 8);
+    const collection = await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'fungible');
     await collection.setPermissions(alice, {access: 'AllowList'});
     await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
     const data = await collection.getData();
@@ -74,7 +100,7 @@
     expect(data?.name).to.be.equal('name');
     expect(data?.description).to.be.equal('descr');
     expect(raw.permissions.access).to.be.equal('AllowList');
-    expect(raw.mode).to.be.deep.equal({Fungible: '8'});
+    expect(raw.mode).to.be.deep.equal({Fungible: '0'});
     expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
   });
 

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
2// This file is part of Unique Network.2// This file is part of Unique Network.
33
4// Unique Network is free software: you can redistribute itSub and/or modify4// Unique Network is free software: you can redistribute it and/or modify
5// itSub under the terms of the GNU General Public License as published by5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.7// (at your option) any later version.
88
9// Unique Network is distributed in the hope that itSub will be useful,9// Unique Network is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.12// GNU General Public License for more details.
21  itApi,21  itApi,
22  normalizeAccountId,22  normalizeAccountId,
23  getCreateItemResult,23  getCreateItemResult,
24  CrossAccountId,
24} from './util/helpers';25} from './util/helpers';
2526
26import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';27import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
27import {IProperty} from './util/playgrounds/types';28import {IProperty} from './util/playgrounds/types';
28import {executeTransaction} from './substrate/substrate-api';29import {executeTransaction} from './substrate/substrate-api';
30import {DevUniqueHelper} from './util/playgrounds/unique.dev';
31
32async function mintTokenHelper(helper: DevUniqueHelper, collection: any, signer: IKeyringPair, owner: CrossAccountId, type: 'nft' | 'fungible' | 'refungible'='nft', properties?: IProperty[]) {
33  let token;
34  const itemCountBefore = await helper.collection.getLastTokenId(collection.collectionId);
35  const itemBalanceBefore = (await helper.api!.rpc.unique.balance(collection.collectionId, owner, 0)).toBigInt();
36  if (type === 'nft') {
37    token = await collection.mintToken(signer, owner, properties);
38  } else if (type === 'fungible') {
39    await collection.mint(signer, 10n, owner);
40  } else {
41    token = await collection.mintToken(signer, 100n, owner, properties);
42  }
43
44  const itemCountAfter = await helper.collection.getLastTokenId(collection.collectionId);
45  const itemBalanceAfter = (await helper.api!.rpc.unique.balance(collection.collectionId, owner, 0)).toBigInt();
46
47  if (type === 'fungible') {
48    expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);
49  } else {
50    expect(itemCountAfter).to.be.equal(itemCountBefore + 1);
51  }
52
53  return token;
54}
2955
3056
31describe('integration test: ext. ():', () => {57describe('integration test: ext. ():', () => {
4167
42  itSub('Create new item in NFT collection', async ({helper}) => {68  itSub('Create new item in NFT collection', async ({helper}) => {
43    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});69    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
44    await collection.mintToken(alice, {Substrate: alice.address});70    await mintTokenHelper(helper, collection, alice, {Substrate: alice.address});
45  });71  });
46  itSub('Create new item in Fungible collection', async ({helper}) => {72  itSub('Create new item in Fungible collection', async ({helper}) => {
47    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);73    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
48    await collection.mint(alice, 10n, {Substrate: alice.address});74    await mintTokenHelper(helper, collection, alice, {Substrate: alice.address}, 'fungible');
49  });75  });
50  itApi.skip('Check events on create new item in Fungible collection', async ({api}) => {76  itSub('Check events on create new item in Fungible collection', async ({helper}) => {
51    const createMode = 'Fungible';
52
53    const newCollectionID = (await createCollection(api, alice, {mode: {type: createMode, decimalPoints: 0}})).collectionId;77    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'}, 0);
78    const api = helper.api!;
79
5480
55    const to = normalizeAccountId(alice);81    const to = normalizeAccountId(alice);
56    {82    {
57      const createData = {fungible: {value: 100}};83      const createData = {fungible: {value: 100}};
58      const tx = api.tx.unique.createItem(newCollectionID, to, createData as any);84      const tx = api.tx.unique.createItem(collectionId, to, createData as any);
59      const events = await executeTransaction(api, alice, tx);85      const events = await executeTransaction(api, alice, tx);
60      const result = getCreateItemResult(events);86      const result = getCreateItemResult(events);
61      expect(result.amount).to.be.equal(100);87      expect(result.amount).to.be.equal(100);
62      expect(result.collectionId).to.be.equal(newCollectionID);88      expect(result.collectionId).to.be.equal(collectionId);
63      expect(result.recipient).to.be.deep.equal(to);89      expect(result.recipient).to.be.deep.equal(to);
64    }90    }
65    {91    {
66      const createData = {fungible: {value: 50}};92      const createData = {fungible: {value: 50}};
67      const tx = api.tx.unique.createItem(newCollectionID, to, createData as any);93      const tx = api.tx.unique.createItem(collectionId, to, createData as any);
68      const events = await executeTransaction(api, alice, tx);94      const events = await executeTransaction(api, alice, tx);
69      const result = getCreateItemResult(events);95      const result = getCreateItemResult(events);
70      expect(result.amount).to.be.equal(50);96      expect(result.amount).to.be.equal(50);
71      expect(result.collectionId).to.be.equal(newCollectionID);97      expect(result.collectionId).to.be.equal(collectionId);
72      expect(result.recipient).to.be.deep.equal(to);98      expect(result.recipient).to.be.deep.equal(to);
73    }99    }
74  });100  });
75  itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) =>  {101  itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) =>  {
76    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});102    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
77    await collection.mintToken(alice, 100n, {Substrate: alice.address});103    await mintTokenHelper(helper, collection, alice, {Substrate: alice.address}, 'refungible');
78  });104  });
79  itSub('Create new item in NFT collection with collection admin permissions', async ({helper}) => {105  itSub('Create new item in NFT collection with collection admin permissions', async ({helper}) => {
80    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});106    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
81    await collection.addAdmin(alice, {Substrate: bob.address});107    await collection.addAdmin(alice, {Substrate: bob.address});
82    await collection.mintToken(bob, {Substrate: alice.address});108    await mintTokenHelper(helper, collection, bob, {Substrate: alice.address});
83  });109  });
84  itSub('Create new item in Fungible collection with collection admin permissions', async ({helper}) => {110  itSub('Create new item in Fungible collection with collection admin permissions', async ({helper}) => {
85    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);111    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
86    await collection.addAdmin(alice, {Substrate: bob.address});112    await collection.addAdmin(alice, {Substrate: bob.address});
87    await collection.mint(bob, 10n, {Substrate: alice.address});113    await mintTokenHelper(helper, collection, bob, {Substrate: alice.address}, 'fungible');
88  });114  });
89  itSub.ifWithPallets('Create new item in ReFungible collection with collection admin permissions', [Pallets.ReFungible], async ({helper}) =>  {115  itSub.ifWithPallets('Create new item in ReFungible collection with collection admin permissions', [Pallets.ReFungible], async ({helper}) =>  {
90    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});116    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
91    await collection.addAdmin(alice, {Substrate: bob.address});117    await collection.addAdmin(alice, {Substrate: bob.address});
92    await collection.mintToken(bob, 100n, {Substrate: alice.address});118    await mintTokenHelper(helper, collection, bob, {Substrate: alice.address}, 'refungible');
93  });119  });
94120
95  itSub('Set property Admin', async ({helper}) => {121  itSub('Set property Admin', async ({helper}) => {
96    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',122    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
97      properties: [{key: 'k', value: 'v'}],123      properties: [{key: 'k', value: 'v'}],
98      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],124      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
99    });125    });
100    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);126    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
101  });127  });
102128
103  itSub('Set property AdminConst', async ({helper}) => {129  itSub('Set property AdminConst', async ({helper}) => {
104    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',130    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
105      properties: [{key: 'k', value: 'v'}],131      properties: [{key: 'k', value: 'v'}],
106      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],132      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
107    });133    });
108    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);134    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
109  });135  });
110136
111  itSub('Set property itemOwnerOrAdmin', async ({helper}) => {137  itSub('Set property itemOwnerOrAdmin', async ({helper}) => {
112    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',138    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
113      properties: [{key: 'k', value: 'v'}],139      properties: [{key: 'k', value: 'v'}],
114      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],140      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
115    });141    });
116    await collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);142    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
117  });143  });
118144
119  itSub('Check total pieces of Fungible token', async ({helper}) => {145  itSub('Check total pieces of Fungible token', async ({helper}) => {
120    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);146    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
121    const amount = 10n;147    const amount = 10n;
122    await collection.mint(alice, amount, {Substrate: bob.address});148    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'fungible');
123    {149    {
124      const totalPieces = await collection.getTotalPieces();150      const totalPieces = await collection.getTotalPieces();
125      expect(totalPieces).to.be.equal(amount);151      expect(totalPieces).to.be.equal(amount);
134  itSub('Check total pieces of NFT token', async ({helper}) => {160  itSub('Check total pieces of NFT token', async ({helper}) => {
135    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});161    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
136    const amount = 1n;162    const amount = 1n;
137    const token = await collection.mintToken(alice, {Substrate: bob.address});163    const token = await mintTokenHelper(helper, collection, alice, {Substrate: bob.address});
138    {164    {
139      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);165      const totalPieces = await helper.api?.rpc.unique.totalPieces(collection.collectionId, token.tokenId);
140      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);166      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
149  itSub.ifWithPallets('Check total pieces of ReFungible token', [Pallets.ReFungible], async ({helper}) => {175  itSub.ifWithPallets('Check total pieces of ReFungible token', [Pallets.ReFungible], async ({helper}) => {
150    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});176    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
151    const amount = 100n;177    const amount = 100n;
152    const token = await collection.mintToken(alice, amount, {Substrate: bob.address});178    const token = await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'refungible');
153    {179    {
154      const totalPieces = await token.getTotalPieces();180      const totalPieces = await token.getTotalPieces();
155      expect(totalPieces).to.be.equal(amount);181      expect(totalPieces).to.be.equal(amount);

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -1,12 +1,12 @@
 // Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
 // This file is part of Unique Network.
 
-// Unique Network is free software: you can redistribute itSub and/or modify
-// itSub under the terms of the GNU General Public License as published by
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 
-// Unique Network is distributed in the hope that itSub will be useful,
+// Unique Network is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.