git.delta.rocks / unique-network / refs/commits / 0231a432ed7d

--- a/tests/package.json
+++ b/tests/package.json
@@ -44,6 +44,7 @@
     "testAddCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/addCollectionAdmin.test.ts",
     "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",
     "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",
+    "testChangeCollectionOwner": "mocha --timeout 9999999 -r ts-node/register ./**/change-collection-owner.test.ts",
     "testSetCollectionSponsor": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionSponsor.test.ts",
     "testConfirmSponsorship": "mocha --timeout 9999999 -r ts-node/register ./**/confirmSponsorship.test.ts",
     "testRemoveCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionAdmin.test.ts",

--- a/tests/src/adminTransferAndBurn.test.ts
+++ b/tests/src/adminTransferAndBurn.test.ts
@@ -15,14 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 
 describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => {
   let alice: IKeyringPair;
@@ -31,44 +24,40 @@
 
   before(async () => {
     await usingPlaygrounds(async (helper, privateKey) => {
-      donor = privateKey('//Alice');
+      const donor = privateKey('//Alice');
       [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });
 
-  it('admin transfers other user\'s token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
-      await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
-      const limits = await helper.collection.getEffectiveLimits(collectionId);
-      expect(limits.ownerCanTransfer).to.be.true;
+  itSub('admin transfers other user\'s token', async ({helper}) => {
+    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+    await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
+    const limits = await helper.collection.getEffectiveLimits(collectionId);
+    expect(limits.ownerCanTransfer).to.be.true;
 
-      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-      const transferResult = async () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
-      await expect(transferResult()).to.be.rejected;
+    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
+    const transferResult = async () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
+    await expect(transferResult()).to.be.rejected;
 
-      await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
-      const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
-      expect(newTokenOwner.Substrate).to.be.equal(charlie.address);
-    });
+    await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
+    const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
+    expect(newTokenOwner.Substrate).to.be.equal(charlie.address);
   });
 
-  it('admin burns other user\'s token', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+  itSub('admin burns other user\'s token', async ({helper}) => {
+    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
 
-      await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
-      const limits = await helper.collection.getEffectiveLimits(collectionId);
-      expect(limits.ownerCanTransfer).to.be.true;
+    await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
+    const limits = await helper.collection.getEffectiveLimits(collectionId);
+    expect(limits.ownerCanTransfer).to.be.true;
 
-      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-      const burnTxFailed = async () => helper.nft.burnToken(alice, collectionId, tokenId);
+    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
+    const burnTxFailed = async () => helper.nft.burnToken(alice, collectionId, tokenId);
 
-      await expect(burnTxFailed()).to.be.rejected;
+    await expect(burnTxFailed()).to.be.rejected;
 
-      await helper.nft.burnToken(bob, collectionId, tokenId);
-      const token = await helper.nft.getToken(collectionId, tokenId);
-      expect(token).to.be.null;
-    });
+    await helper.nft.burnToken(bob, collectionId, tokenId);
+    const token = await helper.nft.getToken(collectionId, tokenId);
+    expect(token).to.be.null;
   });
 });

--- a/tests/src/allowLists.test.ts
+++ b/tests/src/allowLists.test.ts
@@ -18,7 +18,7 @@
 import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 import {ICollectionPermissions} from './util/playgrounds/types';
 
-describe('Integration Test ext. Add to Allow List', () => {  
+describe('Integration Test ext. Allow list tests', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
   let charlie: IKeyringPair;
@@ -38,7 +38,7 @@
       const allowList = await helper.nft.getAllowList(collectionId);
       expect(allowList).to.deep.contain({Substrate: bob.address});
     });
-  
+
     itSub('Admin can add address to allow list', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       await helper.nft.addAdmin(alice, collectionId, {Substrate: bob.address});
@@ -64,7 +64,7 @@
       await expect(helper.nft.addToAllowList(bob, collectionId, {Substrate: charlie.address}))
         .to.be.rejectedWith(/common\.CollectionNotFound/);
     });
-  
+
     itSub('Nobody can add address to allow list of destroyed collection', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       await helper.collection.burn(alice, collectionId);
@@ -80,7 +80,7 @@
   });
 });
 
-describe('Integration Test ext. Remove from Allow List', () => {  
+describe('Integration Test ext. Remove from Allow List', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
   let charlie: IKeyringPair;
@@ -120,9 +120,9 @@
       await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: bob.address});
       const allowListBefore = await helper.nft.getAllowList(collectionId);
       expect(allowListBefore).to.not.deep.contain({Substrate: bob.address});
-  
+
       await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: bob.address});
-  
+
       const allowListAfter = await helper.nft.getAllowList(collectionId);
       expect(allowListAfter).to.not.deep.contain({Substrate: bob.address});
     });
@@ -138,25 +138,25 @@
       const allowList = await helper.nft.getAllowList(collectionId);
       expect(allowList).to.deep.contain({Substrate: charlie.address});
     });
-  
+
     itSub('Nobody can remove address from allow list of non-existing collection', async ({helper}) => {
       const collectionId = (1<<32) - 1;
       await expect(helper.collection.removeFromAllowList(bob, collectionId, {Substrate: charlie.address}))
         .to.be.rejectedWith(/common\.CollectionNotFound/);
     });
-  
+
     itSub('Nobody can remove address from allow list of deleted collection', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: bob.address});
       await helper.collection.burn(alice, collectionId);
-  
+
       await expect(helper.collection.removeFromAllowList(alice, collectionId, {Substrate: bob.address}))
         .to.be.rejectedWith(/common\.CollectionNotFound/);
     });
   });
 });
 
-describe('Integration Test ext. Transfer if included in Allow List', () => {  
+describe('Integration Test ext. Transfer if included in Allow List', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
   let charlie: IKeyringPair;
@@ -179,7 +179,7 @@
       const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
       expect(owner.Substrate).to.be.equal(charlie.address);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, tokens can be transferred to a allowlisted address with transferFrom.', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -187,24 +187,24 @@
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
       await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
-  
+
       await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: alice.address}, {Substrate: charlie.address});
       const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
       expect(owner.Substrate).to.be.equal(charlie.address);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
       await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
-  
+
       await helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
       const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
       expect(owner.Substrate).to.be.equal(charlie.address);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transferFrom', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -212,7 +212,7 @@
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
       await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
-  
+
       await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: alice.address}, {Substrate: charlie.address});
       const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
       expect(owner.Substrate).to.be.equal(charlie.address);
@@ -225,11 +225,11 @@
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
       await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
-  
+
       await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
         .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, tokens can\'t be transferred from a non-allowlisted address with transfer or transferFrom. Test2', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -238,35 +238,35 @@
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
       await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
       await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: alice.address});
-  
+
       await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
         .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, tokens can\'t be transferred to a non-allowlisted address with transfer or transferFrom. Test1', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
       await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
-  
+
       await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
         .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, tokens can\'t be transferred to a non-allowlisted address with transfer or transferFrom. Test2', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
       await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
-  
+
       await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
       await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: alice.address});
-  
+
       await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
         .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, tokens can\'t be destroyed by a non-allowlisted address (even if it owned them before enabling AllowList mode)', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -274,7 +274,7 @@
       await expect(helper.nft.burnToken(bob, collectionId, tokenId))
         .to.be.rejectedWith(/common\.NoPermission/);
     });
-  
+
     itSub('If Public Access mode is set to AllowList, token transfers can\'t be Approved by a non-allowlisted address (see Approve method)', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -285,7 +285,7 @@
   });
 });
 
-describe('Integration Test ext. Mint if included in Allow List', () => {  
+describe('Integration Test ext. Mint if included in Allow List', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
 
@@ -309,7 +309,7 @@
     const appropriateRejectionMessage = permissions.mintMode! ? /common\.AddressNotInAllowlist/ : /common\.PublicMintingNotAllowed/;
 
     const allowlistedMintingTest = () => itSub(
-      `With the condtions above, tokens can${allowlistedMintingShouldFail ? '\'t' : ''} be created by allow-listed addresses`, 
+      `With the condtions above, tokens can${allowlistedMintingShouldFail ? '\'t' : ''} be created by allow-listed addresses`,
       async ({helper}) => {
         const collection = await helper.nft.mintCollection(alice, {});
         await collection.setPermissions(alice, permissions);
@@ -330,7 +330,7 @@
           await collection.setPermissions(alice, permissions);
           await expect(collection.mintToken(alice, {Substrate: alice.address})).to.not.be.rejected;
         });
-      
+
         itSub('With the condtions above, tokens can be created by admin', async ({helper}) => {
           const collection = await helper.nft.mintCollection(alice, {});
           await collection.setPermissions(alice, permissions);

--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -14,231 +14,156 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
-import {createCollectionExpectSuccess,
-  addCollectionAdminExpectSuccess,
-  setCollectionSponsorExpectSuccess,
-  confirmSponsorshipExpectSuccess,
-  removeCollectionSponsorExpectSuccess,
-  enableAllowListExpectSuccess,
-  setMintPermissionExpectSuccess,
-  destroyCollectionExpectSuccess,
-  setCollectionSponsorExpectFailure,
-  confirmSponsorshipExpectFailure,
-  removeCollectionSponsorExpectFailure,
-  enableAllowListExpectFail,
-  setMintPermissionExpectFailure,
-  destroyCollectionExpectFailure,
-  setPublicAccessModeExpectSuccess,
-  queryCollectionExpectSuccess,
-} from './util/helpers';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 
 describe('Integration Test changeCollectionOwner(collection_id, new_owner):', () => {
-  it('Changing owner changes owner address', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
-      const collection =await queryCollectionExpectSuccess(api, collectionId);
-      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+    });
+  });
 
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await submitTransactionAsync(alice, changeOwnerTx);
+  itSub('Changing owner changes owner address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const beforeChanging = await helper.collection.getData(collection.collectionId);
+    expect(beforeChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
 
-      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
-    });
+    await collection.changeOwner(alice, bob.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
   });
 });
 
 describe('Integration Test changeCollectionOwner(collection_id, new_owner) special checks for exOwner:', () => {
-  it('Changing the owner of the collection is not allowed for the former owner', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
 
-      const collection = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
-
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await submitTransactionAsync(alice, changeOwnerTx);
-
-      const badChangeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, alice.address);
-      await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
-
-      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
-
-  it('New collectionOwner has access to sponsorship management operations in the collection', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
 
-      const collection = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
-
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await submitTransactionAsync(alice, changeOwnerTx);
-
-      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+  itSub('Changing the owner of the collection is not allowed for the former owner', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
 
-      // After changing the owner of the collection, all privileged methods are available to the new owner
-      // The new owner of the collection has access to sponsorship management operations in the collection
-      await setCollectionSponsorExpectSuccess(collectionId, charlie.address, '//Bob');
-      await confirmSponsorshipExpectSuccess(collectionId, '//Charlie');
-      await removeCollectionSponsorExpectSuccess(collectionId, '//Bob');
+    await collection.changeOwner(alice, bob.address);
 
-      // The new owner of the collection has access to operations for managing the collection parameters
-      const collectionLimits = {
-        accountTokenOwnershipLimit: 1,
-        sponsoredMintSize: 1,
-        tokenLimit: 1,
-        sponsorTransferTimeout: 1,
-        ownerCanTransfer: true,
-        ownerCanDestroy: true,
-      };
-      const tx1 = api.tx.unique.setCollectionLimits(
-        collectionId,
-        collectionLimits,
-      );
-      await submitTransactionAsync(bob, tx1);
+    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      await setPublicAccessModeExpectSuccess(bob, collectionId, 'AllowList');
-      await enableAllowListExpectSuccess(bob, collectionId);
-      await setMintPermissionExpectSuccess(bob, collectionId, true);
-      await destroyCollectionExpectSuccess(collectionId, '//Bob');
-    });
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
   });
 
-  it('New collectionOwner has access to changeCollectionOwner', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
+  itSub('New collectionOwner has access to sponsorship management operations in the collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
 
-      const collection = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
 
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await submitTransactionAsync(alice, changeOwnerTx);
+    await collection.setSponsor(bob, charlie.address);
+    await collection.confirmSponsorship(charlie);
+    await collection.removeSponsor(bob);
+    const limits = {
+      accountTokenOwnershipLimit: 1,
+      tokenLimit: 1,
+      sponsorTransferTimeout: 1,
+      ownerCanDestroy: true,
+      ownerCanTransfer: true,
+    };
 
-      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+    await collection.setLimits(bob, limits);
+    const gotLimits = await collection.getEffectiveLimits();
+    expect(gotLimits).to.be.deep.contains(limits);
 
-      const changeOwnerTx2 = api.tx.unique.changeCollectionOwner(collectionId, charlie.address);
-      await submitTransactionAsync(bob, changeOwnerTx2);
+    await collection.setPermissions(bob, {access: 'AllowList', mintMode: true});
 
-      // ownership lost
-      const collectionAfterOwnerChange2 = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange2.owner.toString()).to.be.deep.eq(charlie.address);
-    });
+    await collection.burn(bob);
+    const collectionData = await helper.collection.getData(collection.collectionId);
+    expect(collectionData).to.be.null;
   });
+
+  itSub('New collectionOwner has access to changeCollectionOwner', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
+    await collection.changeOwner(bob, charlie.address);
+    const collectionData = await collection.getData();
+    expect(collectionData?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(charlie.address));
+  });
 });
 
 describe('Negative Integration Test changeCollectionOwner(collection_id, new_owner):', () => {
-  it('Not owner can\'t change owner.', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
-
-      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
 
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await createCollectionExpectSuccess();
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
-  it('Collection admin can\'t change owner.', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
-
-      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);
-
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await createCollectionExpectSuccess();
-    });
+  itSub('Not owner can\'t change owner.', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Can\'t change owner of a non-existing collection.', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = (1<<32) - 1;
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await expect(submitTransactionExpectFailAsync(alice, changeOwnerTx)).to.be.rejected;
+  itSub('Collection admin can\'t change owner.', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
+  });
 
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await createCollectionExpectSuccess();
-    });
+  itSub('Can\'t change owner of a non-existing collection.', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
+    const changeOwnerTx = async () => helper.collection.changeOwner(bob, collectionId, bob.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Former collectionOwner not allowed to sponsorship management operations in the collection', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
+  itSub('Former collectionOwner not allowed to sponsorship management operations in the collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.changeOwner(alice, bob.address);
 
-      const collection = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
+    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
-      await submitTransactionAsync(alice, changeOwnerTx);
+    const afterChanging = await helper.collection.getData(collection.collectionId);
+    expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
 
-      const badChangeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, alice.address);
-      await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
+    const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+    const removeSponsorTx = async () => collection.removeSponsor(alice);
+    await expect(setSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
+    await expect(removeSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
-      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+    const limits = {
+      accountTokenOwnershipLimit: 1,
+      tokenLimit: 1,
+      sponsorTransferTimeout: 1,
+      ownerCanDestroy: true,
+      ownerCanTransfer: true,
+    };
 
-      await setCollectionSponsorExpectFailure(collectionId, charlie.address, '//Alice');
-      await confirmSponsorshipExpectFailure(collectionId, '//Alice');
-      await removeCollectionSponsorExpectFailure(collectionId, '//Alice');
+    const setLimitsTx = async () => collection.setLimits(alice, limits);
+    await expect(setLimitsTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const collectionLimits = {
-        accountTokenOwnershipLimit: 1,
-        sponsoredMintSize: 1,
-        tokenLimit: 1,
-        sponsorTransferTimeout: 1,
-        ownerCanTransfer: true,
-        ownerCanDestroy: true,
-      };
-      const tx1 = api.tx.unique.setCollectionLimits(
-        collectionId,
-        collectionLimits,
-      );
-      await expect(submitTransactionExpectFailAsync(alice, tx1)).to.be.rejected;
+    const setPermissionTx = async () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await expect(setPermissionTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-      await enableAllowListExpectFail(alice, collectionId);
-      await setMintPermissionExpectFailure(alice, collectionId, true);
-      await destroyCollectionExpectFailure(collectionId, '//Alice');
-    });
+    const burnTx = async () => collection.burn(alice);
+    await expect(burnTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 });

--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -14,404 +14,230 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
-import {
-  createCollectionExpectSuccess,
-  setCollectionSponsorExpectSuccess,
-  destroyCollectionExpectSuccess,
-  confirmSponsorshipExpectSuccess,
-  confirmSponsorshipExpectFailure,
-  createItemExpectSuccess,
-  findUnusedAddress,
-  getGenericResult,
-  enableAllowListExpectSuccess,
-  enablePublicMintingExpectSuccess,
-  addToAllowListExpectSuccess,
-  normalizeAccountId,
-  addCollectionAdminExpectSuccess,
-  getCreatedCollectionCount,
-  UNIQUE,
-  requirePallets,
-  Pallets,
-} from './util/helpers';
 import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
 
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+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);
+}
 
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let charlie: IKeyringPair;
+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;
+  let charlie: IKeyringPair;
+  let zeroBalance: IKeyringPair;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      charlie = privateKeyWrapper('//Charlie');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie, zeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n], donor);
     });
   });
 
-  it('Confirm collection sponsorship', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
+  itSub('Confirm collection sponsorship', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await setSponsorHelper(collection, alice, bob.address);
+    await confirmSponsorHelper(collection, bob);
   });
-  it('Add sponsor to a collection after the same sponsor was already added and confirmed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+
+  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 setSponsorHelper(collection, alice, bob.address);
+    await confirmSponsorHelper(collection, bob);
+    await setSponsorHelper(collection, alice, bob.address);
   });
-  it('Add new sponsor to a collection after another sponsor was already added and confirmed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-    await setCollectionSponsorExpectSuccess(collectionId, charlie.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 setSponsorHelper(collection, alice, bob.address);
+    await confirmSponsorHelper(collection, bob);
+    await setSponsorHelper(collection, alice, charlie.address);
   });
 
-  it('NFT: Transfer fees are paid by the sponsor after confirmation', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Mint token for unused address
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', zeroBalance.address);
-
-      // Transfer this tokens from unused address to Alice
-      const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 0);
-      const events = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result = getGenericResult(events);
-      expect(result.success).to.be.true;
-
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
-    });
-
+  itSub('NFT: Transfer fees are paid by the sponsor after confirmation', 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);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address});
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Mint token for unused address
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'Fungible', zeroBalance.address);
-
-      // Transfer this tokens from unused address to Alice
-      const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 1);
-      const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result1 = getGenericResult(events1);
-      expect(result1.success).to.be.true;
-
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
-    });
+  itSub('Fungible: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+    await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
-
-  it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
 
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Mint token for unused address
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'ReFungible', zeroBalance.address);
-
-      // Transfer this tokens from unused address to Alice
-      const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 1);
-      const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result1 = getGenericResult(events1);
-
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      expect(result1.success).to.be.true;
-      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
-    });
+  itSub.ifWithPallets('ReFungible: Transfer fees are paid by the sponsor after confirmation', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
-
-  it('CreateItem fees are paid by the sponsor after confirmation', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    // Enable collection allow list
-    await enableAllowListExpectSuccess(alice, collectionId);
 
-    // Enable public minting
-    await enablePublicMintingExpectSuccess(alice, collectionId);
-
-    // Create Item
-    await usingApi(async (api, privateKeyWrapper) => {
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Add zeroBalance address to allow list
-      await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);
-
-      // Mint token using unused address as signer
-      await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
+  itSub('CreateItem fees are paid by the sponsor after confirmation', 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.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
 
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
-    });
+    expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
   });
 
-  it('NFT: Sponsoring of transfers is rate limited', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
+  itSub('NFT: Sponsoring of transfers is rate limited', 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 usingApi(async (api, privateKeyWrapper) => {
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Mint token for alice
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);
+    const token = await collection.mintToken(alice, {Substrate: alice.address});
+    await token.transfer(alice, {Substrate: zeroBalance.address});
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-      // Transfer this token from Alice to unused address and back
-      // Alice to Zero gets sponsored
-      const aliceToZero = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 0);
-      const events1 = await submitTransactionAsync(alice, aliceToZero);
-      const result1 = getGenericResult(events1);
+    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      // Second transfer should fail
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-      const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(alice.address), collectionId, itemId, 0);
-      const badTransaction = async function () {
-        await submitTransactionExpectFailAsync(zeroBalance, zeroToAlice);
-      };
-      await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      // Try again after Zero gets some balance - now it should succeed
-      const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
-      await submitTransactionAsync(alice, balancetx);
-      const events2 = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result2 = getGenericResult(events2);
-
-      expect(result1.success).to.be.true;
-      expect(result2.success).to.be.true;
-      expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('Fungible: Sponsoring is rate limited', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Mint token for unused address
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'Fungible', zeroBalance.address);
-
-      // Transfer this tokens in parts from unused address to Alice
-      const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 1);
-      const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result1 = getGenericResult(events1);
-      expect(result1.success).to.be.true;
+  itSub('Fungible: Sponsoring is rate limited', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-      await expect(submitTransactionExpectFailAsync(zeroBalance, zeroToAlice)).to.be.rejected;
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
+    await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+    await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-      // Try again after Zero gets some balance - now it should succeed
-      const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
-      await submitTransactionAsync(alice, balancetx);
-      const events2 = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result2 = getGenericResult(events2);
-      expect(result2.success).to.be.true;
+    const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
+    await expect(transferTx()).to.be.rejected;
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
-
-  it('ReFungible: Sponsoring is rate limited', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Mint token for alice
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'ReFungible', zeroBalance.address);
+  itSub.ifWithPallets('ReFungible: Sponsoring is rate limited', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
 
-      const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(alice.address), collectionId, itemId, 1);
-
-      // Zero to alice gets sponsored
-      const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result1 = getGenericResult(events1);
-      expect(result1.success).to.be.true;
+    const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+    await token.transfer(zeroBalance, {Substrate: alice.address});
 
-      // Second transfer should fail
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-      await expect(submitTransactionExpectFailAsync(zeroBalance, zeroToAlice)).to.be.rejectedWith('Inability to pay some fees');
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-      expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      // Try again after Zero gets some balance - now it should succeed
-      const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
-      await submitTransactionAsync(alice, balancetx);
-      const events2 = await submitTransactionAsync(zeroBalance, zeroToAlice);
-      const result2 = getGenericResult(events2);
-      expect(result2.success).to.be.true;
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
 
-  it('NFT: Sponsoring of createItem is rate limited', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    // Enable collection allow list
-    await enableAllowListExpectSuccess(alice, collectionId);
-
-    // Enable public minting
-    await enablePublicMintingExpectSuccess(alice, collectionId);
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Add zeroBalance address to allow list
-      await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);
+  itSub('NFT: Sponsoring of createItem is rate limited', 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.setPermissions(alice, {mintMode: true, access: 'AllowList'});
+    await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
 
-      // Mint token using unused address as signer - gets sponsored
-      await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
+    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
 
-      // Second mint should fail
-      const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      const badTransaction = async function () {
-        await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
-      };
-      await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');
-      const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      // Try again after Zero gets some balance - now it should succeed
-      const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
-      await submitTransactionAsync(alice, balancetx);
-      await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
-
-      expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
-    });
+    expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
   });
-
 });
 
 describe('(!negative test!) integration test: ext. confirmSponsorship():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+  let ownerZeroBalance: IKeyringPair;
+  let senderZeroBalance: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      charlie = privateKeyWrapper('//Charlie');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie, ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n, 0n], donor);
     });
   });
 
-  it('(!negative test!) Confirm sponsorship for a collection that never existed', async () => {
-    // Find the collection that never existed
-    let collectionId = 0;
-    await usingApi(async (api) => {
-      collectionId = await getCreatedCollectionCount(api) + 1;
-    });
-
-    await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+  itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {
+    const collectionId = 1_000_000;
+    const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
-
-  it('(!negative test!) Confirm sponsorship using a non-sponsor address', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-
-    await usingApi(async (api) => {
-      const transfer = api.tx.balances.transfer(charlie.address, 1e15);
-      await submitTransactionAsync(alice, transfer);
-    });
 
-    await confirmSponsorshipExpectFailure(collectionId, '//Charlie');
+  itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship using owner address', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectFailure(collectionId, '//Alice');
+  itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship by collection admin', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await addCollectionAdminExpectSuccess(alice, collectionId, charlie.address);
-    await confirmSponsorshipExpectFailure(collectionId, '//Charlie');
+  itSub('(!negative test!) Confirm sponsorship by collection admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.addAdmin(alice, {Substrate: charlie.address});
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+  itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('(!negative test!) Confirm sponsorship in a collection that was destroyed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await destroyCollectionExpectSuccess(collectionId);
-    await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+  itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.burn(alice);
+    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      // Find unused address
-      const ownerZeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Find another unused address
-      const senderZeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
-      // Mint token for an unused address
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', ownerZeroBalance.address);
-
-      const sponsorBalanceBeforeTx = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      // Try to transfer this token from an unsponsored unused adress to Alice
-      const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(alice.address), collectionId, itemId, 0);
-      await expect(submitTransactionExpectFailAsync(senderZeroBalance, zeroToAlice)).to.be.rejected;
-
-      const sponsorBalanceAfterTx = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
-      expect(sponsorBalanceAfterTx).to.equal(sponsorBalanceBeforeTx);
-    });
+  itSub('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', 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);
+    const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
+    const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
+    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+    const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
+    expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
   });
 });

--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -14,130 +14,143 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import {expect} from 'chai';
-import usingApi, {executeTransaction, submitTransactionAsync} from './substrate/substrate-api';
-import {createCollectionWithPropsExpectFailure, createCollectionExpectFailure, createCollectionExpectSuccess, getCreateCollectionResult, getDetailedCollectionInfo, createCollectionWithPropsExpectSuccess, requirePallets, Pallets} from './util/helpers';
+import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
+import {ICollectionCreationOptions, IProperty} from './util/playgrounds/types';
+import {UniqueHelper} from './util/playgrounds/unique';
 
+async function mintCollectionHelper(helper: UniqueHelper, 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(helper.address.normalizeSubstrate(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():', () => {
-  it('Create new NFT collection', async () => {
-    await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
+  let alice: IKeyringPair;
+
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([100n], donor);
+    });
   });
-  it('Create new NFT collection whith collection_name of maximum length (64 bytes)', async () => {
-    await createCollectionExpectSuccess({name: 'A'.repeat(64)});
+  itSub('Create new NFT collection', async ({helper}) => {
+    await mintCollectionHelper(helper, alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 'nft');
   });
-  it('Create new NFT collection whith collection_description of maximum length (256 bytes)', async () => {
-    await createCollectionExpectSuccess({description: 'A'.repeat(256)});
+  itSub('Create new NFT collection whith collection_name of maximum length (64 bytes)', async ({helper}) => {
+    await mintCollectionHelper(helper, alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'}, 'nft');
   });
-  it('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async () => {
-    await createCollectionExpectSuccess({tokenPrefix: 'A'.repeat(16)});
+  itSub('Create new NFT collection whith collection_description of maximum length (256 bytes)', async ({helper}) => {
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'}, 'nft');
   });
-  it('Create new Fungible collection', async () => {
-    await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+  itSub('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async ({helper}) => {
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)}, 'nft');
   });
-  it('Create new ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
+  itSub('Create new Fungible collection', async ({helper}) => {
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'fungible');
   });
 
-  it('create new collection with properties #1', async () => {
-    await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'},
-      properties: [{key: 'key1', value: 'val1'}],
-      propPerm:   [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}]});
+  itSub.ifWithPallets('Create new ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'refungible');
   });
 
-  it('create new collection with properties #2', async () => {
-    await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'},
+  itSub('create new collection with properties', async ({helper}) => {
+    await mintCollectionHelper(helper, alice, {
+      name: 'name', description: 'descr', tokenPrefix: 'COL',
       properties: [{key: 'key1', value: 'val1'}],
-      propPerm:   [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}]});
+      tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
+    }, 'nft');
   });
 
-  it('create new collection with properties #3', async () => {
-    await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'},
-      properties: [{key: 'key1', value: 'val1'}],
-      propPerm:   [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}]});
-  });
+  itSub('Create new collection with extra fields', async ({helper}) => {
+    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();
+    const limits = await collection.getEffectiveLimits();
+    const raw = data?.raw;
 
-  it('Create new collection with extra fields', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const tx = api.tx.unique.createCollectionEx({
-        mode: {Fungible: 8},
-        permissions: {
-          access: 'AllowList',
-        },
-        name: [1],
-        description: [2],
-        tokenPrefix: '0x000000',
-        pendingSponsor: bob.address,
-        limits: {
-          accountTokenOwnershipLimit: 3,
-        },
-      });
-      const events = await submitTransactionAsync(alice, tx);
-      const result = getCreateCollectionResult(events);
+    expect(data?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
+    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: '0'});
+    expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
+  });
 
-      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.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.sponsorship.asUnconfirmed.toString()).to.equal(bob.address);
-      expect(collection.limits.accountTokenOwnershipLimit.unwrap().toNumber()).to.equal(3);
-    });
+  itSub('New collection is not external', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+    const data = await collection.getData();
+    expect(data?.raw.readOnly).to.be.false;
   });
+});
 
-  it('New collection is not external', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const tx = api.tx.unique.createCollectionEx({ });
-      const events = await submitTransactionAsync(alice, tx);
-      const result = getCreateCollectionResult(events);
+describe('(!negative test!) integration test: ext. createCollection():', () => {
+  let alice: IKeyringPair;
 
-      const collection = (await getDetailedCollectionInfo(api, result.collectionId))!;
-      expect(collection.readOnly.toHuman()).to.be.false;
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([100n], donor);
     });
   });
-});
 
-describe('(!negative test!) integration test: ext. createCollection():', () => {
-  it('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async () => {
-    await createCollectionExpectFailure({name: 'A'.repeat(65), mode: {type: 'NFT'}});
+  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
-  it('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async () => {
-    await createCollectionExpectFailure({description: 'A'.repeat(257), mode: {type: 'NFT'}});
+  itSub('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
-  it('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async () => {
-    await createCollectionExpectFailure({tokenPrefix: 'A'.repeat(17), mode: {type: 'NFT'}});
+  itSub('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
-  it('fails when bad limits are set', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const tx = api.tx.unique.createCollectionEx({mode: 'NFT', limits: {tokenLimit: 0}});
-      await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/^common.CollectionTokenLimitExceeded$/);
-    });
+  
+  itSub('(!negative test!) fails when bad limits are set', async ({helper}) => {
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
+    await expect(mintCollectionTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
 
-  it('(!negative test!) create collection with incorrect property limit (64 elements)', async () => {
-    const props = [];
+  itSub('(!negative test!) create collection with incorrect property limit (64 elements)', async ({helper}) => {
+    const props: IProperty[] = [];
 
     for (let i = 0; i < 65; i++) {
       props.push({key: `key${i}`, value: `value${i}`});
     }
-
-    await createCollectionWithPropsExpectFailure({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, properties: props});
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('(!negative test!) create collection with incorrect property limit (40 kb)', async () => {
-    const props = [];
+  itSub('(!negative test!) create collection with incorrect property limit (40 kb)', async ({helper}) => {
+    const props: IProperty[] = [];
 
     for (let i = 0; i < 32; i++) {
       props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)});
     }
 
-    await createCollectionWithPropsExpectFailure({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, properties: props});
+    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 });

--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -14,308 +14,259 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import {default as usingApi, executeTransaction} from './substrate/substrate-api';
-import chai from 'chai';
 import {IKeyringPair} from '@polkadot/types/types';
-import {
-  createCollectionExpectSuccess,
-  createItemExpectSuccess,
-  addCollectionAdminExpectSuccess,
-  createCollectionWithPropsExpectSuccess,
-  createItemWithPropsExpectSuccess,
-  createItemWithPropsExpectFailure,
-  createCollection,
-  transferExpectSuccess,
-  itApi,
-  normalizeAccountId,
-  getCreateItemResult,
-  requirePallets,
-  Pallets,
-} from './util/helpers';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
+import {IProperty, ICrossAccountId} from './util/playgrounds/types';
+import {UniqueHelper} from './util/playgrounds/unique';
+
+async function mintTokenHelper(helper: UniqueHelper, collection: any, signer: IKeyringPair, owner: ICrossAccountId, type: 'nft' | 'fungible' | 'refungible'='nft', properties?: IProperty[]) {
+  let token;
+  const itemCountBefore = await helper.collection.getLastTokenId(collection.collectionId);
+  const itemBalanceBefore = (await helper.callRpc('api.rpc.unique.balance', [collection.collectionId, owner, 0])).toBigInt();
+  if (type === 'nft') {
+    token = await collection.mintToken(signer, owner, properties);
+  } else if (type === 'fungible') {
+    await collection.mint(signer, 10n, owner);
+  } else {
+    token = await collection.mintToken(signer, 100n, owner, properties);
+  }
+
+  const itemCountAfter = await helper.collection.getLastTokenId(collection.collectionId);
+  const itemBalanceAfter = (await helper.callRpc('api.rpc.unique.balance', [collection.collectionId, owner, 0])).toBigInt();
+
+  if (type === 'fungible') {
+    expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);
+  } else {
+    expect(itemCountAfter).to.be.equal(itemCountBefore + 1);
+  }
+
+  return token;
+}
 
-const expect = chai.expect;
-let alice: IKeyringPair;
-let bob: IKeyringPair;
 
 describe('integration test: ext. ():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Create new item in NFT collection', async () => {
-    const createMode = 'NFT';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
-    await createItemExpectSuccess(alice, newCollectionID, createMode);
+  itSub('Create new item in NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await mintTokenHelper(helper, collection, alice, {Substrate: alice.address});
   });
-  it('Create new item in Fungible collection', async () => {
-    const createMode = 'Fungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
-    await createItemExpectSuccess(alice, newCollectionID, createMode);
+  itSub('Create new item in Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await mintTokenHelper(helper, collection, alice, {Substrate: alice.address}, 'fungible');
   });
-  itApi('Check events on create new item in Fungible collection', async ({api}) => {
-    const createMode = 'Fungible';
-    
-    const newCollectionID = (await createCollection(api, alice, {mode: {type: createMode, decimalPoints: 0}})).collectionId;
-    
-    const to = normalizeAccountId(alice);
+  itSub('Check events on create new item in Fungible collection', async ({helper}) => {
+    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'}, 0);
+    const to = {Substrate: alice.address};
     {
       const createData = {fungible: {value: 100}};
-      const tx = api.tx.unique.createItem(newCollectionID, to, createData as any);
-      const events = await executeTransaction(api, alice, tx);
-      const result = getCreateItemResult(events);
-      expect(result.amount).to.be.equal(100);
-      expect(result.collectionId).to.be.equal(newCollectionID);
-      expect(result.recipient).to.be.deep.equal(to);
+      const events = await helper.executeExtrinsic(alice, 'api.tx.unique.createItem', [collectionId, to, createData as any]);
+      const result = helper.util.extractTokensFromCreationResult(events);
+      expect(result.tokens[0].amount).to.be.equal(100n);
+      expect(result.tokens[0].collectionId).to.be.equal(collectionId);
+      expect(result.tokens[0].owner).to.be.deep.equal(to);
     }
     {
       const createData = {fungible: {value: 50}};
-      const tx = api.tx.unique.createItem(newCollectionID, to, createData as any);
-      const events = await executeTransaction(api, alice, tx);
-      const result = getCreateItemResult(events);
-      expect(result.amount).to.be.equal(50);
-      expect(result.collectionId).to.be.equal(newCollectionID);
-      expect(result.recipient).to.be.deep.equal(to);
+      const events = await helper.executeExtrinsic(alice, 'api.tx.unique.createItem', [collectionId, to, createData as any]);
+      const result = helper.util.extractTokensFromCreationResult(events);
+      expect(result.tokens[0].amount).to.be.equal(50n);
+      expect(result.tokens[0].collectionId).to.be.equal(collectionId);
+      expect(result.tokens[0].owner).to.be.deep.equal(to);
     }
-
   });
-  it('Create new item in ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    const createMode = 'ReFungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
-    await createItemExpectSuccess(alice, newCollectionID, createMode);
+  itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) =>  {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await mintTokenHelper(helper, collection, alice, {Substrate: alice.address}, 'refungible');
   });
-  it('Create new item in NFT collection with collection admin permissions', async () => {
-    const createMode = 'NFT';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
-    await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-    await createItemExpectSuccess(bob, newCollectionID, createMode);
+  itSub('Create new item in NFT collection with collection admin permissions', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await mintTokenHelper(helper, collection, bob, {Substrate: alice.address});
   });
-  it('Create new item in Fungible collection with collection admin permissions', async () => {
-    const createMode = 'Fungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
-    await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-    await createItemExpectSuccess(bob, newCollectionID, createMode);
+  itSub('Create new item in Fungible collection with collection admin permissions', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await mintTokenHelper(helper, collection, bob, {Substrate: alice.address}, 'fungible');
   });
-  it('Create new item in ReFungible collection with collection admin permissions', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    const createMode = 'ReFungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
-    await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-    await createItemExpectSuccess(bob, newCollectionID, createMode);
+  itSub.ifWithPallets('Create new item in ReFungible collection with collection admin permissions', [Pallets.ReFungible], async ({helper}) =>  {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await mintTokenHelper(helper, collection, bob, {Substrate: alice.address}, 'refungible');
   });
 
-  it('Set property Admin', async () => {
-    const createMode = 'NFT';
-    const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, 
-      propPerm:   [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]});
-    
-    await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'k', value: 't2'}]);
+  itSub('Set property Admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
+    });
+    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
   });
 
-  it('Set property AdminConst', async () => {
-    const createMode = 'NFT';
-    const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, 
-      propPerm:   [{key: 'key1', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]});
-    
-    await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'key1', value: 'val1'}]);
-  });
-
-  it('Set property itemOwnerOrAdmin', async () => {
-    const createMode = 'NFT';
-    const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode},
-      propPerm:   [{key: 'key1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});
-    
-    await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'key1', value: 'val1'}]);
-  });
-
-  it('Check total pieces of Fungible token', async () => {
-    await usingApi(async api => {
-      const createMode = 'Fungible';
-      const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
-      const amountPieces = 10n;
-      const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
-      {
-        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
-        expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
-      }
-
-      await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
-      {
-        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
-        expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
-      }
-
-      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
-      expect(totalPieces.toBigInt()).to.be.eq(amountPieces);
+  itSub('Set property AdminConst', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
     });
+    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
   });
 
-  it('Check total pieces of NFT token', async () => {
-    await usingApi(async api => {
-      const createMode = 'NFT';
-      const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
-      const amountPieces = 1n;
-      const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
-      {
-        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
-        expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
-      }
-
-      await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
-      {
-        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
-        expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
-      }
-
-      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
-      expect(totalPieces.toBigInt()).to.be.eq(amountPieces);
+  itSub('Set property itemOwnerOrAdmin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+      properties: [{key: 'k', value: 'v'}],
+      tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
     });
+    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
   });
 
-  it('Check total pieces of ReFungible token', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub('Check total pieces of Fungible token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const amount = 10n;
+    await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'fungible');
+    {
+      const totalPieces = await collection.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
+    await collection.transfer(bob, {Substrate: alice.address}, 1n);
+    {
+      const totalPieces = await collection.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
+  });
 
-    await usingApi(async api => {
-      const createMode = 'ReFungible';
-      const createCollectionResult = await createCollection(api, alice, {mode: {type: createMode}});
-      const collectionId  = createCollectionResult.collectionId;
-      const amountPieces = 100n;
-      const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
-      {
-        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
-        expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
-      }
+  itSub('Check total pieces of NFT token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const amount = 1n;
+    const token = await mintTokenHelper(helper, collection, alice, {Substrate: bob.address});
+    {
+      const totalPieces = await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, token.tokenId]);
+      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+    }
+    await token.transfer(bob, {Substrate: alice.address});
+    {
+      const totalPieces = await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, token.tokenId]);
+      expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+    }
+  });
 
-      await transferExpectSuccess(collectionId, tokenId, bob, alice, 60n, createMode);
-      {
-        const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
-        expect(totalPieces.isSome).to.be.true;
-        expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
-      }
-
-      const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
-      expect(totalPieces.toBigInt()).to.be.eq(amountPieces);
-    });
+  itSub.ifWithPallets('Check total pieces of ReFungible token', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const amount = 100n;
+    const token = await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'refungible');
+    {
+      const totalPieces = await token.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
+    await token.transfer(bob, {Substrate: alice.address}, 60n);
+    {
+      const totalPieces = await token.getTotalPieces();
+      expect(totalPieces).to.be.equal(amount);
+    }
   });
 });
 
 describe('Negative integration test: ext. createItem():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Regular user cannot create new item in NFT collection', async () => {
-    const createMode = 'NFT';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
-    await expect(createItemExpectSuccess(bob, newCollectionID, createMode)).to.be.rejected;
+  itSub('Regular user cannot create new item in NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
-  it('Regular user cannot create new item in Fungible collection', async () => {
-    const createMode = 'Fungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
-    await expect(createItemExpectSuccess(bob, newCollectionID, createMode)).to.be.rejected;
+  itSub('Regular user cannot create new item in Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const mintTx = async () => collection.mint(bob, 10n, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
-  it('Regular user cannot create new item in ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    const createMode = 'ReFungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
-    await expect(createItemExpectSuccess(bob, newCollectionID, createMode)).to.be.rejected;
+  itSub.ifWithPallets('Regular user cannot create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(bob, 100n, {Substrate: bob.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('No editing rights', async () => {
-    await usingApi(async () => {
-      const createMode = 'NFT';
-      const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode}, 
-        propPerm:   [{key: 'key1', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}]});
-      await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-
-      await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'key1', value: 'v'}]);
+  itSub('No editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('User doesnt have editing rights', async () => {
-    await usingApi(async () => {
-      const newCollectionID = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
-      await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'key1', value: 'v'}]);
+  itSub('User doesnt have editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding property without access rights', async () => {
-    await usingApi(async () => {
-      const newCollectionID = await createCollectionWithPropsExpectSuccess();
-      await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-
-      await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'k', value: 'v'}]);
-    });
+  itSub('Adding property without access rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding more than 64 prps', async () => {
-    await usingApi(async () => {
-      const prps = [];
+  itSub('Adding more than 64 prps', async ({helper}) => {
+    const props: IProperty[] = [];
 
-      for (let i = 0; i < 65; i++) {
-        prps.push({key: `key${i}`, value: `value${i}`});
-      }
+    for (let i = 0; i < 65; i++) {
+      props.push({key: `key${i}`, value: `value${i}`});
+    }
 
-      const newCollectionID = await createCollectionWithPropsExpectSuccess();
-      
-      await createItemWithPropsExpectFailure(alice, newCollectionID, 'NFT', prps);
-    });
-  });
 
-  it('Trying to add bigger property than allowed', async () => {
-    await usingApi(async () => {
-      const newCollectionID = await createCollectionWithPropsExpectSuccess();
-      
-      await createItemWithPropsExpectFailure(alice, newCollectionID, 'NFT', [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]);
-    });
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Check total pieces for invalid Fungible token', async () => {
-    await usingApi(async api => {
-      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'Fungible', decimalPoints: 0}});
-      const collectionId  = createCollectionResult.collectionId;
-      const invalidTokenId = 1000_000;
-      
-      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
-      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.toBigInt()).to.be.eq(0n);
+  itSub('Trying to add bigger property than allowed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+        {key: 'k2', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+      ],
     });
+    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [
+      {key: 'k1', value: 'vvvvvv'.repeat(5000)},
+      {key: 'k2', value: 'vvv'.repeat(5000)},
+    ]);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoSpaceForProperty/);
   });
 
-  it('Check total pieces for invalid NFT token', async () => {
-    await usingApi(async api => {
-      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'NFT'}});
-      const collectionId  = createCollectionResult.collectionId;
-      const invalidTokenId = 1000_000;
-      
-      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
-      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.toBigInt()).to.be.eq(0n);
-    });
+  itSub('Check total pieces for invalid Fungible token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+    const invalidTokenId = 1_000_000;
+    expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+    expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
   });
 
-  it('Check total pieces for invalid Refungible token', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub('Check total pieces for invalid NFT token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const invalidTokenId = 1_000_000;
+    expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+    expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
+  });
 
-    await usingApi(async api => {
-      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'ReFungible'}});
-      const collectionId  = createCollectionResult.collectionId;
-      const invalidTokenId = 1000_000;
-      
-      expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
-      expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.toBigInt()).to.be.eq(0n);
-    });
+  itSub.ifWithPallets('Check total pieces for invalid Refungible token', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+    const invalidTokenId = 1_000_000;
+    expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+    expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
   });
 });

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -14,292 +14,151 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import {ApiPromise} from '@polkadot/api';
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync, executeTransaction} from './substrate/substrate-api';
-import {
-  createCollectionExpectSuccess,
-  destroyCollectionExpectSuccess,
-  getGenericResult,
-  normalizeAccountId,
-  setCollectionLimitsExpectSuccess,
-  addCollectionAdminExpectSuccess,
-  getBalance,
-  getTokenOwner,
-  getLastTokenId,
-  getCreatedCollectionCount,
-  createCollectionWithPropsExpectSuccess,
-  createMultipleItemsWithPropsExpectSuccess,
-  getTokenProperties,
-  requirePallets,
-  Pallets,
-  checkPalletsPresence,
-} from './util/helpers';
+import {usingPlaygrounds, expect, Pallets, itSub} from './util/playgrounds';
 
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
 describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
-  it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
+  let alice: IKeyringPair;
 
-      const alice = privateKeyWrapper('//Alice');
-      await submitTransactionAsync(
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collectionId, [{key: 'data', permission: {tokenOwner: true}}]),
-      );
-      
-      const args = [
-        {NFT: {properties: [{key: 'data', value: '1'}]}},
-        {NFT: {properties: [{key: 'data', value: '2'}]}},
-        {NFT: {properties: [{key: 'data', value: '3'}]}},
-      ];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await submitTransactionAsync(alice, createMultipleItemsTx);
-      const itemsListIndexAfter = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexAfter).to.be.equal(3);
-
-      expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));
-
-      expect((await getTokenProperties(api, collectionId, 1, ['data']))[0].value).to.be.equal('1');
-      expect((await getTokenProperties(api, collectionId, 2, ['data']))[0].value).to.be.equal('2');
-      expect((await getTokenProperties(api, collectionId, 3, ['data']))[0].value).to.be.equal('3');
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([100n], donor);
     });
   });
 
-  it('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const alice = privateKeyWrapper('//Alice');
-      const args = [
-        {Fungible: {value: 1}},
-        {Fungible: {value: 2}},
-        {Fungible: {value: 3}},
-      ];
-      const createMultipleItemsTx = api.tx.unique
-        .createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await submitTransactionAsync(alice, createMultipleItemsTx);
-      const token1Data = await getBalance(api, collectionId, alice.address, 0);
-
-      expect(token1Data).to.be.equal(6n); // 1 + 2 + 3
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
-
-  it('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const alice = privateKeyWrapper('//Alice');
-      const args = [
-        {ReFungible: {pieces: 1}},
-        {ReFungible: {pieces: 2}},
-        {ReFungible: {pieces: 3}},
-      ];
-      const createMultipleItemsTx = api.tx.unique
-        .createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await submitTransactionAsync(alice, createMultipleItemsTx);
-      const itemsListIndexAfter = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexAfter).to.be.equal(3);
-
-      expect(await getBalance(api, collectionId, alice.address, 1)).to.be.equal(1n);
-      expect(await getBalance(api, collectionId, alice.address, 2)).to.be.equal(2n);
-      expect(await getBalance(api, collectionId, alice.address, 3)).to.be.equal(3n);
+  itSub('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {value: 1n},
+      {value: 2n},
+      {value: 3n},
+    ];
+    await helper.ft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, args, {Substrate: alice.address});
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(6n);
   });
-
-  it('Can mint amount of items equals to collection limits', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
 
-      const collectionId = await createCollectionExpectSuccess();
-      await setCollectionLimitsExpectSuccess(alice, collectionId, {
-        tokenLimit: 2,
-      });
-      const args = [
-        {NFT: {}},
-        {NFT: {}},
-      ];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      const events = await submitTransactionAsync(alice, createMultipleItemsTx);
-      const result = getGenericResult(events);
-      expect(result.success).to.be.true;
+  itSub.ifWithPallets('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
-  });
+    const args = [
+      {pieces: 1n},
+      {pieces: 2n},
+      {pieces: 3n},
+    ];
+    const tokens = await helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT with property Admin', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const alice = privateKeyWrapper('//Alice');
-      const args = [
-        {NFT: {properties: [{key: 'k', value: 'v1'}]}},
-        {NFT: {properties: [{key: 'k', value: 'v2'}]}},
-        {NFT: {properties: [{key: 'k', value: 'v3'}]}},
-      ];
-
-      await createMultipleItemsWithPropsExpectSuccess(alice, collectionId, args);
-      const itemsListIndexAfter = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexAfter).to.be.equal(3);
-
-      expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));
-
-      expect((await getTokenProperties(api, collectionId, 1, ['k']))[0].value).to.be.equal('v1');
-      expect((await getTokenProperties(api, collectionId, 2, ['k']))[0].value).to.be.equal('v2');
-      expect((await getTokenProperties(api, collectionId, 3, ['k']))[0].value).to.be.equal('v3');
-    });
+    for (const [i, token] of tokens.entries()) {
+      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(BigInt(i + 1));
+    }
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT with property AdminConst', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const args = [
-        {NFT: {properties: [{key: 'k', value: 'v1'}]}},
-        {NFT: {properties: [{key: 'k', value: 'v2'}]}},
-        {NFT: {properties: [{key: 'k', value: 'v3'}]}},
-      ];
-
-      await createMultipleItemsWithPropsExpectSuccess(alice, collectionId, args);
-      const itemsListIndexAfter = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexAfter).to.be.equal(3);
-
-      expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));
-
-      expect((await getTokenProperties(api, collectionId, 1, ['k']))[0].value).to.be.equal('v1');
-      expect((await getTokenProperties(api, collectionId, 2, ['k']))[0].value).to.be.equal('v2');
-      expect((await getTokenProperties(api, collectionId, 3, ['k']))[0].value).to.be.equal('v3');
+  itSub('Can mint amount of items equals to collection limits', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      limits: {
+        tokenLimit: 2,
+      },
     });
+    const args = [{}, {}];
+    await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT with property itemOwnerOrAdmin', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const alice = privateKeyWrapper('//Alice');
-      const args = [
-        {NFT: {properties: [{key: 'k', value: 'v1'}]}},
-        {NFT: {properties: [{key: 'k', value: 'v2'}]}},
-        {NFT: {properties: [{key: 'k', value: 'v3'}]}},
-      ];
-
-      await createMultipleItemsWithPropsExpectSuccess(alice, collectionId, args);
-      const itemsListIndexAfter = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexAfter).to.be.equal(3);
-
-      expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));
-
-      expect((await getTokenProperties(api, collectionId, 1, ['k']))[0].value).to.be.equal('v1');
-      expect((await getTokenProperties(api, collectionId, 2, ['k']))[0].value).to.be.equal('v2');
-      expect((await getTokenProperties(api, collectionId, 3, ['k']))[0].value).to.be.equal('v3');
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT with property Admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
-});
 
-describe('Integration Test createMultipleItems(collection_id, owner, items_data) with collection admin permissions:', () => {
-  let alice: IKeyringPair;
-  let bob: IKeyringPair;
-
-  before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT with property AdminConst', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
 
-  it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'data', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const args = [
-        {NFT: {properties: [{key: 'data', value: 'v1'}]}},
-        {NFT: {properties: [{key: 'data', value: 'v2'}]}},
-        {NFT: {properties: [{key: 'data', value: 'v3'}]}},
-      ];
-      const createMultipleItemsTx = api.tx.unique
-        .createMultipleItems(collectionId, normalizeAccountId(bob.address), args);
-      await submitTransactionAsync(bob, createMultipleItemsTx);
-      const itemsListIndexAfter = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexAfter).to.be.equal(3);
-
-      expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(bob.address));
-      expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(bob.address));
-      expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(bob.address));
-
-      expect((await getTokenProperties(api, collectionId, 1, ['data']))[0].value).to.be.equal('v1');
-      expect((await getTokenProperties(api, collectionId, 2, ['data']))[0].value).to.be.equal('v2');
-      expect((await getTokenProperties(api, collectionId, 3, ['data']))[0].value).to.be.equal('v3');
+  itSub('Create 0x31, 0x32, 0x33 items in active NFT with property itemOwnerOrAdmin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
-  });
-
-  it('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const args = [
-        {Fungible: {value: 1}},
-        {Fungible: {value: 2}},
-        {Fungible: {value: 3}},
-      ];
-      const createMultipleItemsTx = api.tx.unique
-        .createMultipleItems(collectionId, normalizeAccountId(bob.address), args);
-      await submitTransactionAsync(bob, createMultipleItemsTx);
-      const token1Data = await getBalance(api, collectionId, bob.address, 0);
-
-      expect(token1Data).to.be.equal(6n); // 1 + 2 + 3
-    });
-  });
-
-  it('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const args = [
-        {ReFungible: {pieces: 1}},
-        {ReFungible: {pieces: 2}},
-        {ReFungible: {pieces: 3}},
-      ];
-      const createMultipleItemsTx = api.tx.unique
-        .createMultipleItems(collectionId, normalizeAccountId(bob.address), args);
-      await submitTransactionAsync(bob, createMultipleItemsTx);
-      const itemsListIndexAfter = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexAfter).to.be.equal(3);
-
-      expect(await getBalance(api, collectionId, bob.address, 1)).to.be.equal(1n);
-      expect(await getBalance(api, collectionId, bob.address, 2)).to.be.equal(2n);
-      expect(await getBalance(api, collectionId, bob.address, 3)).to.be.equal(3n);
-    });
+    const args = [
+      {properties: [{key: 'data', value: '1'}]},
+      {properties: [{key: 'data', value: '2'}]},
+      {properties: [{key: 'data', value: '3'}]},
+    ];
+    const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    for (const [i, token] of tokens.entries()) {
+      const tokenData = await token.getData();
+      expect(tokenData?.normalizedOwner.Substrate).to.be.equal(helper.address.normalizeSubstrate(alice.address));
+      expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);
+    }
   });
 });
 
@@ -308,238 +167,208 @@
   let bob: IKeyringPair;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Regular user cannot create items in active NFT collection', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionExpectSuccess();
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const args = [{NFT: {}},
-        {NFT: {}},
-        {NFT: {}}];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(executeTransaction(api, bob, createMultipleItemsTx)).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
+  itSub('Regular user cannot create items in active NFT collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {},
+      {},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('Regular user cannot create items in active Fungible collection', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const args = [
-        {Fungible: {value: 1}},
-        {Fungible: {value: 2}},
-        {Fungible: {value: 3}},
-      ];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(executeTransaction(api, bob, createMultipleItemsTx)).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
+  itSub('Regular user cannot create items in active Fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {value: 1n},
+      {value: 2n},
+      {value: 3n},
+    ];
+    const mintTx = async () => helper.ft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, args, {Substrate: alice.address});
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
-
-  it('Regular user cannot create items in active ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const args = [
-        {ReFungible: {pieces: 1}},
-        {ReFungible: {pieces: 1}},
-        {ReFungible: {pieces: 1}},
-      ];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(executeTransaction(api, bob, createMultipleItemsTx)).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
+  itSub.ifWithPallets('Regular user cannot create items in active ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {pieces: 1n},
+      {pieces: 1n},
+      {pieces: 1n},
+    ];
+    const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
-  it('Create token in not existing collection', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await getCreatedCollectionCount(api) + 1;
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), ['NFT', 'NFT', 'NFT']);
-      await expect(executeTransaction(api, alice, createMultipleItemsTx)).to.be.rejectedWith(/common\.CollectionNotFound/);
-    });
+  itSub('Create token in not existing collection', async ({helper}) => {
+    const collectionId = 1_000_000;
+    const args = [
+      {},
+      {},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Create NFTs that has reached the maximum data limit', async function() {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({
-        propPerm: [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}],
-      });
-      const alice = privateKeyWrapper('//Alice');
-      const args = [
-        {NFT: {properties: [{key: 'key', value: 'A'.repeat(32769)}]}},
-        {NFT: {properties: [{key: 'key', value: 'B'.repeat(32769)}]}},
-        {NFT: {properties: [{key: 'key', value: 'C'.repeat(32769)}]}},
-      ];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTx)).to.be.rejected;
+  itSub('Create NFTs that has reached the maximum data limit', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'.repeat(32769)}]},
+      {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
+      {properties: [{key: 'data', value: 'C'.repeat(32769)}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Create Refungible tokens that has reached the maximum data limit', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    await usingApi(async api => {
-      const collectionIdReFungible =
-        await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      {
-        const argsReFungible = [
-          {ReFungible: [10, [['key', 'A'.repeat(32769)]]]},
-          {ReFungible: [10, [['key', 'B'.repeat(32769)]]]},
-          {ReFungible: [10, [['key', 'C'.repeat(32769)]]]},
-        ];
-        const createMultipleItemsTxFungible = api.tx.unique
-          .createMultipleItems(collectionIdReFungible, normalizeAccountId(alice.address), argsReFungible);
-        await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTxFungible)).to.be.rejected;
-      }
-      {
-        const argsReFungible = [
-          {ReFungible: {properties: [{key: 'key', value: 'A'.repeat(32769)}]}},
-          {ReFungible: {properties: [{key: 'key', value: 'B'.repeat(32769)}]}},
-          {ReFungible: {properties: [{key: 'key', value: 'C'.repeat(32769)}]}},
-        ];
-        const createMultipleItemsTxFungible = api.tx.unique
-          .createMultipleItems(collectionIdReFungible, normalizeAccountId(alice.address), argsReFungible);
-        await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTxFungible)).to.be.rejected;
-      }
+  itSub.ifWithPallets('Create Refungible tokens that has reached the maximum data limit', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {pieces: 10n, properties: [{key: 'data', value: 'A'.repeat(32769)}]},
+      {pieces: 10n, properties: [{key: 'data', value: 'B'.repeat(32769)}]},
+      {pieces: 10n, properties: [{key: 'data', value: 'C'.repeat(32769)}]},
+    ];
+    const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
-
-  it('Create tokens with different types', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionExpectSuccess();
 
-      const types = ['NFT', 'Fungible'];
-
-      if (await checkPalletsPresence([Pallets.ReFungible])) {
-        types.push('ReFungible');
-      }
-
-      const createMultipleItemsTx = api.tx.unique
-        .createMultipleItems(collectionId, normalizeAccountId(alice.address), types);
-      await expect(executeTransaction(api, alice, createMultipleItemsTx)).to.be.rejectedWith(/nonfungible\.NotNonfungibleDataUsedToMintFungibleCollectionToken/);
-      // garbage collection :-D // lol
-      await destroyCollectionExpectSuccess(collectionId);
+  itSub.ifWithPallets('Create tokens with different types', [Pallets.ReFungible], async ({helper}) => {
+    const {collectionId} = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+
+    const types = ['NFT', 'Fungible', 'ReFungible'];
+    await expect(helper.executeExtrinsic(
+      alice, 
+      'api.tx.unique.createMultipleItems', 
+      [collectionId, {Substrate: alice.address}, types],
+    )).to.be.rejectedWith(/nonfungible\.NotNonfungibleDataUsedToMintFungibleCollectionToken/);
   });
 
-  it('Create tokens with different data limits <> maximum data limit', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({
-        propPerm: [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}],
-      });
-      const args = [
-        {NFT: {properties: [{key: 'key', value: 'A'}]}},
-        {NFT: {properties: [{key: 'key', value: 'B'.repeat(32769)}]}},
-      ];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTx)).to.be.rejected;
+  itSub('Create tokens with different data limits <> maximum data limit', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'}]},
+      {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
-  it('Fails when minting tokens exceeds collectionLimits amount', async () => {
-    await usingApi(async (api) => {
-      const collectionId = await createCollectionExpectSuccess();
-      await setCollectionLimitsExpectSuccess(alice, collectionId, {
+  itSub('Fails when minting tokens exceeds collectionLimits amount', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
+      ],
+      limits: {
         tokenLimit: 1,
-      });
-      const args = [
-        {NFT: {}},
-        {NFT: {}},
-      ];
-      const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(executeTransaction(api, alice, createMultipleItemsTx)).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
+      },
     });
+    const args = [
+      {},
+      {},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
 
-  it('User doesnt have editing rights', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({
-        propPerm: [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
-      });
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const args = [
-        {NFT: {properties: [{key: 'key1', value: 'v2'}]}},
-        {NFT: {}},
-        {NFT: {}},
-      ];
-
-      const tx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(bob.address), args);
-      await expect(executeTransaction(api, bob, tx)).to.be.rejectedWith(/common\.NoPermission/);
+  itSub('User doesnt have editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: false}},
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
-
-  it('Adding property without access rights', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'k', value: 'v1'}]});
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const args = [{NFT: {properties: [{key: 'k', value: 'v'}]}},
-        {NFT: {}},
-        {NFT: {}}];
 
-      const tx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(bob.address), args);
-      await expect(executeTransaction(api, bob, tx)).to.be.rejectedWith(/common\.NoPermission/);
+  itSub('Adding property without access rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      properties: [
+        {
+          key: 'data',
+          value: 'v',
+        },
+      ],
     });
+    const args = [
+      {properties: [{key: 'data', value: 'A'}]},
+    ];
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding more than 64 prps', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const propPerms = [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}];
-      for (let i = 0; i < 65; i++) {
-        propPerms.push({key: `key${i}`, permission: {mutable: true, collectionAdmin: true, tokenOwner: true}});
-      }
-
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-
-      const tx1 = api.tx.unique.setTokenPropertyPermissions(collectionId, propPerms);
-      await expect(executeTransaction(api, alice, tx1)).to.be.rejectedWith(/common\.PropertyLimitReached/);
-
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-
-      const prps = [];
-
-      for (let i = 0; i < 65; i++) {
-        prps.push({key: `key${i}`, value: `value${i}`});
-      }
-
-      const args = [
-        {NFT: {properties: prps}},
-        {NFT: {properties: prps}},
-        {NFT: {properties: prps}},
-      ];
-
-      // there are no permissions, but will fail anyway because of too much weight for a block
-      const tx2 = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(submitTransactionExpectFailAsync(alice, tx2)).to.be.rejected;
+  itSub('Adding more than 64 prps', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
-  });
+    const prps = [];
 
-  it('Trying to add bigger property than allowed', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionWithPropsExpectSuccess({
-        propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}],
-      });
-      const itemsListIndexBefore = await getLastTokenId(api, collectionId);
-      expect(itemsListIndexBefore).to.be.equal(0);
-      const args = [{NFT: {properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}},
-        {NFT: {properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}},
-        {NFT: {properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}}];
+    for (let i = 0; i < 65; i++) {
+      prps.push({key: `key${i}`, value: `value${i}`});
+    }
+
+    const args = [
+      {properties: prps},
+      {properties: prps},
+      {properties: prps},
+    ];
 
-      const tx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);
-      await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
-    });
+    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 });

--- a/tests/src/createMultipleItemsEx.test.ts
+++ b/tests/src/createMultipleItemsEx.test.ts
@@ -14,382 +14,433 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import {expect} from 'chai';
-import usingApi, {executeTransaction} from './substrate/substrate-api';
-import {addCollectionAdminExpectSuccess, createCollectionExpectSuccess, createCollectionWithPropsExpectSuccess, getBalance, getLastTokenId, getTokenProperties, requirePallets, Pallets} from './util/helpers';
+import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, Pallets, itSub} from './util/playgrounds';
+import {IProperty} from './util/playgrounds/types';
 
 describe('Integration Test: createMultipleItemsEx', () => {
-  it('can initialize multiple NFT with different owners', async () => {
-    const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      const data = [
-        {
-          owner: {substrate: alice.address},
-        }, {
-          owner: {substrate: bob.address},
-        }, {
-          owner: {substrate: charlie.address},
-        },
-      ];
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+    });
+  });
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        NFT: data,
-      }));
-      const tokens = await api.query.nonfungible.tokenData.entries(collection);
-      const json = tokens.map(([, token]) => token.toJSON());
-      expect(json).to.be.deep.equal(data);
+  itSub('can initialize multiple NFT with different owners', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
     });
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+      },
+      {
+        owner: {Substrate: bob.address},
+      },
+      {
+        owner: {Substrate: charlie.address},
+      },
+    ];
+
+    const tokens = await collection.mintMultipleTokens(alice, args);
+    for (const [i, token] of tokens.entries()) {
+      expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+    }
   });
 
-  it('createMultipleItemsEx with property Admin', async () => {
-    const collection = await createCollectionWithPropsExpectSuccess({mode: {type: 'NFT'}, propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      const data = [
+  itSub('createMultipleItemsEx with property Admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
         {
-          owner: {substrate: alice.address},
-          properties: [{key: 'k', value: 'v1'}],
-        }, {
-          owner: {substrate: bob.address},
-          properties: [{key: 'k', value: 'v2'}],
-        }, {
-          owner: {substrate: charlie.address},
-          properties: [{key: 'k', value: 'v3'}],
+          key: 'k',
+          permission: {
+            mutable: true,
+            collectionAdmin: true,
+            tokenOwner: false,
+          },
         },
-      ];
+      ],
+    });
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        NFT: data,
-      }));
-      for (let i = 1; i < 4; i++) {
-        expect(await api.rpc.unique.tokenProperties(collection, i)).not.to.be.empty;
-      }
-    });
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: [{key: 'k', value: 'v1'}],
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: [{key: 'k', value: 'v2'}],
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: [{key: 'k', value: 'v3'}],
+      },
+    ];
+
+    const tokens = await collection.mintMultipleTokens(alice, args);
+    for (const [i, token] of tokens.entries()) {
+      expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+      expect(await token.getData()).to.not.be.empty;
+    }
   });
 
-  it('createMultipleItemsEx with property AdminConst', async () => {
-    const collection = await createCollectionWithPropsExpectSuccess({mode: {type: 'NFT'}, propPerm: [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      const data = [
+  itSub('createMultipleItemsEx with property AdminConst', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
         {
-          owner: {substrate: alice.address},
-          properties: [{key: 'k', value: 'v1'}],
-        }, {
-          owner: {substrate: bob.address},
-          properties: [{key: 'k', value: 'v2'}],
-        }, {
-          owner: {substrate: charlie.address},
-          properties: [{key: 'k', value: 'v3'}],
+          key: 'k',
+          permission: {
+            mutable: false,
+            collectionAdmin: true,
+            tokenOwner: false,
+          },
         },
-      ];
+      ],
+    });
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        NFT: data,
-      }));
-      for (let i = 1; i < 4; i++) {
-        expect(await api.rpc.unique.tokenProperties(collection, i)).not.to.be.empty;
-      }
-    });
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: [{key: 'k', value: 'v1'}],
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: [{key: 'k', value: 'v2'}],
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: [{key: 'k', value: 'v3'}],
+      },
+    ];
+
+    const tokens = await collection.mintMultipleTokens(alice, args);
+    for (const [i, token] of tokens.entries()) {
+      expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+      expect(await token.getData()).to.not.be.empty;
+    }
   });
 
-  it('createMultipleItemsEx with property itemOwnerOrAdmin', async () => {
-    const collection = await createCollectionWithPropsExpectSuccess({mode: {type: 'NFT'}, propPerm: [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}]});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      const data = [
+  itSub('createMultipleItemsEx with property itemOwnerOrAdmin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
         {
-          owner: {substrate: alice.address},
-          properties: [{key: 'k', value: 'v1'}],
-        }, {
-          owner: {substrate: bob.address},
-          properties: [{key: 'k', value: 'v2'}],
-        }, {
-          owner: {substrate: charlie.address},
-          properties: [{key: 'k', value: 'v3'}],
+          key: 'k',
+          permission: {
+            mutable: false,
+            collectionAdmin: true,
+            tokenOwner: true,
+          },
         },
-      ];
+      ],
+    });
+
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: [{key: 'k', value: 'v1'}],
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: [{key: 'k', value: 'v2'}],
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: [{key: 'k', value: 'v3'}],
+      },
+    ];
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        NFT: data,
-      }));
-      for (let i = 1; i < 4; i++) {
-        expect(await api.rpc.unique.tokenProperties(collection, i)).not.to.be.empty;
-      }
-    });
+    const tokens = await collection.mintMultipleTokens(alice, args);
+    for (const [i, token] of tokens.entries()) {
+      expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+      expect(await token.getData()).to.not.be.empty;
+    }
   });
 
-  it('can initialize fungible with multiple owners', async () => {
-    const collection = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
+  itSub('can initialize fungible with multiple owners', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+    }, 0);
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        Fungible: new Map([
-          [JSON.stringify({Substrate: alice.address}), 50],
-          [JSON.stringify({Substrate: bob.address}), 100],
-        ]),
-      }));
+    const api = helper.api;
+    await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {
+      Fungible: new Map([
+        [JSON.stringify({Substrate: alice.address}), 50],
+        [JSON.stringify({Substrate: bob.address}), 100],
+      ]),
+    }));
 
-      expect(await getBalance(api, collection, alice.address, 0)).to.equal(50n);
-      expect(await getBalance(api, collection, bob.address, 0)).to.equal(100n);
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(50n);
+    expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(100n);
+  });
+
+  itSub.ifWithPallets('can initialize an RFT with multiple owners', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'k', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},
+      ],
     });
+
+    const api = helper.api;
+    await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {
+      RefungibleMultipleOwners: {
+        users: new Map([
+          [JSON.stringify({Substrate: alice.address}), 1],
+          [JSON.stringify({Substrate: bob.address}), 2],
+        ]),
+        properties: [
+          {key: 'k', value: 'v'},
+        ],
+      },
+    }));
+    const tokenId = await collection.getLastTokenId();
+    expect(tokenId).to.be.equal(1);
+    expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);
+    expect(await collection.getTokenBalance(1, {Substrate: bob.address})).to.be.equal(2n);
   });
 
-  it('can initialize an RFT with multiple owners', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub.ifWithPallets('can initialize multiple RFTs with the same owner', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
+        {key: 'k', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},
+      ],
+    });
 
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      await executeTransaction(
-        api,
-        alice,
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'data', permission: {tokenOwner: true}}]),
-      );
+    const api = helper.api;
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        RefungibleMultipleOwners: {
-          users: new Map([
-            [JSON.stringify({Substrate: alice.address}), 1],
-            [JSON.stringify({Substrate: bob.address}), 2],
-          ]),
+    await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {
+      RefungibleMultipleItems: [
+        {
+          user: {Substrate: alice.address}, pieces: 1,
           properties: [
-            {key: 'data', value: 'testValue'},
+            {key: 'k', value: 'v1'},
           ],
         },
-      }));
-
-      const itemsListIndexAfter = await getLastTokenId(api, collection);
-      expect(itemsListIndexAfter).to.be.equal(1);
-
-      expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);
-      expect(await getBalance(api, collection, bob.address, 1)).to.be.equal(2n);
-      expect((await getTokenProperties(api, collection, 1, ['data']))[0].value).to.be.equal('testValue');
-    });
-  });
-
-  it('can initialize multiple RFTs with the same owner', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      await executeTransaction(
-        api,
-        alice,
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'data', permission: {tokenOwner: true}}]),
-      );
+        {
+          user: {Substrate: alice.address}, pieces: 3,
+          properties: [
+            {key: 'k', value: 'v2'},
+          ],
+        },
+      ],
+    }));
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        RefungibleMultipleItems: [
-          {
-            user: {Substrate: alice.address}, pieces: 1,
-            properties: [
-              {key: 'data', value: 'testValue1'},
-            ],
-          },
-          {
-            user: {Substrate: alice.address}, pieces: 3,
-            properties: [
-              {key: 'data', value: 'testValue2'},
-            ],
-          },
-        ],
-      }));
+    expect(await collection.getLastTokenId()).to.be.equal(2);
+    expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);
+    expect(await collection.getTokenBalance(2, {Substrate: alice.address})).to.be.equal(3n);
 
-      const itemsListIndexAfter = await getLastTokenId(api, collection);
-      expect(itemsListIndexAfter).to.be.equal(2);
+    const tokenData1 = await helper.rft.getToken(collection.collectionId, 1);
+    expect(tokenData1).to.not.be.null;
+    expect(tokenData1?.properties[0]).to.be.deep.equal({key: 'k', value: 'v1'});
 
-      expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);
-      expect(await getBalance(api, collection, alice.address, 2)).to.be.equal(3n);
-      expect((await getTokenProperties(api, collection, 1, ['data']))[0].value).to.be.equal('testValue1');
-      expect((await getTokenProperties(api, collection, 2, ['data']))[0].value).to.be.equal('testValue2');
-    });
+    const tokenData2 = await helper.rft.getToken(collection.collectionId, 2);
+    expect(tokenData2).to.not.be.null;
+    expect(tokenData2?.properties[0]).to.be.deep.equal({key: 'k', value: 'v2'});
   });
 });
 
 describe('Negative test: createMultipleItemsEx', () => {
-  it('No editing rights', async () => {
-    const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}],
-      propPerm:   [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      const data = [
-        {
-          owner: {substrate: alice.address},
-          properties: [{key: 'key1', value: 'v2'}],
-        }, {
-          owner: {substrate: bob.address},
-          properties: [{key: 'key1', value: 'v2'}],
-        }, {
-          owner: {substrate: charlie.address},
-          properties: [{key: 'key1', value: 'v2'}],
-        },
-      ];
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
 
-      const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
-      // await executeTransaction(api, alice, tx);
-
-      //await submitTransactionExpectFailAsync(alice, tx);
-      await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
   });
 
-  it('User doesnt have editing rights', async () => {
-    const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}],
-      propPerm:   [{key: 'key1', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}]});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      const data = [
+  itSub('No editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
         {
-          owner: {substrate: alice.address},
-          properties: [{key: 'key1', value: 'v2'}],
-        }, {
-          owner: {substrate: alice.address},
-          properties: [{key: 'key1', value: 'v2'}],
-        }, {
-          owner: {substrate: alice.address},
-          properties: [{key: 'key1', value: 'v2'}],
+          key: 'k',
+          permission: {
+            mutable: true,
+            collectionAdmin: false,
+            tokenOwner: false,
+          },
         },
-      ];
+      ],
+    });
 
-      const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
-      // await executeTransaction(api, alice, tx);
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: [{key: 'k', value: 'v1'}],
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: [{key: 'k', value: 'v2'}],
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: [{key: 'k', value: 'v3'}],
+      },
+    ];
 
-      //await submitTransactionExpectFailAsync(alice, tx);
-      await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
-    });
+    await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding property without access rights', async () => {
-    const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}]});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      const data = [
+  itSub('User doesnt have editing rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
         {
-          owner: {substrate: alice.address},
-          properties: [{key: 'key1', value: 'v2'}],
-        }, {
-          owner: {substrate: bob.address},
-          properties: [{key: 'key1', value: 'v2'}],
-        }, {
-          owner: {substrate: charlie.address},
-          properties: [{key: 'key1', value: 'v2'}],
+          key: 'k',
+          permission: {
+            mutable: false,
+            collectionAdmin: false,
+            tokenOwner: false,
+          },
         },
-      ];
+      ],
+    });
 
-      const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: [{key: 'k', value: 'v1'}],
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: [{key: 'k', value: 'v2'}],
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: [{key: 'k', value: 'v3'}],
+      },
+    ];
 
-      await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
-      //await submitTransactionExpectFailAsync(alice, tx);
-    });
+    await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Adding more than 64 properties', async () => {
-    const propPerms = [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}];
+  itSub('Adding property without access rights', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+    });
 
-    for (let i = 0; i < 65; i++) {
-      propPerms.push({key: `key${i}`, permission: {mutable: true, collectionAdmin: true, tokenOwner: true}});
-    }
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: [{key: 'k', value: 'v1'}],
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: [{key: 'k', value: 'v2'}],
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: [{key: 'k', value: 'v3'}],
+      },
+    ];
 
-    const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      await expect(executeTransaction(api, alice, api.tx.unique.setTokenPropertyPermissions(collection, propPerms))).to.be.rejectedWith(/common\.PropertyLimitReached/);
-    });
+    await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Trying to add bigger property than allowed', async () => {
-    const collection = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      const data = [
+  itSub('Adding more than 64 properties', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
         {
-          owner: {substrate: alice.address}, properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}],
-        }, {
-          owner: {substrate: bob.address}, properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}],
-        }, {
-          owner: {substrate: charlie.address}, properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}],
+          key: 'k',
+          permission: {
+            mutable: true,
+            collectionAdmin: true,
+            tokenOwner: true,
+          },
         },
-      ];
+      ],
+    });
+
+    const properties: IProperty[] = [];
+
+    for (let i = 0; i < 65; i++) {
+      properties.push({key: `k${i}`, value: `v${i}`});
+    }
 
-      const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: properties,
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: properties,
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: properties,
+      },
+    ];
 
-      //await submitTransactionExpectFailAsync(alice, tx);
-      await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
-    });
+    await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith('Verification Error');
   });
 
-  it('can initialize multiple NFT with different owners', async () => {
-    const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      const data = [
+  itSub('Trying to add bigger property than allowed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'name',
+      description: 'descr',
+      tokenPrefix: 'COL',
+      tokenPropertyPermissions: [
         {
-          owner: {substrate: alice.address},
-        }, {
-          owner: {substrate: bob.address},
-        }, {
-          owner: {substrate: charlie.address},
+          key: 'k',
+          permission: {
+            mutable: true,
+            collectionAdmin: true,
+            tokenOwner: true,
+          },
         },
-      ];
-
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        NFT: data,
-      }));
-      const tokens = await api.query.nonfungible.tokenData.entries(collection);
-      const json = tokens.map(([, token]) => token.toJSON());
-      expect(json).to.be.deep.equal(data);
+      ],
     });
-  });
 
-  it('can initialize multiple NFT with different owners', async () => {
-    const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      const charlie = privateKeyWrapper('//Charlie');
-      const data = [
-        {
-          owner: {substrate: alice.address},
-        }, {
-          owner: {substrate: bob.address},
-        }, {
-          owner: {substrate: charlie.address},
-        },
-      ];
+    const args = [
+      {
+        owner: {Substrate: alice.address},
+        properties: [{key: 'k', value: 'A'.repeat(32769)}],
+      },
+      {
+        owner: {Substrate: bob.address},
+        properties: [{key: 'k', value: 'A'.repeat(32769)}],
+      },
+      {
+        owner: {Substrate: charlie.address},
+        properties: [{key: 'k', value: 'A'.repeat(32769)}],
+      },
+    ];
 
-      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
-        NFT: data,
-      }));
-      const tokens = await api.query.nonfungible.tokenData.entries(collection);
-      const json = tokens.map(([, token]) => token.toJSON());
-      expect(json).to.be.deep.equal(data);
-    });
+    await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith('Verification Error');
   });
 });

--- a/tests/src/creditFeesToTreasury.test.ts
+++ b/tests/src/creditFeesToTreasury.test.ts
@@ -15,32 +15,15 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import './interfaces/augment-api-consts';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
 import {IKeyringPair} from '@polkadot/types/types';
-import {
-  createCollectionExpectSuccess,
-  createItemExpectSuccess,
-  getGenericResult,
-  transferExpectSuccess,
-  UNIQUE,
-} from './util/helpers';
-
-import {default as waitNewBlocks} from './substrate/wait-new-blocks';
 import {ApiPromise} from '@polkadot/api';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
 
 const TREASURY = '5EYCAe5ijiYfyeZ2JJCGq56LmPyNRAKzpG4QkoQkkQNB5e6Z';
 const saneMinimumFee = 0.05;
 const saneMaximumFee = 0.5;
 const createCollectionDeposit = 100;
 
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-
 // Skip the inflation block pauses if the block is close to inflation block
 // until the inflation happens
 /*eslint no-async-promise-executor: "off"*/
@@ -62,129 +45,121 @@
 }
 
 describe('integration test: Fees must be credited to Treasury:', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('Total issuance does not change', async () => {
-    await usingApi(async (api) => {
-      await skipInflationBlock(api);
-      await waitNewBlocks(api, 1);
+  itSub('Total issuance does not change', async ({helper}) => {
+    const api = helper.api!;
+    await skipInflationBlock(api);
+    await helper.wait.newBlocks(1);
 
-      const totalBefore = (await api.query.balances.totalIssuance()).toBigInt();
+    const totalBefore = (await api.query.balances.totalIssuance()).toBigInt();
 
-      const amount = 1n;
-      const transfer = api.tx.balances.transfer(bob.address, amount);
+    await helper.balance.transferToSubstrate(alice, bob.address, 1n);
 
-      const result = getGenericResult(await submitTransactionAsync(alice, transfer));
+    const totalAfter = (await api.query.balances.totalIssuance()).toBigInt();
 
-      const totalAfter = (await api.query.balances.totalIssuance()).toBigInt();
+    expect(totalAfter).to.be.equal(totalBefore);
+  });
 
-      expect(result.success).to.be.true;
-      expect(totalAfter).to.be.equal(totalBefore);
-    });
-  });
+  itSub('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async ({helper}) => {
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
-  it('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async () => {
-    await usingApi(async (api) => {
-      await skipInflationBlock(api);
-      await waitNewBlocks(api, 1);
+    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
 
-      const treasuryBalanceBefore: bigint = (await api.query.system.account(TREASURY)).data.free.toBigInt();
-      const aliceBalanceBefore: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
+    const amount = 1n;
+    await helper.balance.transferToSubstrate(alice, bob.address, amount);
 
-      const amount = 1n;
-      const transfer = api.tx.balances.transfer(bob.address, amount);
-      const result = getGenericResult(await submitTransactionAsync(alice, transfer));
+    const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+    const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
 
-      const treasuryBalanceAfter: bigint = (await api.query.system.account(TREASURY)).data.free.toBigInt();
-      const aliceBalanceAfter: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
-      const fee = aliceBalanceBefore - aliceBalanceAfter - amount;
-      const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+    const fee = aliceBalanceBefore - aliceBalanceAfter - amount;
+    const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
 
-      expect(result.success).to.be.true;
-      expect(treasuryIncrease).to.be.equal(fee);
-    });
+    expect(treasuryIncrease).to.be.equal(fee);
   });
 
-  it('Treasury balance increased by failed tx fee', async () => {
-    await usingApi(async (api) => {
-      //await skipInflationBlock(api);
-      await waitNewBlocks(api, 1);
+  itSub('Treasury balance increased by failed tx fee', async ({helper}) => {
+    const api = helper.api!;
+    await helper.wait.newBlocks(1);
 
-      const treasuryBalanceBefore = (await api.query.system.account(TREASURY)).data.free.toBigInt();
-      const bobBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
+    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-      const badTx = api.tx.balances.setBalance(alice.address, 0, 0);
-      await expect(submitTransactionExpectFailAsync(bob, badTx)).to.be.rejected;
+    await expect(helper.signTransaction(bob, api.tx.balances.setBalance(alice.address, 0, 0))).to.be.rejected;
+
+    const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      const treasuryBalanceAfter = (await api.query.system.account(TREASURY)).data.free.toBigInt();
-      const bobBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-      const fee = bobBalanceBefore - bobBalanceAfter;
-      const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+    const fee = bobBalanceBefore - bobBalanceAfter;
+    const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
 
-      expect(treasuryIncrease).to.be.equal(fee);
-    });
+    expect(treasuryIncrease).to.be.equal(fee);
   });
 
-  it('NFT Transactions also send fees to Treasury', async () => {
-    await usingApi(async (api) => {
-      await skipInflationBlock(api);
-      await waitNewBlocks(api, 1);
+  itSub('NFT Transactions also send fees to Treasury', async ({helper}) => {
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
-      const treasuryBalanceBefore = (await api.query.system.account(TREASURY)).data.free.toBigInt();
-      const aliceBalanceBefore = (await api.query.system.account(alice.address)).data.free.toBigInt();
+    const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
 
-      await createCollectionExpectSuccess();
+    await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
 
-      const treasuryBalanceAfter = (await api.query.system.account(TREASURY)).data.free.toBigInt();
-      const aliceBalanceAfter = (await api.query.system.account(alice.address)).data.free.toBigInt();
-      const fee = aliceBalanceBefore - aliceBalanceAfter;
-      const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+    const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+    const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+    const fee = aliceBalanceBefore - aliceBalanceAfter;
+    const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
 
-      expect(treasuryIncrease).to.be.equal(fee);
-    });
+    expect(treasuryIncrease).to.be.equal(fee);
   });
 
-  it('Fees are sane', async () => {
-    await usingApi(async (api) => {
-      await skipInflationBlock(api);
-      await waitNewBlocks(api, 1);
+  itSub('Fees are sane', async ({helper}) => {
+    const unique = helper.balance.getOneTokenNominal();
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
-      const aliceBalanceBefore: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
+    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
 
-      await createCollectionExpectSuccess();
+    await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
 
-      const aliceBalanceAfter: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
-      const fee = aliceBalanceBefore - aliceBalanceAfter;
+    const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+    const fee = aliceBalanceBefore - aliceBalanceAfter;
 
-      expect(fee / UNIQUE < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
-      expect(fee / UNIQUE < BigInt(Math.ceil(saneMinimumFee  + createCollectionDeposit))).to.be.true;
-    });
+    expect(fee / unique < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
+    expect(fee / unique < BigInt(Math.ceil(saneMinimumFee  + createCollectionDeposit))).to.be.true;
   });
 
-  it('NFT Transfer fee is close to 0.1 Unique', async () => {
-    await usingApi(async (api) => {
-      await skipInflationBlock(api);
-      await waitNewBlocks(api, 1);
+  itSub('NFT Transfer fee is close to 0.1 Unique', async ({helper}) => {
+    await skipInflationBlock(helper.api!);
+    await helper.wait.newBlocks(1);
 
-      const collectionId = await createCollectionExpectSuccess();
-      const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+    });
+    // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
+    const token = await collection.mintToken(alice, {Substrate: alice.address});
 
-      const aliceBalanceBefore: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
-      await transferExpectSuccess(collectionId, tokenId, alice, bob, 1, 'NFT');
-      const aliceBalanceAfter: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
+    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
+    await token.transfer(alice, {Substrate: bob.address});
+    const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
 
-      const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(UNIQUE);
-      const expectedTransferFee = 0.1;
-      // fee drifts because of NextFeeMultiplier
-      const tolerance = 0.001;
+    const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(helper.balance.getOneTokenNominal());
+    const expectedTransferFee = 0.1;
+    // fee drifts because of NextFeeMultiplier
+    const tolerance = 0.001;
 
-      expect(Math.abs(fee - expectedTransferFee)).to.be.lessThan(tolerance);
-    });
+    expect(Math.abs(fee - expectedTransferFee)).to.be.lessThan(tolerance);
   });
-
 });

--- a/tests/src/destroyCollection.test.ts
+++ b/tests/src/destroyCollection.test.ts
@@ -15,36 +15,44 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi} from './substrate/substrate-api';
-import {createCollectionExpectSuccess,
-  destroyCollectionExpectSuccess,
-  destroyCollectionExpectFailure,
-  setCollectionLimitsExpectSuccess,
-  addCollectionAdminExpectSuccess,
-  getCreatedCollectionCount,
-  createItemExpectSuccess,
-  requirePallets,
-  Pallets,
-} from './util/helpers';
+import {itSub, expect, usingPlaygrounds, Pallets} from './util/playgrounds';
 
-chai.use(chaiAsPromised);
-
 describe('integration test: ext. destroyCollection():', () => {
-  it('NFT collection can be destroyed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await destroyCollectionExpectSuccess(collectionId);
-  });
-  it('Fungible collection can be destroyed', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await destroyCollectionExpectSuccess(collectionId);
+  let alice: IKeyringPair;
+
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([100n], donor);
+    });
   });
-  it('ReFungible collection can be destroyed', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await destroyCollectionExpectSuccess(collectionId);
+  itSub('NFT collection can be destroyed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+    });
+    await collection.burn(alice);
+    expect(await collection.getData()).to.be.null;
+  });
+  itSub('Fungible collection can be destroyed', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+    }, 0);
+    await collection.burn(alice);
+    expect(await collection.getData()).to.be.null;
+  });
+  itSub.ifWithPallets('ReFungible collection can be destroyed', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+    });
+    await collection.burn(alice);
+    expect(await collection.getData()).to.be.null;
   });
 });
 
@@ -53,44 +61,60 @@
   let bob: IKeyringPair;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
     });
   });
 
-  it('(!negative test!) Destroy a collection that never existed', async () => {
-    await usingApi(async (api) => {
-      // Find the collection that never existed
-      const collectionId = await getCreatedCollectionCount(api) + 1;
-      await destroyCollectionExpectFailure(collectionId);
+  itSub('(!negative test!) Destroy a collection that never existed', async ({helper}) => {
+    const collectionId = 1_000_000;
+    await expect(helper.collection.burn(alice, collectionId)).to.be.rejectedWith(/common\.CollectionNotFound/);
+  });
+  itSub('(!negative test!) Destroy a collection that has already been destroyed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
     });
-  });
-  it('(!negative test!) Destroy a collection that has already been destroyed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await destroyCollectionExpectSuccess(collectionId);
-    await destroyCollectionExpectFailure(collectionId);
+    await collection.burn(alice);
+    await expect(collection.burn(alice)).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
-  it('(!negative test!) Destroy a collection using non-owner account', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await destroyCollectionExpectFailure(collectionId, '//Bob');
-    await destroyCollectionExpectSuccess(collectionId, '//Alice');
+  itSub('(!negative test!) Destroy a collection using non-owner account', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+    });
+    await expect(collection.burn(bob)).to.be.rejectedWith(/common\.NoPermission/);
   });
-  it('(!negative test!) Destroy a collection using collection admin account', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-    await destroyCollectionExpectFailure(collectionId, '//Bob');
+  itSub('(!negative test!) Destroy a collection using collection admin account', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+    });
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await expect(collection.burn(bob)).to.be.rejectedWith(/common\.NoPermission/);
   });
-  it('fails when OwnerCanDestroy == false', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanDestroy: false});
-
-    await destroyCollectionExpectFailure(collectionId, '//Alice');
+  itSub('fails when OwnerCanDestroy == false', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+      limits: {
+        ownerCanDestroy: false,
+      },
+    });
+    await expect(collection.burn(alice)).to.be.rejectedWith(/common\.NoPermission/);
   });
-  it('fails when a collection still has a token', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await createItemExpectSuccess(alice, collectionId, 'NFT');
-
-    await destroyCollectionExpectFailure(collectionId, '//Alice');
+  itSub('fails when a collection still has a token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+    });
+    await collection.mintToken(alice, {Substrate: alice.address});
+    await expect(collection.burn(alice)).to.be.rejectedWith(/common\.CantDestroyNotEmptyCollection/);
   });
 });

--- a/tests/src/enableDisableTransfer.test.ts
+++ b/tests/src/enableDisableTransfer.test.ts
@@ -14,61 +14,69 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import usingApi from './substrate/substrate-api';
-import {
-  createItemExpectSuccess,
-  createCollectionExpectSuccess,
-  transferExpectSuccess,
-  transferExpectFailure,
-  setTransferFlagExpectSuccess,
-  setTransferFlagExpectFailure,
-} from './util/helpers';
-
-chai.use(chaiAsPromised);
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
 describe('Enable/Disable Transfers', () => {
-  it('User can transfer token with enabled transfer flag', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      // nft
-      const nftCollectionId = await createCollectionExpectSuccess();
-      const newNftTokenId = await createItemExpectSuccess(alice, nftCollectionId, 'NFT');
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
-      // explicitely set transfer flag
-      await setTransferFlagExpectSuccess(alice, nftCollectionId, true);
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+    });
+  });
 
-      await transferExpectSuccess(nftCollectionId, newNftTokenId, alice, bob, 1);
+  itSub('User can transfer token with enabled transfer flag', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+      limits: {
+        transfersEnabled: true,
+      },
     });
+    const token = await collection.mintToken(alice, {Substrate: alice.address});
+    await token.transfer(alice, {Substrate: bob.address});
+    expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});
   });
 
-  it('User can\'n transfer token with disabled transfer flag', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const bob = privateKeyWrapper('//Bob');
-      // nft
-      const nftCollectionId = await createCollectionExpectSuccess();
-      const newNftTokenId = await createItemExpectSuccess(alice, nftCollectionId, 'NFT');
-
-      // explicitely set transfer flag
-      await setTransferFlagExpectSuccess(alice, nftCollectionId, false);
-
-      await transferExpectFailure(nftCollectionId, newNftTokenId, alice, bob, 1);
+  itSub('User can\'n transfer token with disabled transfer flag', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+      limits: {
+        transfersEnabled: false,
+      },
     });
+    const token = await collection.mintToken(alice, {Substrate: alice.address});
+    await expect(token.transfer(alice, {Substrate: bob.address})).to.be.rejectedWith(/common\.TransferNotAllowed/);
   });
 });
 
 describe('Negative Enable/Disable Transfers', () => {
-  it('Non-owner cannot change transfer flag', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const bob = privateKeyWrapper('//Bob');
-      // nft
-      const nftCollectionId = await createCollectionExpectSuccess();
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+    });
+  });
 
-      // Change transfer flag
-      await setTransferFlagExpectFailure(bob, nftCollectionId, false);
+  itSub('Non-owner cannot change transfer flag', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {
+      name: 'test',
+      description: 'test',
+      tokenPrefix: 'test',
+      limits: {
+        transfersEnabled: true,
+      },
     });
+
+    await expect(collection.setLimits(bob, {transfersEnabled: false})).to.be.rejectedWith(/common\.NoPermission/);
   });
 });

--- a/tests/src/nesting/properties.test.ts
+++ b/tests/src/nesting/properties.test.ts
@@ -666,7 +666,6 @@
           `on adding property #${i} by signer #${j}`,
         ).to.be.fulfilled;
       }
-
     }
 
     const properties = await nestedToken.getProperties(propertyKeys);

--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -124,7 +124,7 @@
     const token = await collection.mintToken(alice, 100n);
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
-    expect((await token.burn(alice, 99n)).success).to.be.true;
+    expect(await token.burn(alice, 99n)).to.be.true;
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);
   });
@@ -136,7 +136,7 @@
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
 
-    expect((await token.burn(alice, 100n)).success).to.be.true;
+    expect(await token.burn(alice, 100n)).to.be.true;
     expect(await collection.isTokenExists(token.tokenId)).to.be.false;
   });
 
@@ -152,17 +152,17 @@
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(40n);
     expect(await token.getBalance({Substrate: bob.address})).to.be.equal(60n);
 
-    expect((await token.burn(alice, 40n)).success).to.be.true;
+    expect(await token.burn(alice, 40n)).to.be.true;
 
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);
 
-    expect((await token.burn(bob, 59n)).success).to.be.true;
+    expect(await token.burn(bob, 59n)).to.be.true;
 
     expect(await token.getBalance({Substrate: bob.address})).to.be.equal(1n);
     expect(await collection.isTokenExists(token.tokenId)).to.be.true;
 
-    expect((await token.burn(bob, 1n)).success).to.be.true;
+    expect(await token.burn(bob, 1n)).to.be.true;
 
     expect(await collection.isTokenExists(token.tokenId)).to.be.false;
   });