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

--- a/tests/package.json
+++ b/tests/package.json
@@ -71,6 +71,7 @@
     "testRemoveFromContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromContractAllowList.test.ts",
     "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts",
     "testSetOffchainSchema": "mocha --timeout 9999999 -r ts-node/register ./**/setOffchainSchema.test.ts",
+    "testNextSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/nextSponsoring.test.ts",
     "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts",
     "testInflation": "mocha --timeout 9999999 -r ts-node/register ./**/inflation.test.ts",
     "testScheduler": "mocha --timeout 9999999 -r ts-node/register ./**/scheduler.test.ts",
@@ -97,7 +98,7 @@
   "dependencies": {
     "@polkadot/api": "9.2.2",
     "@polkadot/api-contract": "9.2.2",
-    "@polkadot/util-crypto": "10.1.1",
+    "@polkadot/util-crypto": "10.1.7",
     "bignumber.js": "^9.0.2",
     "chai-as-promised": "^7.1.1",
     "chai-like": "^1.1.1",

--- a/tests/src/addCollectionAdmin.test.ts
+++ b/tests/src/addCollectionAdmin.test.ts
@@ -15,121 +15,111 @@
 // 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';
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+describe('Integration Test addCollectionAdmin(collection_id, new_admin_id):', () => {
+  let donor: IKeyringPair;
 
-let donor: IKeyringPair;
-
-before(async () => {
-  await usingPlaygrounds(async (_, privateKeyWrapper) => {
-    donor = privateKeyWrapper('//Alice');
+  before(async () => {
+    await usingPlaygrounds(async (_, privateKeyWrapper) => {
+      donor = privateKeyWrapper('//Alice');
+    });
   });
-});
 
-describe('Integration Test addCollectionAdmin(collection_id, new_admin_id):', () => {
-  it('Add collection admin.', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);
-      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
+  itSub('Add collection admin.', async ({helper}) => {
+    const [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);
+    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
 
-      const collection = await helper.collection.getData(collectionId);
-      expect(collection!.normalizedOwner!).to.be.equal(alice.address);
+    const collection = await helper.collection.getData(collectionId);
+    expect(collection!.normalizedOwner!).to.be.equal(helper.address.normalizeSubstrate(alice.address));
 
-      await helper.nft.addAdmin(alice, collectionId, {Substrate: bob.address});
+    await helper.nft.addAdmin(alice, collectionId, {Substrate: bob.address});
 
-      const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);
-      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
-    });
+    const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);
+    expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
   });
 });
 
 describe('Negative Integration Test addCollectionAdmin(collection_id, new_admin_id):', () => {
-  it("Not owner can't add collection admin.", async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
-      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
+  let donor: IKeyringPair;
+
+  before(async () => {
+    await usingPlaygrounds(async (_, privateKeyWrapper) => {
+      donor = privateKeyWrapper('//Alice');
+    });
+  });
 
-      const collection = await helper.collection.getData(collectionId);
-      expect(collection?.normalizedOwner).to.be.equal(alice.address);
+  itSub("Not owner can't add collection admin.", async ({helper}) => {
+    const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
+    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
 
-      const changeAdminTxBob = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: bob.address});
-      const changeAdminTxCharlie = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: charlie.address});
-      await expect(changeAdminTxCharlie()).to.be.rejected;
-      await expect(changeAdminTxBob()).to.be.rejected;
+    const collection = await helper.collection.getData(collectionId);
+    expect(collection?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
+
+    const changeAdminTxBob = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: bob.address});
+    const changeAdminTxCharlie = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: charlie.address});
+    await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
+    await expect(changeAdminTxBob()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);
-      expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: charlie.address});
-      expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: bob.address});
-    });
+    const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);
+    expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: charlie.address});
+    expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: bob.address});
   });
 
-  it("Admin can't add collection admin.", async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
+  itSub("Admin can't add collection admin.", async ({helper}) => {
+    const [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
+    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
 
-      await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.addAdmin(alice, {Substrate: bob.address});
 
-      const adminListAfterAddAdmin = await collection.getAdmins();
-      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
+    const adminListAfterAddAdmin = await collection.getAdmins();
+    expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
 
-      const changeAdminTxCharlie = async () => collection.addAdmin(bob, {Substrate: charlie.address});
-      await expect(changeAdminTxCharlie()).to.be.rejected;
+    const changeAdminTxCharlie = async () => collection.addAdmin(bob, {Substrate: charlie.address});
+    await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
 
-      const adminListAfterAddNewAdmin = await collection.getAdmins();
-      expect(adminListAfterAddNewAdmin).to.be.deep.contains({Substrate: bob.address});
-      expect(adminListAfterAddNewAdmin).to.be.not.deep.contains({Substrate: charlie.address});
-    });
+    const adminListAfterAddNewAdmin = await collection.getAdmins();
+    expect(adminListAfterAddNewAdmin).to.be.deep.contains({Substrate: bob.address});
+    expect(adminListAfterAddNewAdmin).to.be.not.deep.contains({Substrate: charlie.address});
   });
 
-  it("Can't add collection admin of not existing collection.", async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
-      // tslint:disable-next-line: no-bitwise
-      const collectionId = (1 << 32) - 1;
+  itSub("Can't add collection admin of not existing collection.", async ({helper}) => {
+    const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
+    const collectionId = (1 << 32) - 1;
 
-      const addAdminTx = async () => helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
-      await expect(addAdminTx()).to.be.rejected;
+    const addAdminTx = async () => helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
+    await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
 
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
-    });
+    // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
+    await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
   });
 
-  it("Can't add an admin to a destroyed collection.", async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
+  itSub("Can't add an admin to a destroyed collection.", async ({helper}) => {
+    const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
+    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
 
-      await collection.burn(alice);
-      const addAdminTx = async () => collection.addAdmin(alice, {Substrate: bob.address});
-      await expect(addAdminTx()).to.be.rejected;
+    await collection.burn(alice);
+    const addAdminTx = async () => collection.addAdmin(alice, {Substrate: bob.address});
+    await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
 
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
-    });
+    // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
+    await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
   });
 
-  it('Add an admin to a collection that has reached the maximum number of admins limit', async () => {
-    await usingPlaygrounds(async (helper) => {
-      const [alice, ...accounts] = await helper.arrange.createAccounts([10n, 0n, 0n, 0n, 0n, 0n, 0n, 0n], donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
+  itSub('Add an admin to a collection that has reached the maximum number of admins limit', async ({helper}) => {
+    const [alice, ...accounts] = await helper.arrange.createAccounts([10n, 0n, 0n, 0n, 0n, 0n, 0n, 0n], donor);
+    const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
 
-      const chainAdminLimit = (helper.api!.consts.common.collectionAdminsLimit as any).toNumber();
-      expect(chainAdminLimit).to.be.equal(5);
+    const chainAdminLimit = (helper.api!.consts.common.collectionAdminsLimit as any).toNumber();
+    expect(chainAdminLimit).to.be.equal(5);
 
-      for (let i = 0; i < chainAdminLimit; i++) {
-        await collection.addAdmin(alice, {Substrate: accounts[i].address});
-        const adminListAfterAddAdmin = await collection.getAdmins();
-        expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: accounts[i].address});
-      }
+    for (let i = 0; i < chainAdminLimit; i++) {
+      await collection.addAdmin(alice, {Substrate: accounts[i].address});
+      const adminListAfterAddAdmin = await collection.getAdmins();
+      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: accounts[i].address});
+    }
 
-      const addExtraAdminTx = async () => collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address});
-      await expect(addExtraAdminTx()).to.be.rejected;
-    });
+    const addExtraAdminTx = async () => collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address});
+    await expect(addExtraAdminTx()).to.be.rejectedWith(/common\.CollectionAdminCountExceeded/);
   });
 });

--- a/tests/src/eth/contractSponsoring.test.ts
+++ b/tests/src/eth/contractSponsoring.test.ts
@@ -15,7 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {expect} from 'chai';
-import { expectSubstrateEventsAtBlock } from '../util/helpers';
+import {expectSubstrateEventsAtBlock} from '../util/helpers';
 import {
   contractHelpers,
   createEthAccountWithBalance,

--- a/tests/src/eth/nesting/nest.test.ts
+++ b/tests/src/eth/nesting/nest.test.ts
@@ -20,7 +20,7 @@
   let donor: IKeyringPair;
 
   before(async function() {
-    await usingEthPlaygrounds(async (helper, privateKey) => {
+    await usingEthPlaygrounds(async (_, privateKey) => {
       donor = privateKey('//Alice');
     });
   });

--- a/tests/src/eth/payable.test.ts
+++ b/tests/src/eth/payable.test.ts
@@ -22,7 +22,7 @@
   let donor: IKeyringPair;
 
   before(async function() {
-    await usingEthPlaygrounds(async (helper, privateKey) => {
+    await usingEthPlaygrounds(async (_, privateKey) => {
       donor = privateKey('//Alice');
     });
   });

--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 /* eslint-disable function-call-argument-newline */
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="unique.dev.d.ts" />
 
 import {readFile} from 'fs/promises';
 

--- a/tests/src/fungible.test.ts
+++ b/tests/src/fungible.test.ts
@@ -16,14 +16,9 @@
 
 import {IKeyringPair} from '@polkadot/types/types';
 import {U128_MAX} from './util/helpers';
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
-import {usingPlaygrounds} from './util/playgrounds';
-
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
+// todo:playgrounds get rid of globals
 let alice: IKeyringPair;
 let bob: IKeyringPair;
 
@@ -35,131 +30,117 @@
     });
   });
 
-  it('Create fungible collection and token', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'trest'});
-      const defaultTokenId = await collection.getLastTokenId();
-      expect(defaultTokenId).to.be.equal(0);
+  itSub('Create fungible collection and token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'trest'});
+    const defaultTokenId = await collection.getLastTokenId();
+    expect(defaultTokenId).to.be.equal(0);
 
-      await collection.mint(alice, {Substrate: alice.address}, U128_MAX);
-      const aliceBalance = await collection.getBalance({Substrate: alice.address});
-      const itemCountAfter = await collection.getLastTokenId();
+    await collection.mint(alice, U128_MAX);
+    const aliceBalance = await collection.getBalance({Substrate: alice.address});
+    const itemCountAfter = await collection.getLastTokenId();
 
-      expect(itemCountAfter).to.be.equal(defaultTokenId);
-      expect(aliceBalance).to.be.equal(U128_MAX);
-    });
+    expect(itemCountAfter).to.be.equal(defaultTokenId);
+    expect(aliceBalance).to.be.equal(U128_MAX);
   });
   
-  it('RPC method tokenOnewrs for fungible collection and token', async () => {
-    await usingPlaygrounds(async (helper, privateKey) => {
-      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
-      const facelessCrowd = Array(7).fill(0).map((_, i) => ({Substrate: privateKey(`//Alice+${i}`).address}));
+  itSub('RPC method tokenOnewrs for fungible collection and token', async ({helper, privateKey}) => {
+    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
+    const facelessCrowd = Array(7).fill(0).map((_, i) => ({Substrate: privateKey(`//Alice+${i}`).address}));
 
-      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
 
-      await collection.mint(alice, {Substrate: alice.address}, U128_MAX);
+    await collection.mint(alice, U128_MAX);
 
-      await collection.transfer(alice, {Substrate: bob.address}, 1000n);
-      await collection.transfer(alice, ethAcc, 900n);
-      
-      for (let i = 0; i < 7; i++) {
-        await collection.transfer(alice, facelessCrowd[i], 1n);
-      } 
+    await collection.transfer(alice, {Substrate: bob.address}, 1000n);
+    await collection.transfer(alice, ethAcc, 900n);
+    
+    for (let i = 0; i < 7; i++) {
+      await collection.transfer(alice, facelessCrowd[i], 1n);
+    } 
 
-      const owners = await collection.getTop10Owners();
+    const owners = await collection.getTop10Owners();
 
-      // What to expect
-      expect(owners).to.deep.include.members([{Substrate: alice.address}, ethAcc, {Substrate: bob.address}, ...facelessCrowd]);
-      expect(owners.length).to.be.equal(10);
-      
-      const eleven = privateKey('//ALice+11');
-      expect(await collection.transfer(alice, {Substrate: eleven.address}, 10n)).to.be.true;
-      expect((await collection.getTop10Owners()).length).to.be.equal(10);
-    });
+    // What to expect
+    expect(owners).to.deep.include.members([{Substrate: alice.address}, ethAcc, {Substrate: bob.address}, ...facelessCrowd]);
+    expect(owners.length).to.be.equal(10);
+    
+    const eleven = privateKey('//ALice+11');
+    expect(await collection.transfer(alice, {Substrate: eleven.address}, 10n)).to.be.true;
+    expect((await collection.getTop10Owners()).length).to.be.equal(10);
   });
   
-  it('Transfer token', async () => {
-    await usingPlaygrounds(async helper => {
-      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
-      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      await collection.mint(alice, {Substrate: alice.address}, 500n);
+  itSub('Transfer token', async ({helper}) => {
+    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
+    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    await collection.mint(alice, 500n);
 
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
-      expect(await collection.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
-      expect(await collection.transfer(alice, ethAcc, 140n)).to.be.true;
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
+    expect(await collection.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
+    expect(await collection.transfer(alice, ethAcc, 140n)).to.be.true;
 
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(300n);
-      expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(60n);
-      expect(await collection.getBalance(ethAcc)).to.be.equal(140n);
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(300n);
+    expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(60n);
+    expect(await collection.getBalance(ethAcc)).to.be.equal(140n);
 
-      await expect(collection.transfer(alice, {Substrate: bob.address}, 350n)).to.eventually.be.rejected;
-    });
+    await expect(collection.transfer(alice, {Substrate: bob.address}, 350n)).to.eventually.be.rejected;
   });
 
-  it('Tokens multiple creation', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+  itSub('Tokens multiple creation', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
 
-      await collection.mintWithOneOwner(alice, {Substrate: alice.address}, [
-        {value: 500n},
-        {value: 400n},
-        {value: 300n},
-      ]);
+    await collection.mintWithOneOwner(alice, [
+      {value: 500n},
+      {value: 400n},
+      {value: 300n},
+    ]);
 
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1200n);
-    });
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1200n);
   });
 
-  it('Burn some tokens ', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      await collection.mint(alice, {Substrate: alice.address}, 500n);
+  itSub('Burn some tokens ', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    await collection.mint(alice, 500n);
 
-      expect(await collection.isTokenExists(0)).to.be.true;
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
-      expect(await collection.burnTokens(alice, 499n)).to.be.true;
-      expect(await collection.isTokenExists(0)).to.be.true;
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1n);
-    });
+    expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
+    expect(await collection.burnTokens(alice, 499n)).to.be.true;
+    expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1n);
   });
   
-  it('Burn all tokens ', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      await collection.mint(alice, {Substrate: alice.address}, 500n);
+  itSub('Burn all tokens ', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    await collection.mint(alice, 500n);
 
-      expect(await collection.isTokenExists(0)).to.be.true;
-      expect(await collection.burnTokens(alice, 500n)).to.be.true;
-      expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.burnTokens(alice, 500n)).to.be.true;
+    expect(await collection.isTokenExists(0)).to.be.true;
 
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(0n);
-      expect(await collection.getTotalPieces()).to.be.equal(0n);
-    });
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(0n);
+    expect(await collection.getTotalPieces()).to.be.equal(0n);
   });
 
-  it('Set allowance for token', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
-      await collection.mint(alice, {Substrate: alice.address}, 100n);
+  itSub('Set allowance for token', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
+    await collection.mint(alice, 100n);
 
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(100n);
-      
-      expect(await collection.approveTokens(alice, {Substrate: bob.address}, 60n)).to.be.true;
-      expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(60n);
-      expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(0n);
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(100n);
+    
+    expect(await collection.approveTokens(alice, {Substrate: bob.address}, 60n)).to.be.true;
+    expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(60n);
+    expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(0n);
 
-      expect(await collection.transferFrom(bob, {Substrate: alice.address}, {Substrate: bob.address}, 20n)).to.be.true;
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(80n);
-      expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(20n);
-      expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(40n);
+    expect(await collection.transferFrom(bob, {Substrate: alice.address}, {Substrate: bob.address}, 20n)).to.be.true;
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(80n);
+    expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(20n);
+    expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(40n);
 
-      await collection.burnTokensFrom(bob, {Substrate: alice.address}, 10n);
+    await collection.burnTokensFrom(bob, {Substrate: alice.address}, 10n);
 
-      expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(70n);
-      expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(30n);
-      expect(await collection.transferFrom(bob, {Substrate: alice.address}, ethAcc, 10n)).to.be.true;
-      expect(await collection.getBalance(ethAcc)).to.be.equal(10n);
-    });
+    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(70n);
+    expect(await collection.getApprovedTokens({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(30n);
+    expect(await collection.transferFrom(bob, {Substrate: alice.address}, ethAcc, 10n)).to.be.true;
+    expect(await collection.getBalance(ethAcc)).to.be.equal(10n);
   });
 });

--- a/tests/src/limits.test.ts
+++ b/tests/src/limits.test.ts
@@ -15,54 +15,41 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import usingApi from './substrate/substrate-api';
-import {
-  createCollectionExpectSuccess,
-  destroyCollectionExpectSuccess,
-  setCollectionLimitsExpectSuccess,
-  setCollectionSponsorExpectSuccess,
-  confirmSponsorshipExpectSuccess,
-  createItemExpectSuccess,
-  createItemExpectFailure,
-  transferExpectSuccess,
-  getFreeBalance,
-  waitNewBlocks, burnItemExpectSuccess,
-  requirePallets,
-  Pallets,
-} from './util/helpers';
-import {expect} from 'chai';
+import {expect, itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds} from './util/playgrounds';
 
 describe('Number of tokens per address (NFT)', () => {
   let alice: IKeyringPair;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([10n], donor);
     });
   });
 
-  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
-
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});
+  itSub.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 20});
+    
     for(let i = 0; i < 10; i++){
-      await createItemExpectSuccess(alice, collectionId, 'NFT');
+      await expect(collection.mintToken(alice)).to.be.not.rejected;
     }
-    await createItemExpectFailure(alice, collectionId, 'NFT');
+    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
     for(let i = 1; i < 11; i++) {
-      await burnItemExpectSuccess(alice, collectionId, i);
+      await expect(collection.burnToken(alice, i)).to.be.not.rejected;
     }
-    await destroyCollectionExpectSuccess(collectionId);
+    await collection.burn(alice);
   });
-
-  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
+  
+  itSub('Collection limits allow lower number than chain limits, collection limits are enforced', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 1});
 
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});
-    await createItemExpectSuccess(alice, collectionId, 'NFT');
-    await createItemExpectFailure(alice, collectionId, 'NFT');
-    await burnItemExpectSuccess(alice, collectionId, 1);
-    await destroyCollectionExpectSuccess(collectionId);
+    await collection.mintToken(alice);
+    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
+    
+    await collection.burnToken(alice, 1);
+    await expect(collection.burn(alice)).to.be.not.rejected;
   });
 });
 
@@ -70,38 +57,43 @@
   let alice: IKeyringPair;
 
   before(async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
 
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([10n], donor);
     });
   });
 
-  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 20});
+  itSub.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 20});
+    
     for(let i = 0; i < 10; i++){
-      await createItemExpectSuccess(alice, collectionId, 'ReFungible');
+      await expect(collection.mintToken(alice, 10n)).to.be.not.rejected;
     }
-    await createItemExpectFailure(alice, collectionId, 'ReFungible');
+    await expect(collection.mintToken(alice, 10n)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
     for(let i = 1; i < 11; i++) {
-      await burnItemExpectSuccess(alice, collectionId, i, 100);
+      await expect(collection.burnToken(alice, i, 10n)).to.be.not.rejected;
     }
-    await destroyCollectionExpectSuccess(collectionId);
+    await collection.burn(alice);
   });
 
-  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 1});
-    await createItemExpectSuccess(alice, collectionId, 'ReFungible');
-    await createItemExpectFailure(alice, collectionId, 'ReFungible');
-    await burnItemExpectSuccess(alice, collectionId, 1, 100);
-    await destroyCollectionExpectSuccess(collectionId);
+  itSub('Collection limits allow lower number than chain limits, collection limits are enforced', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 1});
+
+    await collection.mintToken(alice);
+    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
+    
+    await collection.burnToken(alice, 1);
+    await expect(collection.burn(alice)).to.be.not.rejected;
   });
 });
 
+// todo:playgrounds skipped ~ postponed
 describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {
-  let alice: IKeyringPair;
+  /*let alice: IKeyringPair;
   let bob: IKeyringPair;
   let charlie: IKeyringPair;
 
@@ -113,7 +105,7 @@
     });
   });
 
-  it.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
+  itSub.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
     await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
     const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
@@ -137,7 +129,7 @@
     await destroyCollectionExpectSuccess(collectionId);
   });
 
-  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
 
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
     await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
@@ -176,7 +168,7 @@
     });
   });
 
-  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
+  itSub('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
     await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
     const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');
@@ -202,7 +194,7 @@
     await destroyCollectionExpectSuccess(collectionId);
   });
 
-  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
 
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
     await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
@@ -243,7 +235,7 @@
     });
   });
 
-  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
+  itSub('Collection limits have greater timeout value than chain limits, collection limits are enforced', async ({helper}) => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
     await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
     const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');
@@ -267,7 +259,7 @@
     await destroyCollectionExpectSuccess(collectionId);
   });
 
-  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+  itSub('Collection limits have lower timeout value than chain limits, chain limits are enforced', async ({helper}) => {
 
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
     await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 1});
@@ -290,7 +282,7 @@
     expect(aliceBalanceAfterSponsoredTransaction < aliceBalanceBefore).to.be.true;
     //expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
     await destroyCollectionExpectSuccess(collectionId);
-  });
+  });*/
 });
 
 describe('Collection zero limits (NFT)', () => {
@@ -299,38 +291,38 @@
   let charlie: 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] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });
 
-  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});
+  itSub.skip('Limits have 0 in tokens per address field, the chain limits are applied', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 0});
+
     for(let i = 0; i < 10; i++){
-      await createItemExpectSuccess(alice, collectionId, 'NFT');
+      await collection.mintToken(alice);
     }
-    await createItemExpectFailure(alice, collectionId, 'NFT');
+    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
   });
 
-  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {});
+    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
+    const token = await collection.mintToken(alice);
 
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});
-    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
-    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
-    await transferExpectSuccess(collectionId, tokenId, alice, bob);
-    const aliceBalanceBefore = await getFreeBalance(alice);
+    await collection.setSponsor(alice, alice.address);
+    await collection.confirmSponsorship(alice);
+    
+    await token.transfer(alice, {Substrate: bob.address});
+    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
 
     // check setting SponsorTimeout = 0, success with next block
-    await waitNewBlocks(1);
-    await transferExpectSuccess(collectionId, tokenId, bob, charlie);
-    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);
+    await helper.wait.newBlocks(1);
+    await token.transfer(bob, {Substrate: charlie.address});
+    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
     expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
-    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
   });
 });
 
@@ -340,29 +332,28 @@
   let charlie: 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] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });
 
-  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});
-    const tokenId = await createItemExpectSuccess(alice, collectionId, 'Fungible');
-    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
-    await transferExpectSuccess(collectionId, tokenId, alice, bob, 10, 'Fungible');
-    const aliceBalanceBefore = await getFreeBalance(alice);
-    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');
+  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {});
+    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
+    await collection.mint(alice, 3n);
+
+    await collection.setSponsor(alice, alice.address);
+    await collection.confirmSponsorship(alice);
+    
+    await collection.transfer(alice, {Substrate: bob.address}, 2n);
+    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
 
     // check setting SponsorTimeout = 0, success with next block
-    await waitNewBlocks(1);
-    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 2, 'Fungible');
-    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);
+    await helper.wait.newBlocks(1);
+    await collection.transfer(bob, {Substrate: charlie.address});
+    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
     expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
-    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
   });
 });
 
@@ -372,110 +363,112 @@
   let charlie: IKeyringPair;
 
   before(async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
 
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      charlie = privateKeyWrapper('//Charlie');
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });
 
-  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {accountTokenOwnershipLimit: 0});
+  itSub.skip('Limits have 0 in tokens per address field, the chain limits are applied', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {});
+    await collection.setLimits(alice, {accountTokenOwnershipLimit: 0});
     for(let i = 0; i < 10; i++){
-      await createItemExpectSuccess(alice, collectionId, 'ReFungible');
+      await collection.mintToken(alice);
     }
-    await createItemExpectFailure(alice, collectionId, 'ReFungible');
+    await expect(collection.mintToken(alice)).to.be.rejectedWith(/common\.AccountTokenLimitExceeded/);
   });
 
-  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+  itSub('Limits have 0 in sponsor timeout, no limits are applied', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {});
+    await collection.setLimits(alice, {sponsorTransferTimeout: 0});
+    const token = await collection.mintToken(alice, 3n);
 
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 0});
-    const tokenId = await createItemExpectSuccess(alice, collectionId, 'ReFungible');
-    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
-    await transferExpectSuccess(collectionId, tokenId, alice, bob, 100, 'ReFungible');
-    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');
-    const aliceBalanceBefore = await getFreeBalance(alice);
+    await collection.setSponsor(alice, alice.address);
+    await collection.confirmSponsorship(alice);
+    
+    await token.transfer(alice, {Substrate: bob.address}, 2n);
+    const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
 
     // check setting SponsorTimeout = 0, success with next block
-    await waitNewBlocks(1);
-    await transferExpectSuccess(collectionId, tokenId, bob, charlie, 20, 'ReFungible');
-    const aliceBalanceAfterSponsoredTransaction1 = await getFreeBalance(alice);
+    await helper.wait.newBlocks(1);
+    await token.transfer(bob, {Substrate: charlie.address});
+    const aliceBalanceAfterSponsoredTransaction1 = await helper.balance.getSubstrate(alice.address);
     expect(aliceBalanceAfterSponsoredTransaction1 < aliceBalanceBefore).to.be.true;
-    //expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
   });
-  
-  it('Effective collection limits', async () => {
-    await usingApi(async (api) => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true});
-      
-      { // Check that limits is undefined
-        const collection = await api.rpc.unique.collectionById(collectionId);
-        expect(collection.isSome).to.be.true;
-        const limits = collection.unwrap().limits;
-        expect(limits).to.be.any;
-        
-        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.null;
-        expect(limits.sponsoredDataSize.toHuman()).to.be.null;
-        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.null;
-        expect(limits.tokenLimit.toHuman()).to.be.null;
-        expect(limits.sponsorTransferTimeout.toHuman()).to.be.null;
-        expect(limits.sponsorApproveTimeout.toHuman()).to.be.null;
-        expect(limits.ownerCanTransfer.toHuman()).to.be.true;
-        expect(limits.ownerCanDestroy.toHuman()).to.be.null;
-        expect(limits.transfersEnabled.toHuman()).to.be.null;
-      }
-  
-      { // Check that limits is undefined for non-existent collection
-        const limits = await api.rpc.unique.effectiveCollectionLimits(11111);
-        expect(limits.toHuman()).to.be.null;
-      }
-  
-      { // Check that default values defined for collection limits
-        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);
-        expect(limitsOpt.isNone).to.be.false;
-        const limits = limitsOpt.unwrap();
-  
-        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('100,000');
-        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('2,048');
-        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');
-        expect(limits.tokenLimit.toHuman()).to.be.eq('4,294,967,295');
-        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');
-        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');
-        expect(limits.ownerCanTransfer.toHuman()).to.be.true;
-        expect(limits.ownerCanDestroy.toHuman()).to.be.true;
-        expect(limits.transfersEnabled.toHuman()).to.be.true;
-      }
+});
 
-      { //Check the values for collection limits
-        await setCollectionLimitsExpectSuccess(alice, collectionId, {
-          accountTokenOwnershipLimit: 99_999,
-          sponsoredDataSize: 1024,
-          tokenLimit: 123,
-          transfersEnabled: false,
-        });
+describe('Effective collection limits (NFT)', () => {
+  let alice: IKeyringPair;
 
-        const limitsOpt = await api.rpc.unique.effectiveCollectionLimits(collectionId);
-        expect(limitsOpt.isNone).to.be.false;
-        const limits = limitsOpt.unwrap();
-  
-        expect(limits.accountTokenOwnershipLimit.toHuman()).to.be.eq('99,999');
-        expect(limits.sponsoredDataSize.toHuman()).to.be.eq('1,024');
-        expect(limits.sponsoredDataRateLimit.toHuman()).to.be.eq('SponsoringDisabled');
-        expect(limits.tokenLimit.toHuman()).to.be.eq('123');
-        expect(limits.sponsorTransferTimeout.toHuman()).to.be.eq('5');
-        expect(limits.sponsorApproveTimeout.toHuman()).to.be.eq('5');
-        expect(limits.ownerCanTransfer.toHuman()).to.be.true;
-        expect(limits.ownerCanDestroy.toHuman()).to.be.true;
-        expect(limits.transfersEnabled.toHuman()).to.be.false;
-      }
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([10n], donor);
     });
   });
-});
+  
+  itSub('Effective collection limits', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {});
+    await collection.setLimits(alice, {ownerCanTransfer: true});    
+    
+    { 
+      // Check that limits are undefined
+      const collectionInfo = await collection.getData();
+      const limits = collectionInfo?.raw.limits;
+      expect(limits).to.be.any;
+      
+      expect(limits.accountTokenOwnershipLimit).to.be.null;
+      expect(limits.sponsoredDataSize).to.be.null;
+      expect(limits.sponsoredDataRateLimit).to.be.null;
+      expect(limits.tokenLimit).to.be.null;
+      expect(limits.sponsorTransferTimeout).to.be.null;
+      expect(limits.sponsorApproveTimeout).to.be.null;
+      expect(limits.ownerCanTransfer).to.be.true;
+      expect(limits.ownerCanDestroy).to.be.null;
+      expect(limits.transfersEnabled).to.be.null;
+    }
+
+    { // Check that limits is undefined for non-existent collection
+      const limits = await helper.collection.getEffectiveLimits(999999);
+      expect(limits).to.be.null;
+    }
 
+    { // Check that default values defined for collection limits
+      const limits = await collection.getEffectiveLimits();
 
+      expect(limits.accountTokenOwnershipLimit).to.be.eq(100000);
+      expect(limits.sponsoredDataSize).to.be.eq(2048);
+      expect(limits.sponsoredDataRateLimit).to.be.deep.eq({sponsoringDisabled: null});
+      expect(limits.tokenLimit).to.be.eq(4294967295);
+      expect(limits.sponsorTransferTimeout).to.be.eq(5);
+      expect(limits.sponsorApproveTimeout).to.be.eq(5);
+      expect(limits.ownerCanTransfer).to.be.true;
+      expect(limits.ownerCanDestroy).to.be.true;
+      expect(limits.transfersEnabled).to.be.true;
+    }
+
+    { 
+      // Check the values for collection limits
+      await collection.setLimits(alice, {
+        accountTokenOwnershipLimit: 99_999,
+        sponsoredDataSize: 1024,
+        tokenLimit: 123,
+        transfersEnabled: false,
+      });
+
+      const limits = await collection.getEffectiveLimits();
+
+      expect(limits.accountTokenOwnershipLimit).to.be.eq(99999);
+      expect(limits.sponsoredDataSize).to.be.eq(1024);
+      expect(limits.sponsoredDataRateLimit).to.be.deep.eq({sponsoringDisabled: null});
+      expect(limits.tokenLimit).to.be.eq(123);
+      expect(limits.sponsorTransferTimeout).to.be.eq(5);
+      expect(limits.sponsorApproveTimeout).to.be.eq(5);
+      expect(limits.ownerCanTransfer).to.be.true;
+      expect(limits.ownerCanDestroy).to.be.true;
+      expect(limits.transfersEnabled).to.be.false;
+    }
+  });
+});

--- a/tests/src/nextSponsoring.test.ts
+++ b/tests/src/nextSponsoring.test.ts
@@ -14,100 +14,84 @@
 // 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} from './substrate/substrate-api';
-import {
-  createCollectionExpectSuccess,
-  setCollectionSponsorExpectSuccess,
-  confirmSponsorshipExpectSuccess,
-  createItemExpectSuccess,
-  transferExpectSuccess,
-  normalizeAccountId,
-  getNextSponsored,
-  requirePallets,
-  Pallets,
-} from './util/helpers';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {expect, itSub, Pallets, usingPlaygrounds} from './util/playgrounds';
 
+const SPONSORING_TIMEOUT = 5;
 
-
 describe('Integration Test getNextSponsored(collection_id, owner, item_id):', () => {
   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([20n, 10n], donor);
     });
   });
 
-  it('NFT', async () => {
-    await usingApi(async (api: ApiPromise) => {
+  itSub('NFT', async ({helper}) => {
+    // Non-existing collection
+    expect(await helper.collection.getTokenNextSponsored(0, 0, {Substrate: alice.address})).to.be.null;
 
-      // Not existing collection 
-      expect(await getNextSponsored(api, 0, normalizeAccountId(alice), 0)).to.be.equal(-1);
+    const collection = await helper.nft.mintCollection(alice, {});
+    const token = await collection.mintToken(alice);
 
-      const collectionId = await createCollectionExpectSuccess();
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);
+    // Check with Disabled sponsoring state
+    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.null;
+    
+    // Check with Unconfirmed sponsoring state
+    await collection.setSponsor(alice, bob.address);
+    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.null;
 
-      // Check with Disabled sponsoring state
-      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.equal(-1);
-      await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+    // Check with Confirmed sponsoring state
+    await collection.confirmSponsorship(bob);
+    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.equal(0);
 
-      // Check with Unconfirmed sponsoring state
-      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.equal(-1);
-      await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
+    // Check after transfer
+    await token.transfer(alice, {Substrate: bob.address});
+    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.lessThanOrEqual(SPONSORING_TIMEOUT);
 
-      // Check with Confirmed sponsoring state
-      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.equal(0);
+    // Non-existing token 
+    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.null;
+  });
 
-      // After transfer
-      await transferExpectSuccess(collectionId, itemId, alice, bob, 1);
-      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId)).to.be.lessThanOrEqual(5);
+  itSub('Fungible', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {});
+    await collection.mint(alice, 10n);
 
-      // Not existing token 
-      expect(await getNextSponsored(api, collectionId, normalizeAccountId(alice), itemId+1)).to.be.equal(-1);
-    });
-  });
+    // Check with Disabled sponsoring state
+    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.null;
 
-  it('Fungible', async () => {
-    await usingApi(async (api: ApiPromise) => {
-
-      const createMode = 'Fungible';
-      const funCollectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
-      await createItemExpectSuccess(alice, funCollectionId, createMode);
-      await setCollectionSponsorExpectSuccess(funCollectionId, bob.address);
-      await confirmSponsorshipExpectSuccess(funCollectionId, '//Bob');
-      expect(await getNextSponsored(api, funCollectionId, normalizeAccountId(alice), 0)).to.be.equal(0);
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    
+    // Check with Confirmed sponsoring state
+    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.equal(0);
 
-      await transferExpectSuccess(funCollectionId, 0, alice, bob, 10, 'Fungible');
-      expect(await getNextSponsored(api, funCollectionId, normalizeAccountId(alice), 0)).to.be.lessThanOrEqual(5);
-    });
+    // Check after transfer
+    await collection.transfer(alice, {Substrate: bob.address});
+    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.lessThanOrEqual(SPONSORING_TIMEOUT);
   });
 
-  it('ReFungible', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {});
+    const token = await collection.mintToken(alice, 10n);
 
-    await usingApi(async (api: ApiPromise) => {
+    // Check with Disabled sponsoring state
+    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.null;
 
-      const createMode = 'ReFungible';
-      const refunCollectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
-      const refunItemId = await createItemExpectSuccess(alice, refunCollectionId, createMode);
-      await setCollectionSponsorExpectSuccess(refunCollectionId, bob.address);
-      await confirmSponsorshipExpectSuccess(refunCollectionId, '//Bob');
-      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId)).to.be.equal(0);
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+
+    // Check with Confirmed sponsoring state
+    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.equal(0);
 
-      await transferExpectSuccess(refunCollectionId, refunItemId, alice, bob, 10, 'ReFungible');
-      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId)).to.be.lessThanOrEqual(5);
+    // Check after transfer
+    await token.transfer(alice, {Substrate: bob.address});
+    expect(await token.getNextSponsored({Substrate: alice.address})).to.be.lessThanOrEqual(SPONSORING_TIMEOUT);
 
-      // Not existing token 
-      expect(await getNextSponsored(api, refunCollectionId, normalizeAccountId(alice), refunItemId+1)).to.be.equal(-1);
-    });
+    // Non-existing token 
+    expect(await collection.getTokenNextSponsored(0, {Substrate: alice.address})).to.be.null;
   });
 });

--- a/tests/src/overflow.test.ts
+++ b/tests/src/overflow.test.ts
@@ -23,6 +23,7 @@
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
+// todo:playgrounds skipped ~ postponed
 describe.skip('Integration Test fungible overflows', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;

--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -14,13 +14,7 @@
 // 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 {expect} from 'chai';
-import usingApi from './substrate/substrate-api';
-
-function getModuleNames(api: ApiPromise): string[] {
-  return api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());
-}
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
 // Pallets that must always be present
 const requiredPallets = [
@@ -62,8 +56,8 @@
 
 describe('Pallet presence', () => {
   before(async () => {
-    await usingApi(async api => {
-      const chain = await api.rpc.system.chain();
+    await usingPlaygrounds(async helper => {
+      const chain = await helper.api!.rpc.system.chain();
 
       const refungible = 'refungible';
       const scheduler = 'scheduler';
@@ -80,23 +74,15 @@
     });
   });
 
-  it('Required pallets are present', async () => {
-    await usingApi(async api => {
-      for (let i=0; i<requiredPallets.length; i++) {
-        expect(getModuleNames(api)).to.include(requiredPallets[i]);
-      }
-    });
+  itSub('Required pallets are present', async ({helper}) => {
+    expect(helper.fetchAllPalletNames()).to.contain.members([...requiredPallets]);
   });
-  it('Governance and consensus pallets are present', async () => {
-    await usingApi(async api => {
-      for (let i=0; i<consensusPallets.length; i++) {
-        expect(getModuleNames(api)).to.include(consensusPallets[i]);
-      }
-    });
+
+  itSub('Governance and consensus pallets are present', async ({helper}) => {
+    expect(helper.fetchAllPalletNames()).to.contain.members([...consensusPallets]);
   });
-  it('No extra pallets are included', async () => {
-    await usingApi(async api => {
-      expect(getModuleNames(api).sort()).to.be.deep.equal([...requiredPallets, ...consensusPallets].sort());
-    });
+
+  itSub('No extra pallets are included', async ({helper}) => {
+    expect(helper.fetchAllPalletNames().sort()).to.be.deep.equal([...requiredPallets, ...consensusPallets].sort());
   });
 });

--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -15,18 +15,7 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-
-import {usingPlaygrounds} from './util/playgrounds';
-import {
-  getModuleNames,
-  Pallets,
-  requirePallets,
-} from './util/helpers';
-
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from './util/playgrounds';
 
 let alice: IKeyringPair;
 let bob: IKeyringPair;
@@ -34,255 +23,231 @@
 
 describe('integration test: Refungible functionality:', async () => {
   before(async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+    await usingPlaygrounds(async (helper, privateKey) => {
+      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
 
-    await usingPlaygrounds(async (helper, privateKey) => {
       alice = privateKey('//Alice');
       bob = privateKey('//Bob');
-      if (!getModuleNames(helper.api!).includes(Pallets.ReFungible)) this.skip();
     });
   });
   
-  it('Create refungible collection and token', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+  itSub('Create refungible collection and token', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
 
-      const itemCountBefore = await collection.getLastTokenId();
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
-      
-      const itemCountAfter = await collection.getLastTokenId();
-      
-      // What to expect
-      expect(token?.tokenId).to.be.gte(itemCountBefore);
-      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);
-      expect(itemCountAfter.toString()).to.be.equal(token?.tokenId.toString());
-    });
+    const itemCountBefore = await collection.getLastTokenId();
+    const token = await collection.mintToken(alice, 100n);
+    
+    const itemCountAfter = await collection.getLastTokenId();
+    
+    // What to expect
+    expect(token?.tokenId).to.be.gte(itemCountBefore);
+    expect(itemCountAfter).to.be.equal(itemCountBefore + 1);
+    expect(itemCountAfter.toString()).to.be.equal(token?.tokenId.toString());
   });
   
-  it('Checking RPC methods when interacting with maximum allowed values (MAX_REFUNGIBLE_PIECES)', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, MAX_REFUNGIBLE_PIECES);
-      
-      expect(await collection.getTokenBalance(token.tokenId, {Substrate: alice.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);
-      
-      await collection.transferToken(alice, token.tokenId, {Substrate: bob.address}, MAX_REFUNGIBLE_PIECES);
-      expect(await collection.getTokenBalance(token.tokenId, {Substrate: bob.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);
-      expect(await token.getTotalPieces()).to.be.equal(MAX_REFUNGIBLE_PIECES);
-      
-      await expect(collection.mintToken(alice, {Substrate: alice.address}, MAX_REFUNGIBLE_PIECES + 1n)).to.eventually.be.rejected;
-    });
+  itSub('Checking RPC methods when interacting with maximum allowed values (MAX_REFUNGIBLE_PIECES)', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    
+    const token = await collection.mintToken(alice, MAX_REFUNGIBLE_PIECES);
+    
+    expect(await collection.getTokenBalance(token.tokenId, {Substrate: alice.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);
+    
+    await collection.transferToken(alice, token.tokenId, {Substrate: bob.address}, MAX_REFUNGIBLE_PIECES);
+    expect(await collection.getTokenBalance(token.tokenId, {Substrate: bob.address})).to.be.equal(MAX_REFUNGIBLE_PIECES);
+    expect(await token.getTotalPieces()).to.be.equal(MAX_REFUNGIBLE_PIECES);
+    
+    await expect(collection.mintToken(alice, MAX_REFUNGIBLE_PIECES + 1n))
+      .to.eventually.be.rejectedWith(/refungible\.WrongRefungiblePieces/);
   });
   
-  it('RPC method tokenOnewrs for refungible collection and token', async () => {
-    await usingPlaygrounds(async (helper, privateKey) => {
-      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
-      const facelessCrowd = Array(7).fill(0).map((_, i) => ({Substrate: privateKey(`//Alice+${i}`).address}));
+  itSub('RPC method tokenOnewrs for refungible collection and token', async ({helper, privateKey}) => {
+    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
+    const facelessCrowd = Array(7).fill(0).map((_, i) => ({Substrate: privateKey(`//Alice+${i}`).address}));
 
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
 
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 10_000n);
+    const token = await collection.mintToken(alice, 10_000n);
 
-      await token.transfer(alice, {Substrate: bob.address}, 1000n);
-      await token.transfer(alice, ethAcc, 900n);
-      
-      for (let i = 0; i < 7; i++) {
-        await token.transfer(alice, facelessCrowd[i], 50n * BigInt(i + 1));
-      } 
+    await token.transfer(alice, {Substrate: bob.address}, 1000n);
+    await token.transfer(alice, ethAcc, 900n);
+    
+    for (let i = 0; i < 7; i++) {
+      await token.transfer(alice, facelessCrowd[i], 50n * BigInt(i + 1));
+    } 
 
-      const owners = await token.getTop10Owners();
+    const owners = await token.getTop10Owners();
 
-      // What to expect
-      expect(owners).to.deep.include.members([{Substrate: alice.address}, ethAcc, {Substrate: bob.address}, ...facelessCrowd]);
-      expect(owners.length).to.be.equal(10);
-      
-      const eleven = privateKey('//ALice+11');
-      expect(await token.transfer(alice, {Substrate: eleven.address}, 10n)).to.be.true;
-      expect((await token.getTop10Owners()).length).to.be.equal(10);
-    });
+    // What to expect
+    expect(owners).to.deep.include.members([{Substrate: alice.address}, ethAcc, {Substrate: bob.address}, ...facelessCrowd]);
+    expect(owners.length).to.be.equal(10);
+    
+    const eleven = privateKey('//ALice+11');
+    expect(await token.transfer(alice, {Substrate: eleven.address}, 10n)).to.be.true;
+    expect((await token.getTop10Owners()).length).to.be.equal(10);
   });
   
-  it('Transfer token pieces', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
+  itSub('Transfer token pieces', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const token = await collection.mintToken(alice, 100n);
 
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
-      expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
-      
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(40n);
-      expect(await token.getBalance({Substrate: bob.address})).to.be.equal(60n);
-      
-      await expect(token.transfer(alice, {Substrate: bob.address}, 41n)).to.eventually.be.rejected;
-    });
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
+    expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
+    
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(40n);
+    expect(await token.getBalance({Substrate: bob.address})).to.be.equal(60n);
+    
+    await expect(token.transfer(alice, {Substrate: bob.address}, 41n))
+      .to.eventually.be.rejectedWith(/common\.TokenValueTooLow/);
   });
 
-  it('Create multiple tokens', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      // TODO: fix mintMultipleTokens
-      // await collection.mintMultipleTokens(alice, [
-      //   {owner: {Substrate: alice.address}, pieces: 1n},
-      //   {owner: {Substrate: alice.address}, pieces: 2n},
-      //   {owner: {Substrate: alice.address}, pieces: 100n},
-      // ]);
-      await helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, [
-        {pieces: 1n}, 
-        {pieces: 2n}, 
-        {pieces: 100n},
-      ]);
-      const lastTokenId = await collection.getLastTokenId();
-      expect(lastTokenId).to.be.equal(3);
-      expect(await collection.getTokenBalance(lastTokenId, {Substrate: alice.address})).to.be.equal(100n);
-    });
+  itSub('Create multiple tokens', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    // TODO: fix mintMultipleTokens
+    // await collection.mintMultipleTokens(alice, [
+    //   {owner: {Substrate: alice.address}, pieces: 1n},
+    //   {owner: {Substrate: alice.address}, pieces: 2n},
+    //   {owner: {Substrate: alice.address}, pieces: 100n},
+    // ]);
+    await helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, [
+      {pieces: 1n}, 
+      {pieces: 2n}, 
+      {pieces: 100n},
+    ]);
+    const lastTokenId = await collection.getLastTokenId();
+    expect(lastTokenId).to.be.equal(3);
+    expect(await collection.getTokenBalance(lastTokenId, {Substrate: alice.address})).to.be.equal(100n);
   });
 
-  it('Burn some pieces', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 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 collection.isTokenExists(token.tokenId)).to.be.true;
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);
-    });
+  itSub('Burn some pieces', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    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 collection.isTokenExists(token.tokenId)).to.be.true;
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);
   });
 
-  it('Burn all pieces', async () => {
-    await usingPlaygrounds(async helper => {   
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
-      
-      expect(await collection.isTokenExists(token.tokenId)).to.be.true;
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
+  itSub('Burn all pieces', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    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, 100n)).success).to.be.true;
-      expect(await collection.isTokenExists(token.tokenId)).to.be.false;
-    });
+    expect((await token.burn(alice, 100n)).success).to.be.true;
+    expect(await collection.isTokenExists(token.tokenId)).to.be.false;
   });
 
-  it('Burn some pieces for multiple users', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
+  itSub('Burn some pieces for multiple users', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    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.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
+    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
+    
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
+    expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
 
-      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.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)).success).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 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)).success).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.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)).success).to.be.true;
 
-      expect(await collection.isTokenExists(token.tokenId)).to.be.false;
-    });
+    expect(await collection.isTokenExists(token.tokenId)).to.be.false;
   });
 
-  it('Set allowance for token', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
-      
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
+  itSub('Set allowance for token', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const token = await collection.mintToken(alice, 100n);
+    
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
 
-      expect(await token.approve(alice, {Substrate: bob.address}, 60n)).to.be.true;
-      expect(await token.getApprovedPieces({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(60n);
+    expect(await token.approve(alice, {Substrate: bob.address}, 60n)).to.be.true;
+    expect(await token.getApprovedPieces({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(60n);
 
-      expect(await token.transferFrom(bob, {Substrate: alice.address}, {Substrate: bob.address}, 20n)).to.be.true;
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(80n);
-      expect(await token.getBalance({Substrate: bob.address})).to.be.equal(20n);
-      expect(await token.getApprovedPieces({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(40n);
-    });
+    expect(await token.transferFrom(bob, {Substrate: alice.address}, {Substrate: bob.address}, 20n)).to.be.true;
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(80n);
+    expect(await token.getBalance({Substrate: bob.address})).to.be.equal(20n);
+    expect(await token.getApprovedPieces({Substrate: alice.address}, {Substrate: bob.address})).to.be.equal(40n);
   });
 
-  it('Repartition', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
+  itSub('Repartition', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const token = await collection.mintToken(alice, 100n);
 
-      expect(await token.repartition(alice, 200n)).to.be.true;
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(200n);
-      expect(await token.getTotalPieces()).to.be.equal(200n);
-      
-      expect(await token.transfer(alice, {Substrate: bob.address}, 110n)).to.be.true;
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(90n);
-      expect(await token.getBalance({Substrate: bob.address})).to.be.equal(110n);
-      
-      await expect(token.repartition(alice, 80n)).to.eventually.be.rejected;
-      
-      expect(await token.transfer(alice, {Substrate: bob.address}, 90n)).to.be.true;
-      expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);
-      expect(await token.getBalance({Substrate: bob.address})).to.be.equal(200n);
-
-      expect(await token.repartition(bob, 150n)).to.be.true;
-      await expect(token.transfer(bob, {Substrate: alice.address}, 160n)).to.eventually.be.rejected;
+    expect(await token.repartition(alice, 200n)).to.be.true;
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(200n);
+    expect(await token.getTotalPieces()).to.be.equal(200n);
+    
+    expect(await token.transfer(alice, {Substrate: bob.address}, 110n)).to.be.true;
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(90n);
+    expect(await token.getBalance({Substrate: bob.address})).to.be.equal(110n);
+    
+    await expect(token.repartition(alice, 80n))
+      .to.eventually.be.rejectedWith(/refungible\.RepartitionWhileNotOwningAllPieces/);
+    
+    expect(await token.transfer(alice, {Substrate: bob.address}, 90n)).to.be.true;
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);
+    expect(await token.getBalance({Substrate: bob.address})).to.be.equal(200n);
 
-    });
+    expect(await token.repartition(bob, 150n)).to.be.true;
+    await expect(token.transfer(bob, {Substrate: alice.address}, 160n))
+      .to.eventually.be.rejectedWith(/common\.TokenValueTooLow/);
   });
 
-  it('Repartition with increased amount', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
-      await token.repartition(alice, 200n);
-      const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
-      expect(chainEvents).to.include.deep.members([{
-        method: 'ItemCreated',
-        section: 'common',
-        index: '0x4202',
-        data: [ 
-          helper.api!.createType('u32', collection.collectionId).toHuman(), 
-          helper.api!.createType('u32', token.tokenId).toHuman(),
-          {Substrate: alice.address}, 
-          '100',
-        ],
-      }]);
-    });
+  itSub('Repartition with increased amount', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const token = await collection.mintToken(alice, 100n);
+    await token.repartition(alice, 200n);
+    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
+    expect(chainEvents).to.include.deep.members([{
+      method: 'ItemCreated',
+      section: 'common',
+      index: '0x4202',
+      data: [ 
+        helper.api!.createType('u32', collection.collectionId).toHuman(), 
+        helper.api!.createType('u32', token.tokenId).toHuman(),
+        {Substrate: alice.address}, 
+        '100',
+      ],
+    }]);
   });
 
-  it('Repartition with decreased amount', async () => {
-    await usingPlaygrounds(async helper => {
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      const token = await collection.mintToken(alice, {Substrate: alice.address}, 100n);
-      await token.repartition(alice, 50n);
-      const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
-      expect(chainEvents).to.include.deep.members([{
-        method: 'ItemDestroyed',
-        section: 'common',
-        index: '0x4203',
-        data: [ 
-          helper.api!.createType('u32', collection.collectionId).toHuman(), 
-          helper.api!.createType('u32', token.tokenId).toHuman(),
-          {Substrate: alice.address}, 
-          '50',
-        ],
-      }]);
-    });
+  itSub('Repartition with decreased amount', async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+    const token = await collection.mintToken(alice, 100n);
+    await token.repartition(alice, 50n);
+    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
+    expect(chainEvents).to.include.deep.members([{
+      method: 'ItemDestroyed',
+      section: 'common',
+      index: '0x4203',
+      data: [ 
+        helper.api!.createType('u32', collection.collectionId).toHuman(), 
+        helper.api!.createType('u32', token.tokenId).toHuman(),
+        {Substrate: alice.address}, 
+        '50',
+      ],
+    }]);
   });
   
-  it('Create new collection with properties', async () => {
-    await usingPlaygrounds(async helper => {
-      const properties = [{key: 'key1', value: 'val1'}];
-      const tokenPropertyPermissions = [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}];
-      const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test', properties, tokenPropertyPermissions});
-      const info = await collection.getData();
-      expect(info?.raw.properties).to.be.deep.equal(properties);
-      expect(info?.raw.tokenPropertyPermissions).to.be.deep.equal(tokenPropertyPermissions);
-    });
+  itSub('Create new collection with properties', async ({helper}) => {
+    const properties = [{key: 'key1', value: 'val1'}];
+    const tokenPropertyPermissions = [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}];
+    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test', properties, tokenPropertyPermissions});
+    const info = await collection.getData();
+    expect(info?.raw.properties).to.be.deep.equal(properties);
+    expect(info?.raw.tokenPropertyPermissions).to.be.deep.equal(tokenPropertyPermissions);
   });
 });
 

--- a/tests/src/removeCollectionAdmin.test.ts
+++ b/tests/src/removeCollectionAdmin.test.ts
@@ -14,115 +14,99 @@
 // 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 {usingPlaygrounds} from './util/playgrounds';
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+describe('Integration Test removeCollectionAdmin(collection_id, account_id):', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
-describe('Integration Test removeCollectionAdmin(collection_id, account_id):', () => {
-  it('Remove collection admin.', async () => {
+  before(async () => {
     await usingPlaygrounds(async (helper, privateKey) => {
-      const alice = privateKey('//Alice');
-      const bob = privateKey('//Bob');
-      const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      
-      const collectionInfo = await collection.getData();
-      expect(collectionInfo?.raw.owner.toString()).to.be.deep.eq(alice.address);
-      // first - add collection admin Bob
-      await collection.addAdmin(alice, {Substrate: bob.address});
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([20n, 10n], donor);
+    });
+  });
+
+  itSub('Remove collection admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionAdmin-1', tokenPrefix: 'RCA'});
+    const collectionInfo = await collection.getData();
+    expect(collectionInfo?.raw.owner.toString()).to.be.deep.eq(alice.address);
+    // first - add collection admin Bob
+    await collection.addAdmin(alice, {Substrate: bob.address});
 
-      const adminListAfterAddAdmin = await collection.getAdmins();
-      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: helper.address.normalizeSubstrate(bob.address)});
+    const adminListAfterAddAdmin = await collection.getAdmins();
+    expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
 
-      // then remove bob from admins of collection
-      await collection.removeAdmin(alice, {Substrate: bob.address});
+    // then remove bob from admins of collection
+    await collection.removeAdmin(alice, {Substrate: bob.address});
 
-      const adminListAfterRemoveAdmin = await collection.getAdmins();
-      expect(adminListAfterRemoveAdmin).not.to.be.deep.contains({Substrate: helper.address.normalizeSubstrate(bob.address)});
-    });
+    const adminListAfterRemoveAdmin = await collection.getAdmins();
+    expect(adminListAfterRemoveAdmin).not.to.be.deep.contains({Substrate: bob.address});
   });
 
-  it('Remove admin from collection that has no admins', async () => {
-    await usingPlaygrounds(async (helper, privateKey) => {
-      const alice = privateKey('//Alice');
-      const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+  itSub('Remove admin from collection that has no admins', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionAdmin-2', tokenPrefix: 'RCA'});
 
-      const adminListBeforeAddAdmin = await collection.getAdmins();
-      expect(adminListBeforeAddAdmin).to.have.lengthOf(0);
+    const adminListBeforeAddAdmin = await collection.getAdmins();
+    expect(adminListBeforeAddAdmin).to.have.lengthOf(0);
 
-      // await expect(collection.removeAdmin(alice, {Substrate: alice.address})).to.be.rejectedWith('Unable to remove collection admin');
-      await collection.removeAdmin(alice, {Substrate: alice.address});
-    });
+    await collection.removeAdmin(alice, {Substrate: alice.address});
   });
 });
 
 describe('Negative Integration Test removeCollectionAdmin(collection_id, account_id):', () => {
-  it('Can\'t remove collection admin from not existing collection', async () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+
+  before(async () => {
     await usingPlaygrounds(async (helper, privateKey) => {
-      // tslint:disable-next-line: no-bitwise
-      const collectionId = (1 << 32) - 1;
-      const alice = privateKey('//Alice');
-      const bob = privateKey('//Bob');
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([20n, 10n, 10n], donor);
+    });
+  });
 
-      await expect(helper.collection.removeAdmin(alice, collectionId, {Substrate: bob.address})).to.be.rejected;
+  itSub('Can\'t remove collection admin from not existing collection', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
 
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-    });
+    await expect(helper.collection.removeAdmin(alice, collectionId, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Can\'t remove collection admin from deleted collection', async () => {
-    await usingPlaygrounds(async (helper, privateKey) => {
-      const alice = privateKey('//Alice');
-      const bob = privateKey('//Bob');
-      const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+  itSub('Can\'t remove collection admin from deleted collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionAdmin-Neg-2', tokenPrefix: 'RCA'});
 
-      expect(await collection.burn(alice)).to.be.true;
+    expect(await collection.burn(alice)).to.be.true;
 
-      await expect(helper.collection.removeAdmin(alice, collection.collectionId, {Substrate: bob.address})).to.be.rejected;
-
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-    });
+    await expect(helper.collection.removeAdmin(alice, collection.collectionId, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Regular user can\'t remove collection admin', async () => {
-    await usingPlaygrounds(async (helper, privateKey) => {
-      const alice = privateKey('//Alice');
-      const bob = privateKey('//Bob');
-      const charlie = privateKey('//Charlie');
-      const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
+  itSub('Regular user can\'t remove collection admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionAdmin-Neg-3', tokenPrefix: 'RCA'});
 
-      await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.addAdmin(alice, {Substrate: bob.address});
 
-      await expect(collection.removeAdmin(charlie, {Substrate: bob.address})).to.be.rejected;
-
-      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
-      await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-    });
+    await expect(collection.removeAdmin(charlie, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Admin can\'t remove collection admin.', async () => {
-    await usingPlaygrounds(async (helper, privateKey) => {
-      const alice = privateKey('//Alice');
-      const bob = privateKey('//Bob');
-      const charlie = privateKey('//Charlie');
-      const collection = await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
-      
-      await collection.addAdmin(alice, {Substrate: bob.address});
-      await collection.addAdmin(alice, {Substrate: charlie.address});
+  itSub('Admin can\'t remove collection admin.', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionAdmin-Neg-4', tokenPrefix: 'RCA'});
+    
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.addAdmin(alice, {Substrate: charlie.address});
 
-      const adminListAfterAddAdmin = await collection.getAdmins();
-      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: helper.address.normalizeSubstrate(bob.address)});
-      expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: helper.address.normalizeSubstrate(charlie.address)});
+    const adminListAfterAddAdmin = await collection.getAdmins();
+    expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
+    expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: charlie.address});
 
-      await expect(collection.removeAdmin(charlie, {Substrate: bob.address})).to.be.rejected;
+    await expect(collection.removeAdmin(charlie, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.NoPermission/);
 
-      const adminListAfterRemoveAdmin = await collection.getAdmins();
-      expect(adminListAfterRemoveAdmin).to.be.deep.contains({Substrate: helper.address.normalizeSubstrate(bob.address)});
-      expect(adminListAfterRemoveAdmin).to.be.deep.contains({Substrate: helper.address.normalizeSubstrate(charlie.address)});
-    });
+    const adminListAfterRemoveAdmin = await collection.getAdmins();
+    expect(adminListAfterRemoveAdmin).to.be.deep.contains({Substrate: bob.address});
+    expect(adminListAfterRemoveAdmin).to.be.deep.contains({Substrate: charlie.address});
   });
 });

--- a/tests/src/removeCollectionSponsor.test.ts
+++ b/tests/src/removeCollectionSponsor.test.ts
@@ -14,138 +14,112 @@
 // 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, submitTransactionExpectFailAsync} from './substrate/substrate-api';
-import {
-  createCollectionExpectSuccess,
-  setCollectionSponsorExpectSuccess,
-  destroyCollectionExpectSuccess,
-  confirmSponsorshipExpectSuccess,
-  confirmSponsorshipExpectFailure,
-  createItemExpectSuccess,
-  findUnusedAddress,
-  removeCollectionSponsorExpectSuccess,
-  removeCollectionSponsorExpectFailure,
-  normalizeAccountId,
-  addCollectionAdminExpectSuccess,
-  getCreatedCollectionCount,
-} from './util/helpers';
 import {IKeyringPair} from '@polkadot/types/types';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-
 describe('integration test: ext. removeCollectionSponsor():', () => {
+  let donor: IKeyringPair;
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);
     });
   });
 
-  it('Removing NFT collection sponsor stops sponsorship', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-    await removeCollectionSponsorExpectSuccess(collectionId);
+  itSub('Removing NFT collection sponsor stops sponsorship', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-1', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.removeSponsor(alice);
 
-    await usingApi(async (api, privateKeyWrapper) => {
-      // Find unused address
-      const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
+    // Find unused address
+    const [zeroBalance] = await helper.arrange.createAccounts([0n], donor);
 
-      // Mint token for unused address
-      const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', zeroBalance.address);
+    // Mint token for unused address
+    const token = await collection.mintToken(alice, {Substrate: zeroBalance.address});
 
-      // Transfer this tokens from unused address to Alice - 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();
+    // Transfer this tokens from unused address to Alice - should fail
+    const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
+    await expect(token.transfer(zeroBalance, {Substrate: alice.address}))
+      .to.be.rejectedWith('Inability to pay some fees');
+    const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
-      expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
-    });
+    expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
   });
 
-  it('Remove a sponsor after it was already removed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-    await removeCollectionSponsorExpectSuccess(collectionId);
-    await removeCollectionSponsorExpectSuccess(collectionId);
+  itSub('Remove a sponsor after it was already removed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-2', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await expect(collection.removeSponsor(alice)).to.not.be.rejected;
+    await expect(collection.removeSponsor(alice)).to.not.be.rejected;
   });
 
-  it('Remove sponsor in a collection that never had the sponsor set', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await removeCollectionSponsorExpectSuccess(collectionId);
+  itSub('Remove sponsor in a collection that never had the sponsor set', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-3', tokenPrefix: 'RCS'});
+    await expect(collection.removeSponsor(alice)).to.not.be.rejected;
   });
 
-  it('Remove sponsor for a collection that had the sponsor set, but not confirmed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await removeCollectionSponsorExpectSuccess(collectionId);
+  itSub('Remove sponsor for a collection that had the sponsor set, but not confirmed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-4', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await expect(collection.removeSponsor(alice)).to.not.be.rejected;
   });
 
 });
 
 describe('(!negative test!) integration test: ext. removeCollectionSponsor():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: 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, charlie] = await helper.arrange.createAccounts([20n, 10n, 10n], donor);
     });
   });
 
-  it('(!negative test!) Remove sponsor 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 removeCollectionSponsorExpectFailure(collectionId);
+  itSub('(!negative test!) Remove sponsor for a collection that never existed', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
+    await expect(helper.collection.removeSponsor(alice, collectionId)).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('(!negative test!) Remove sponsor for a collection with collection admin permissions', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-    await removeCollectionSponsorExpectFailure(collectionId, '//Bob');
+  itSub('(!negative test!) Remove sponsor for a collection with collection admin permissions', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-Neg-1', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.addAdmin(alice, {Substrate: charlie.address});
+    await expect(collection.removeSponsor(charlie)).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('(!negative test!) Remove sponsor for a collection by regular user', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await removeCollectionSponsorExpectFailure(collectionId, '//Bob');
+  itSub('(!negative test!) Remove sponsor for a collection by regular user', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-Neg-2', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await expect(collection.removeSponsor(charlie)).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('(!negative test!) Remove sponsor in a destroyed collection', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await destroyCollectionExpectSuccess(collectionId);
-    await removeCollectionSponsorExpectFailure(collectionId);
+  itSub('(!negative test!) Remove sponsor in a destroyed collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-Neg-3', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.burn(alice);
+    await expect(collection.removeSponsor(alice)).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Set - remove - confirm: fails', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await removeCollectionSponsorExpectSuccess(collectionId);
-    await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+  itSub('Set - remove - confirm: fails', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-Neg-4', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.removeSponsor(alice);
+    await expect(collection.confirmSponsorship(bob)).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
-  it('Set - confirm - remove - confirm: Sponsor cannot come back', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-    await removeCollectionSponsorExpectSuccess(collectionId);
-    await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+  itSub('Set - confirm - remove - confirm: Sponsor cannot come back', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveCollectionSponsor-Neg-5', tokenPrefix: 'RCS'});
+    await collection.setSponsor(alice, bob.address);
+    await collection.confirmSponsorship(bob);
+    await collection.removeSponsor(alice);
+    await expect(collection.confirmSponsorship(bob)).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
-
 });

--- a/tests/src/removeFromAllowList.test.ts
+++ b/tests/src/removeFromAllowList.test.ts
@@ -14,58 +14,45 @@
 // 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} from './substrate/substrate-api';
-import {
-  createCollectionExpectSuccess,
-  destroyCollectionExpectSuccess,
-  enableAllowListExpectSuccess,
-  addToAllowListExpectSuccess,
-  removeFromAllowListExpectSuccess,
-  isAllowlisted,
-  findNotExistingCollection,
-  removeFromAllowListExpectFailure,
-  disableAllowListExpectSuccess,
-  normalizeAccountId,
-  addCollectionAdminExpectSuccess,
-} from './util/helpers';
 import {IKeyringPair} from '@polkadot/types/types';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
 describe('Integration Test removeFromAllowList', () => {
   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([10n, 10n], donor);
     });
   });
 
-  it('ensure bob is not in allowlist after removal', async () => {
-    await usingApi(async api => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
+  itSub('ensure bob is not in allowlist after removal', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveFromAllowList-1', tokenPrefix: 'RFAL'});
 
-      await removeFromAllowListExpectSuccess(alice, collectionId, normalizeAccountId(bob.address));
-      expect(await isAllowlisted(api, collectionId, bob.address)).to.be.false;
-    });
+    const collectionInfo = await collection.getData();
+    expect(collectionInfo!.raw.permissions.access).to.not.equal('AllowList');
+
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    expect(await collection.getAllowList()).to.deep.contains({Substrate: bob.address});
+    
+    await collection.removeFromAllowList(alice, {Substrate: bob.address});
+    expect(await collection.getAllowList()).to.be.empty;
   });
 
-  it('allows removal from collection with unset allowlist status', async () => {
-    await usingApi(async () => {
-      const collectionWithoutAllowlistId = await createCollectionExpectSuccess();
-      await enableAllowListExpectSuccess(alice, collectionWithoutAllowlistId);
-      await addToAllowListExpectSuccess(alice, collectionWithoutAllowlistId, bob.address);
-      await disableAllowListExpectSuccess(alice, collectionWithoutAllowlistId);
+  itSub('allows removal from collection with unset allowlist status', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveFromAllowList-2', tokenPrefix: 'RFAL'});
+
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    expect(await collection.getAllowList()).to.deep.contains({Substrate: bob.address});
 
-      await removeFromAllowListExpectSuccess(alice, collectionWithoutAllowlistId, normalizeAccountId(bob.address));
-    });
+    await collection.setPermissions(alice, {access: 'Normal'});
+    
+    await collection.removeFromAllowList(alice, {Substrate: bob.address});
+    expect(await collection.getAllowList()).to.be.empty;
   });
 });
 
@@ -74,29 +61,26 @@
   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([10n, 10n], donor);
     });
   });
 
-  it('fails on removal from not existing collection', async () => {
-    await usingApi(async (api) => {
-      const collectionId = await findNotExistingCollection(api);
-
-      await removeFromAllowListExpectFailure(alice, collectionId, normalizeAccountId(bob.address));
-    });
+  itSub('fails on removal from not existing collection', async ({helper}) => {
+    const nonExistentCollectionId = (1 << 32) - 1;
+    await expect(helper.collection.removeFromAllowList(alice, nonExistentCollectionId, {Substrate: alice.address}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('fails on removal from removed collection', async () => {
-    await usingApi(async () => {
-      const collectionId = await createCollectionExpectSuccess();
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
-      await destroyCollectionExpectSuccess(collectionId);
+  itSub('fails on removal from removed collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveFromAllowList-3', tokenPrefix: 'RFAL'});
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
 
-      await removeFromAllowListExpectFailure(alice, collectionId, normalizeAccountId(bob.address));
-    });
+    await collection.burn(alice);
+    await expect(collection.removeFromAllowList(alice, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 });
 
@@ -106,41 +90,45 @@
   let charlie: 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] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     });
   });
 
-  it('ensure address is not in allowlist after removal', async () => {
-    await usingApi(async api => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      await addToAllowListExpectSuccess(alice, collectionId, charlie.address);
-      await removeFromAllowListExpectSuccess(bob, collectionId, normalizeAccountId(charlie.address));
-      expect(await isAllowlisted(api, collectionId, charlie.address)).to.be.false;
-    });
+  itSub('ensure address is not in allowlist after removal', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveFromAllowList-4', tokenPrefix: 'RFAL'});
+    
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+
+    await collection.addToAllowList(bob, {Substrate: charlie.address});
+    await collection.removeFromAllowList(bob, {Substrate: charlie.address});
+
+    expect(await collection.getAllowList()).to.be.empty;
   });
 
-  it('Collection admin allowed to remove from allowlist with unset allowlist status', async () => {
-    await usingApi(async () => {
-      const collectionWithoutAllowlistId = await createCollectionExpectSuccess();
-      await enableAllowListExpectSuccess(alice, collectionWithoutAllowlistId);
-      await addCollectionAdminExpectSuccess(alice, collectionWithoutAllowlistId, bob.address);
-      await addToAllowListExpectSuccess(alice, collectionWithoutAllowlistId, charlie.address);
-      await disableAllowListExpectSuccess(alice, collectionWithoutAllowlistId);
-      await removeFromAllowListExpectSuccess(bob, collectionWithoutAllowlistId, normalizeAccountId(charlie.address));
-    });
+  itSub('Collection admin allowed to remove from allowlist with unset allowlist status', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveFromAllowList-5', tokenPrefix: 'RFAL'});
+
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, {Substrate: charlie.address});
+
+    await collection.setPermissions(bob, {access: 'Normal'});
+    await collection.removeFromAllowList(bob, {Substrate: charlie.address});
+
+    expect(await collection.getAllowList()).to.be.empty;
   });
 
-  it('Regular user can`t remove from allowlist', async () => {
-    await usingApi(async () => {
-      const collectionWithoutAllowlistId = await createCollectionExpectSuccess();
-      await enableAllowListExpectSuccess(alice, collectionWithoutAllowlistId);
-      await addToAllowListExpectSuccess(alice, collectionWithoutAllowlistId, charlie.address);
-      await removeFromAllowListExpectFailure(bob, collectionWithoutAllowlistId, normalizeAccountId(charlie.address));
-    });
+  itSub('Regular user can`t remove from allowlist', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'RemoveFromAllowList-6', tokenPrefix: 'RFAL'});
+
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: charlie.address});
+
+    await expect(collection.removeFromAllowList(bob, {Substrate: charlie.address}))
+      .to.be.rejectedWith(/common\.NoPermission/);
+    expect(await collection.getAllowList()).to.deep.contain({Substrate: charlie.address});
   });
 });

--- a/tests/src/removeFromContractAllowList.test.ts
+++ b/tests/src/removeFromContractAllowList.test.ts
@@ -20,6 +20,7 @@
 import {IKeyringPair} from '@polkadot/types/types';
 import {expect} from 'chai';
 
+// todo:playgrounds skipped again
 describe.skip('Integration Test removeFromContractAllowList', () => {
   let bob: IKeyringPair;
 

--- a/tests/src/rpc.test.ts
+++ b/tests/src/rpc.test.ts
@@ -1,57 +1,68 @@
-import {IKeyringPair} from '@polkadot/types/types';
-import {expect} from 'chai';
-import usingApi from './substrate/substrate-api';
-import {createCollection, createCollectionExpectSuccess, createFungibleItemExpectSuccess, CrossAccountId, getTokenOwner, normalizeAccountId, transfer, U128_MAX} from './util/helpers';
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
 
-let alice: IKeyringPair;
-let bob: IKeyringPair;
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
 
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// 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 {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, itSub, expect} from './util/playgrounds';
+import {crossAccountIdFromLower} from './util/playgrounds/unique';
+
 describe('integration test: RPC methods', () => {
+  let donor: IKeyringPair;
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([20n, 10n], donor);
     });
   });
 
-  
-  it('returns None for fungible collection', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-      await expect(getTokenOwner(api, collection, 0)).to.be.rejectedWith(/^owner == null$/);
-    });
+  itSub('returns None for fungible collection', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'RPC-1', tokenPrefix: 'RPC'});
+    const owner = (await helper.callRpc('api.rpc.unique.tokenOwner', [collection.collectionId, 0])).toJSON() as any;
+    expect(owner).to.be.null;
   });
   
-  it('RPC method tokenOwners for fungible collection and token', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
-      const facelessCrowd = Array.from(Array(7).keys()).map(i => normalizeAccountId(privateKeyWrapper(i.toString())));
-      
-      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'Fungible', decimalPoints: 0}});
-      const collectionId = createCollectionResult.collectionId;
-      const aliceTokenId = await createFungibleItemExpectSuccess(alice, collectionId, {Value: U128_MAX}, alice.address);
-     
-      await transfer(api, collectionId, aliceTokenId, alice, bob, 1000n);
-      await transfer(api, collectionId, aliceTokenId, alice, ethAcc, 900n);
-            
-      for (let i = 0; i < 7; i++) {
-        await transfer(api, collectionId, aliceTokenId, alice, facelessCrowd[i], 1);
-      } 
-      
-      const owners = await api.rpc.unique.tokenOwners(collectionId, aliceTokenId);
-      const ids = (owners.toJSON() as CrossAccountId[]).map(s => normalizeAccountId(s));
-      const aliceID = normalizeAccountId(alice);
-      const bobId = normalizeAccountId(bob);
+  itSub('RPC method tokenOwners for fungible collection and token', async ({helper}) => {
+    // Set-up a few token owners of all stripes
+    const ethAcc = {Ethereum: '0x67fb3503a61b284dc83fa96dceec4192db47dc7c'};
+    const facelessCrowd = (await helper.arrange.createAccounts([0n, 0n, 0n, 0n, 0n, 0n, 0n], donor))
+      .map(i => {return {Substrate: i.address};});
+    
+    const collection = await helper.ft.mintCollection(alice, {name: 'RPC-2', tokenPrefix: 'RPC'});
+    // mint some maximum (u128) amounts of tokens possible
+    await collection.mint(alice, (1n << 128n) - 1n);
+    
+    await collection.transfer(alice, {Substrate: bob.address}, 1000n);
+    await collection.transfer(alice, ethAcc, 900n);
+          
+    for (let i = 0; i < facelessCrowd.length; i++) {
+      await collection.transfer(alice, facelessCrowd[i], 1n);
+    }
+    // Set-up over
+
+    const owners = await helper.callRpc('api.rpc.unique.tokenOwners', [collection.collectionId, 0]);
+    const ids = (owners.toJSON() as any[]).map(crossAccountIdFromLower);
 
-      // What to expect
-      // tslint:disable-next-line:no-unused-expression
-      expect(ids).to.deep.include.members([aliceID, ethAcc, bobId, ...facelessCrowd]);
-      expect(owners.length == 10).to.be.true;
-      
-      const eleven = privateKeyWrapper('11');
-      expect(await transfer(api, collectionId, aliceTokenId, alice, eleven, 10n)).to.be.true;
-      expect((await api.rpc.unique.tokenOwners(collectionId, aliceTokenId)).length).to.be.equal(10);
-    });
+    expect(ids).to.deep.include.members([{Substrate: alice.address}, ethAcc, {Substrate: bob.address}, ...facelessCrowd]);
+    expect(owners.length == 10).to.be.true;
+    
+    // Make sure only 10 results are returned with this RPC
+    const [eleven] = await helper.arrange.createAccounts([0n], donor);
+    expect(await collection.transfer(alice, {Substrate: eleven.address}, 10n)).to.be.true;
+    expect((await helper.callRpc('api.rpc.unique.tokenOwners', [collection.collectionId, 0])).length).to.be.equal(10);
   });
 });
\ No newline at end of file

--- a/tests/src/scheduler.test.ts
+++ b/tests/src/scheduler.test.ts
@@ -44,6 +44,7 @@
 
 chai.use(chaiAsPromised);
 
+// todo:playgrounds skipped ~ postponed
 describe.skip('Scheduling token and balance transfers', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;

--- a/tests/src/setChainLimits.test.ts
+++ b/tests/src/setChainLimits.test.ts
@@ -23,6 +23,7 @@
   IChainLimits,
 } from './util/helpers';
 
+// todo:playgrounds skipped ~ postponed
 describe.skip('Negative Integration Test setChainLimits', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;

--- a/tests/src/setCollectionLimits.test.ts
+++ b/tests/src/setCollectionLimits.test.ts
@@ -15,26 +15,8 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 // https://unique-network.readthedocs.io/en/latest/jsapi.html#setchainlimits
-import {ApiPromise} from '@polkadot/api';
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import usingApi, {submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
-import {
-  createCollectionExpectSuccess, getCreatedCollectionCount,
-  getCreateItemResult,
-  setCollectionLimitsExpectFailure,
-  setCollectionLimitsExpectSuccess,
-  addCollectionAdminExpectSuccess,
-  queryCollectionExpectSuccess,
-} from './util/helpers';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let collectionIdForTesting: number;
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
 const accountTokenOwnershipLimit = 0;
 const sponsoredDataSize = 0;
@@ -42,197 +24,177 @@
 const tokenLimit = 10;
 
 describe('setCollectionLimits positive', () => {
-  let tx;
-  before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
-    });
-  });
-  it('execute setCollectionLimits with predefined params ', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      tx = api.tx.unique.setCollectionLimits(
-        collectionIdForTesting,
-        {
-          accountTokenOwnershipLimit: accountTokenOwnershipLimit,
-          sponsoredDataSize: sponsoredDataSize,
-          tokenLimit: tokenLimit,
-          sponsorTransferTimeout,
-          ownerCanTransfer: true,
-          ownerCanDestroy: true,
-        },
-      );
-      const events = await submitTransactionAsync(alice, tx);
-      const result = getCreateItemResult(events);
-
-      // get collection limits defined previously
-      const collectionInfo = await queryCollectionExpectSuccess(api, collectionIdForTesting);
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
-      // tslint:disable-next-line:no-unused-expression
-      expect(result.success).to.be.true;
-      expect(collectionInfo.limits.accountTokenOwnershipLimit.unwrap().toNumber()).to.be.equal(accountTokenOwnershipLimit);
-      expect(collectionInfo.limits.sponsoredDataSize.unwrap().toNumber()).to.be.equal(sponsoredDataSize);
-      expect(collectionInfo.limits.tokenLimit.unwrap().toNumber()).to.be.equal(tokenLimit);
-      expect(collectionInfo.limits.sponsorTransferTimeout.unwrap().toNumber()).to.be.equal(sponsorTransferTimeout);
-      expect(collectionInfo.limits.ownerCanTransfer.unwrap().toJSON()).to.be.true;
-      expect(collectionInfo.limits.ownerCanDestroy.unwrap().toJSON()).to.be.true;
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([20n, 10n], donor);
     });
   });
 
-  it('Set the same token limit twice', async () => {
-    await usingApi(async (api: ApiPromise) => {
+  itSub('execute setCollectionLimits with predefined params', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionLimits-1', tokenPrefix: 'SCL'});
 
-      const collectionLimits = {
-        accountTokenOwnershipLimit: accountTokenOwnershipLimit,
-        sponsoredMintSize: sponsoredDataSize,
-        tokenLimit: tokenLimit,
+    await collection.setLimits(
+      alice,
+      {
+        accountTokenOwnershipLimit,
+        sponsoredDataSize,
+        tokenLimit,
         sponsorTransferTimeout,
         ownerCanTransfer: true,
         ownerCanDestroy: true,
-      };
+      },
+    );
 
-      // The first time
-      const tx1 = api.tx.unique.setCollectionLimits(
-        collectionIdForTesting,
-        collectionLimits,
-      );
-      const events1 = await submitTransactionAsync(alice, tx1);
-      const result1 = getCreateItemResult(events1);
-      expect(result1.success).to.be.true;
-      const collectionInfo1 = await queryCollectionExpectSuccess(api, collectionIdForTesting);
-      expect(collectionInfo1.limits.tokenLimit.unwrap().toNumber()).to.be.equal(tokenLimit);
+    // get collection limits defined previously
+    const collectionInfo = await collection.getEffectiveLimits();
+
+    expect(collectionInfo.accountTokenOwnershipLimit).to.be.equal(accountTokenOwnershipLimit);
+    expect(collectionInfo.sponsoredDataSize).to.be.equal(sponsoredDataSize);
+    expect(collectionInfo.tokenLimit).to.be.equal(tokenLimit);
+    expect(collectionInfo.sponsorTransferTimeout).to.be.equal(sponsorTransferTimeout);
+    expect(collectionInfo.ownerCanTransfer).to.be.true;
+    expect(collectionInfo.ownerCanDestroy).to.be.true;
+  });
+
+  itSub('Set the same token limit twice', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionLimits-2', tokenPrefix: 'SCL'});
+
+    const collectionLimits = {
+      accountTokenOwnershipLimit,
+      sponsoredDataSize,
+      tokenLimit,
+      sponsorTransferTimeout,
+      ownerCanTransfer: true,
+      ownerCanDestroy: true,
+    };
+
+    await collection.setLimits(alice, collectionLimits);
+
+    const collectionInfo1 = await collection.getEffectiveLimits();
+      
+    expect(collectionInfo1.tokenLimit).to.be.equal(tokenLimit);
 
-      // The second time
-      const tx2 = api.tx.unique.setCollectionLimits(
-        collectionIdForTesting,
-        collectionLimits,
-      );
-      const events2 = await submitTransactionAsync(alice, tx2);
-      const result2 = getCreateItemResult(events2);
-      expect(result2.success).to.be.true;
-      const collectionInfo2 = await queryCollectionExpectSuccess(api, collectionIdForTesting);
-      expect(collectionInfo2.limits.tokenLimit.unwrap().toNumber()).to.be.equal(tokenLimit);
-    });
+    await collection.setLimits(alice, collectionLimits);
+    const collectionInfo2 = await collection.getEffectiveLimits();
+    expect(collectionInfo2.tokenLimit).to.be.equal(tokenLimit);
   });
 
-  it('execute setCollectionLimits from admin collection', async () => {
-    await addCollectionAdminExpectSuccess(alice, collectionIdForTesting, bob.address);
-    await usingApi(async (api: ApiPromise) => {
-      tx = api.tx.unique.setCollectionLimits(
-        collectionIdForTesting,
-        {
-          accountTokenOwnershipLimit,
-          sponsoredDataSize,
-          // sponsoredMintSize,
-          tokenLimit,
-        },
-      );
-      await expect(submitTransactionAsync(bob, tx)).to.be.not.rejected;
-    });
+  itSub('execute setCollectionLimits from admin collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionLimits-3', tokenPrefix: 'SCL'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+
+    const collectionLimits = {
+      accountTokenOwnershipLimit,
+      sponsoredDataSize,
+      // sponsoredMintSize,
+      tokenLimit,
+    };
+
+    await expect(collection.setLimits(alice, collectionLimits)).to.not.be.rejected;
   });
 });
 
 describe('setCollectionLimits negative', () => {
-  let tx;
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([20n, 10n], donor);
     });
   });
-  it('execute setCollectionLimits for not exists collection', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionCount = await getCreatedCollectionCount(api);
-      const nonExistedCollectionId = collectionCount + 1;
-      tx = api.tx.unique.setCollectionLimits(
-        nonExistedCollectionId,
-        {
-          accountTokenOwnershipLimit,
-          sponsoredDataSize,
-          // sponsoredMintSize,
-          tokenLimit,
-        },
-      );
-      await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
-    });
+  
+  itSub('execute setCollectionLimits for not exists collection', async ({helper}) => {
+    const nonExistentCollectionId = (1 << 32) - 1;
+    await expect(helper.collection.setLimits(
+      alice,
+      nonExistentCollectionId,
+      {
+        accountTokenOwnershipLimit,
+        sponsoredDataSize,
+        // sponsoredMintSize,
+        tokenLimit,
+      },
+    )).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
-  it('execute setCollectionLimits from user who is not owner of this collection', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      tx = api.tx.unique.setCollectionLimits(
-        collectionIdForTesting,
-        {
-          accountTokenOwnershipLimit,
-          sponsoredDataSize,
-          // sponsoredMintSize,
-          tokenLimit,
-        },
-      );
-      await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected;
-    });
+
+  itSub('execute setCollectionLimits from user who is not owner of this collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionLimits-Neg-1', tokenPrefix: 'SCL'});
+
+    await expect(collection.setLimits(bob, {
+      accountTokenOwnershipLimit,
+      sponsoredDataSize,
+      // sponsoredMintSize,
+      tokenLimit,
+    })).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('fails when trying to enable OwnerCanTransfer after it was disabled', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      accountTokenOwnershipLimit: accountTokenOwnershipLimit,
-      sponsoredMintSize: sponsoredDataSize,
-      tokenLimit: tokenLimit,
+  itSub('fails when trying to enable OwnerCanTransfer after it was disabled', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionLimits-Neg-2', tokenPrefix: 'SCL'});
+
+    await collection.setLimits(alice, {
+      accountTokenOwnershipLimit,
+      sponsoredDataSize,
+      tokenLimit,
       sponsorTransferTimeout,
       ownerCanTransfer: false,
       ownerCanDestroy: true,
     });
-    await setCollectionLimitsExpectFailure(alice, collectionId, {
-      accountTokenOwnershipLimit: accountTokenOwnershipLimit,
-      sponsoredMintSize: sponsoredDataSize,
-      tokenLimit: tokenLimit,
+
+    await expect(collection.setLimits(alice, {
+      accountTokenOwnershipLimit,
+      sponsoredDataSize,
+      tokenLimit,
       sponsorTransferTimeout,
       ownerCanTransfer: true,
       ownerCanDestroy: true,
-    });
+    })).to.be.rejectedWith(/common\.OwnerPermissionsCantBeReverted/);
   });
 
-  it('fails when trying to enable OwnerCanDestroy after it was disabled', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      accountTokenOwnershipLimit: accountTokenOwnershipLimit,
-      sponsoredMintSize: sponsoredDataSize,
-      tokenLimit: tokenLimit,
+  itSub('fails when trying to enable OwnerCanDestroy after it was disabled', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionLimits-Neg-3', tokenPrefix: 'SCL'});
+
+    await collection.setLimits(alice, {
+      accountTokenOwnershipLimit,
+      sponsoredDataSize,
+      tokenLimit,
       sponsorTransferTimeout,
       ownerCanTransfer: true,
       ownerCanDestroy: false,
     });
-    await setCollectionLimitsExpectFailure(alice, collectionId, {
+
+    await expect(collection.setLimits(alice, {
+      accountTokenOwnershipLimit,
+      sponsoredDataSize,
+      tokenLimit,
+      sponsorTransferTimeout,
+      ownerCanTransfer: true,
+      ownerCanDestroy: true,
+    })).to.be.rejectedWith(/common\.OwnerPermissionsCantBeReverted/);
+  });
+
+  itSub('Setting the higher token limit fails', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionLimits-Neg-4', tokenPrefix: 'SCL'});
+      
+    const collectionLimits = {
       accountTokenOwnershipLimit: accountTokenOwnershipLimit,
       sponsoredMintSize: sponsoredDataSize,
       tokenLimit: tokenLimit,
       sponsorTransferTimeout,
       ownerCanTransfer: true,
       ownerCanDestroy: true,
-    });
-  });
-
-  it('Setting the higher token limit fails', async () => {
-    await usingApi(async () => {
-
-      const collectionId = await createCollectionExpectSuccess();
-      const collectionLimits = {
-        accountTokenOwnershipLimit: accountTokenOwnershipLimit,
-        sponsoredMintSize: sponsoredDataSize,
-        tokenLimit: tokenLimit,
-        sponsorTransferTimeout,
-        ownerCanTransfer: true,
-        ownerCanDestroy: true,
-      };
+    };
 
-      // The first time
-      await setCollectionLimitsExpectSuccess(alice, collectionId, collectionLimits);
+    // The first time
+    await collection.setLimits(alice, collectionLimits);
 
-      // The second time - higher token limit
-      collectionLimits.tokenLimit += 1;
-      await setCollectionLimitsExpectFailure(alice, collectionId, collectionLimits);
-    });
+    // The second time - higher token limit
+    collectionLimits.tokenLimit += 1;
+    await expect(collection.setLimits(alice, collectionLimits)).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
-
 });

--- a/tests/src/setCollectionSponsor.test.ts
+++ b/tests/src/setCollectionSponsor.test.ts
@@ -14,93 +14,106 @@
 // 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} from './substrate/substrate-api';
-import {createCollectionExpectSuccess,
-  setCollectionSponsorExpectSuccess,
-  destroyCollectionExpectSuccess,
-  setCollectionSponsorExpectFailure,
-  addCollectionAdminExpectSuccess,
-  getCreatedCollectionCount,
-  requirePallets,
-  Pallets,
-} from './util/helpers';
 import {IKeyringPair} from '@polkadot/types/types';
-
-chai.use(chaiAsPromised);
-
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let charlie: IKeyringPair;
+import {itSub, usingPlaygrounds, expect, Pallets} from './util/playgrounds';
 
 describe('integration test: ext. setCollectionSponsor():', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: 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] = await helper.arrange.createAccounts([20n, 10n, 10n], donor);
     });
   });
 
-  it('Set NFT collection sponsor', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  itSub('Set NFT collection sponsor', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionSponsor-1-NFT', tokenPrefix: 'SCS'});
+    await expect(collection.setSponsor(alice, bob.address)).to.be.not.rejected;
+
+    expect((await collection.getData())?.raw.sponsorship).to.deep.equal({
+      Unconfirmed: bob.address,
+    });
   });
-  it('Set Fungible collection sponsor', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  
+  itSub('Set Fungible collection sponsor', async ({helper}) => {
+    const collection = await helper.ft.mintCollection(alice, {name: 'SetCollectionSponsor-1-FT', tokenPrefix: 'SCS'});
+    await expect(collection.setSponsor(alice, bob.address)).to.be.not.rejected;
+
+    expect((await collection.getData())?.raw.sponsorship).to.deep.equal({
+      Unconfirmed: bob.address,
+    });
   });
-  it('Set ReFungible collection sponsor', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  itSub.ifWithPallets('Set ReFungible collection sponsor', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice, {name: 'SetCollectionSponsor-1-RFT', tokenPrefix: 'SCS'});
+    await expect(collection.setSponsor(alice, bob.address)).to.be.not.rejected;
+
+    expect((await collection.getData())?.raw.sponsorship).to.deep.equal({
+      Unconfirmed: bob.address,
+    });
   });
 
-  it('Set the same sponsor repeatedly', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+  itSub('Set the same sponsor repeatedly', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionSponsor-2', tokenPrefix: 'SCS'});
+    await expect(collection.setSponsor(alice, bob.address)).to.be.not.rejected;
+    await expect(collection.setSponsor(alice, bob.address)).to.be.not.rejected;
+
+    expect((await collection.getData())?.raw.sponsorship).to.deep.equal({
+      Unconfirmed: bob.address,
+    });
   });
-  it('Replace collection sponsor', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-    await setCollectionSponsorExpectSuccess(collectionId, charlie.address);
+
+  itSub('Replace collection sponsor', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionSponsor-3', tokenPrefix: 'SCS'});
+    await expect(collection.setSponsor(alice, bob.address)).to.be.not.rejected;
+    await expect(collection.setSponsor(alice, charlie.address)).to.be.not.rejected;
+
+    expect((await collection.getData())?.raw.sponsorship).to.deep.equal({
+      Unconfirmed: charlie.address,
+    });
   });
-  it('Collection admin add sponsor', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-    await setCollectionSponsorExpectSuccess(collectionId, charlie.address, '//Bob');
+  
+  itSub('Collection admin add sponsor', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionSponsor-4', tokenPrefix: 'SCS'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await expect(collection.setSponsor(bob, charlie.address)).to.be.not.rejected;
+
+    expect((await collection.getData())?.raw.sponsorship).to.deep.equal({
+      Unconfirmed: charlie.address,
+    });
   });
 });
 
 describe('(!negative test!) integration test: ext. setCollectionSponsor():', () => {
+  let alice: IKeyringPair;
+  let bob: 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] = await helper.arrange.createAccounts([10n, 5n], donor);
     });
   });
 
-  it('(!negative test!) Add sponsor with a non-owner', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await setCollectionSponsorExpectFailure(collectionId, bob.address, '//Bob');
+  itSub('(!negative test!) Add sponsor with a non-owner', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionSponsor-Neg-1', tokenPrefix: 'SCS'});
+    await expect(collection.setSponsor(bob, bob.address))
+      .to.be.rejectedWith(/common\.NoPermission/);
   });
-  it('(!negative test!) Add sponsor to 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 setCollectionSponsorExpectFailure(collectionId, bob.address);
+  itSub('(!negative test!) Add sponsor to a collection that never existed', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
+    await expect(helper.collection.setSponsor(alice, collectionId, bob.address))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
-  it('(!negative test!) Add sponsor to a collection that was destroyed', async () => {
-    const collectionId = await createCollectionExpectSuccess();
-    await destroyCollectionExpectSuccess(collectionId);
-    await setCollectionSponsorExpectFailure(collectionId, bob.address);
+
+  itSub('(!negative test!) Add sponsor to a collection that was destroyed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetCollectionSponsor-Neg-2', tokenPrefix: 'SCS'});
+    await collection.burn(alice);
+    await expect(collection.setSponsor(alice, bob.address))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 });

--- a/tests/src/setContractSponsoringRateLimit.test.ts
+++ b/tests/src/setContractSponsoringRateLimit.test.ts
@@ -25,6 +25,7 @@
   setContractSponsoringRateLimitExpectSuccess,
 } from './util/helpers';
 
+// todo:playgrounds postponed skipped test
 describe.skip('Integration Test setContractSponsoringRateLimit', () => {
   it('ensure sponsored contract can\'t be called twice without pause for free', async () => {
     await usingApi(async (api, privateKeyWrapper) => {

--- a/tests/src/setMintPermission.test.ts
+++ b/tests/src/setMintPermission.test.ts
@@ -15,65 +15,57 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import usingApi from './substrate/substrate-api';
-import {
-  addToAllowListExpectSuccess,
-  createCollectionExpectSuccess,
-  createItemExpectFailure,
-  createItemExpectSuccess,
-  destroyCollectionExpectSuccess,
-  enableAllowListExpectSuccess,
-  findNotExistingCollection,
-  setMintPermissionExpectFailure,
-  setMintPermissionExpectSuccess,
-  addCollectionAdminExpectSuccess,
-} from './util/helpers';
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
 describe('Integration Test setMintPermission', () => {
   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([10n, 10n], donor);
     });
   });
 
-  it('ensure allow-listed non-privileged address can mint tokens', async () => {
-    await usingApi(async () => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await setMintPermissionExpectSuccess(alice, collectionId, true);
-      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
+  itSub('ensure allow-listed non-privileged address can mint tokens', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetMintPermission-1', description: '', tokenPrefix: 'SMP'});
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
 
-      await createItemExpectSuccess(bob, collectionId, 'NFT');
-    });
+    await expect(collection.mintToken(bob, {Substrate: bob.address})).to.not.be.rejected;
   });
 
-  it('can be enabled twice', async () => {
-    await usingApi(async () => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setMintPermissionExpectSuccess(alice, collectionId, true);
-      await setMintPermissionExpectSuccess(alice, collectionId, true);
-    });
+  itSub('can be enabled twice', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetMintPermission-2', description: '', tokenPrefix: 'SMP'});
+    expect((await collection.getData())?.raw.permissions.access).to.not.equal('AllowList');
+
+    await collection.setPermissions(alice, {mintMode: true});
+    await collection.setPermissions(alice, {mintMode: true});
+    expect((await collection.getData())?.raw.permissions.mintMode).to.be.true;
   });
 
-  it('can be disabled twice', async () => {
-    await usingApi(async () => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setMintPermissionExpectSuccess(alice, collectionId, true);
-      await setMintPermissionExpectSuccess(alice, collectionId, false);
-      await setMintPermissionExpectSuccess(alice, collectionId, false);
-    });
+  itSub('can be disabled twice', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetMintPermission-3', description: '', tokenPrefix: 'SMP'});
+    expect((await collection.getData())?.raw.permissions.access).to.equal('Normal');
+
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    expect((await collection.getData())?.raw.permissions.access).to.equal('AllowList');
+    expect((await collection.getData())?.raw.permissions.mintMode).to.equal(true);
+
+    await collection.setPermissions(alice, {access: 'Normal', mintMode: false});
+    await collection.setPermissions(alice, {access: 'Normal', mintMode: false});
+    expect((await collection.getData())?.raw.permissions.access).to.equal('Normal');
+    expect((await collection.getData())?.raw.permissions.mintMode).to.equal(false);
   });
 
-  it('Collection admin success on set', async () => {
-    await usingApi(async () => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      await setMintPermissionExpectSuccess(bob, collectionId, true);
-    });
+  itSub('Collection admin success on set', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetMintPermission-4', description: '', tokenPrefix: 'SMP'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.setPermissions(bob, {access: 'AllowList', mintMode: true});
+    
+    expect((await collection.getData())?.raw.permissions.access).to.equal('AllowList');
+    expect((await collection.getData())?.raw.permissions.mintMode).to.equal(true);
   });
 });
 
@@ -82,41 +74,38 @@
   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([10n, 10n], donor);
     });
   });
 
-  it('fails on not existing collection', async () => {
-    await usingApi(async (api) => {
-      const nonExistingCollection = await findNotExistingCollection(api);
-      await setMintPermissionExpectFailure(alice, nonExistingCollection, true);
-    });
+  itSub('fails on not existing collection', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
+    await expect(helper.collection.setPermissions(alice, collectionId, {mintMode: true}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('fails on removed collection', async () => {
-    await usingApi(async () => {
-      const removedCollectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await destroyCollectionExpectSuccess(removedCollectionId);
+  itSub('fails on removed collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetMintPermission-Neg-1', tokenPrefix: 'SMP'});
+    await collection.burn(alice);
 
-      await setMintPermissionExpectFailure(alice, removedCollectionId, true);
-    });
+    await expect(collection.setPermissions(alice, {mintMode: true}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('fails when not collection owner tries to set mint status', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await enableAllowListExpectSuccess(alice, collectionId);
-    await setMintPermissionExpectFailure(bob, collectionId, true);
+  itSub('fails when non-owner tries to set mint status', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetMintPermission-Neg-2', tokenPrefix: 'SMP'});
+
+    await expect(collection.setPermissions(bob, {mintMode: true}))
+      .to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('ensure non-allow-listed non-privileged address can\'t mint tokens', async () => {
-    await usingApi(async () => {
-      const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await setMintPermissionExpectSuccess(alice, collectionId, true);
+  itSub('ensure non-allow-listed non-privileged address can\'t mint tokens', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'SetMintPermission-Neg-3', tokenPrefix: 'SMP'});
+    await collection.setPermissions(alice, {mintMode: true});
 
-      await createItemExpectFailure(bob, collectionId, 'NFT');
-    });
+    await expect(collection.mintToken(bob, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
   });
 });

--- a/tests/src/setPublicAccessMode.test.ts
+++ b/tests/src/setPublicAccessMode.test.ts
@@ -15,111 +15,79 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 // https://unique-network.readthedocs.io/en/latest/jsapi.html#setschemaversion
-import {ApiPromise} from '@polkadot/api';
 import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import usingApi, {submitTransactionExpectFailAsync} from './substrate/substrate-api';
-import {
-  addToAllowListExpectSuccess,
-  createCollectionExpectSuccess,
-  createItemExpectSuccess,
-  destroyCollectionExpectSuccess,
-  enablePublicMintingExpectSuccess,
-  enableAllowListExpectSuccess,
-  normalizeAccountId,
-  addCollectionAdminExpectSuccess,
-  getCreatedCollectionCount,
-} from './util/helpers';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let alice: IKeyringPair;
-let bob: IKeyringPair;
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
 describe('Integration Test setPublicAccessMode(): ', () => {
+  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([10n, 10n], donor);
     });
   });
 
-  it('Run extrinsic with collection id parameters, set the allowlist mode for the collection', async () => {
-    await usingApi(async () => {
-      const collectionId: number = await createCollectionExpectSuccess();
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await enablePublicMintingExpectSuccess(alice, collectionId);
-      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
-      await createItemExpectSuccess(bob, collectionId, 'NFT', bob.address);
-    });
+  itSub('Runs extrinsic with collection id parameters, sets the allowlist mode for the collection', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'PublicAccess-1', tokenPrefix: 'TF'});
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    
+    await expect(collection.mintToken(bob, {Substrate: bob.address})).to.be.not.rejected;
+  });
+
+  itSub('Allowlisted collection limits', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'PublicAccess-2', tokenPrefix: 'TF'});
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    
+    await expect(collection.mintToken(bob, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
   });
 
-  it('Allowlisted collection limits', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      const collectionId = await createCollectionExpectSuccess();
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await enablePublicMintingExpectSuccess(alice, collectionId);
-      const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(bob.address), 'NFT');
-      await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected;
-    });
+  itSub('setPublicAccessMode by collection admin', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'PublicAccess-Neg-4', tokenPrefix: 'TF'});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+
+    await expect(collection.setPermissions(bob, {access: 'AllowList'})).to.be.not.rejected;
   });
 });
 
 describe('Negative Integration Test ext. setPublicAccessMode(): ', () => {
-  it('Set a non-existent collection', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      // tslint:disable-next-line: radix
-      const collectionId = await getCreatedCollectionCount(api) + 1;
-      const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: 'AllowList'});
-      await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([10n, 10n], donor);
     });
   });
 
-  it('Set the collection that has been deleted', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      // tslint:disable-next-line: no-bitwise
-      const collectionId = await createCollectionExpectSuccess();
-      await destroyCollectionExpectSuccess(collectionId);
-      const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: 'AllowList'});
-      await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
-    });
+  itSub('Sets a non-existent collection', async ({helper}) => {
+    const collectionId = (1 << 32) - 1;
+    await expect(helper.collection.setPermissions(alice, collectionId, {access: 'AllowList'}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('Re-set the list mode already set in quantity', async () => {
-    await usingApi(async () => {
-      const collectionId: number = await createCollectionExpectSuccess();
-      await enableAllowListExpectSuccess(alice, collectionId);
-      await enableAllowListExpectSuccess(alice, collectionId);
-    });
-  });
+  itSub('Sets the collection that has been deleted', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'PublicAccess-Neg-1', tokenPrefix: 'TF'});
+    await collection.burn(alice);
 
-  it('Execute method not on behalf of the collection owner', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      // tslint:disable-next-line: no-bitwise
-      const collectionId = await createCollectionExpectSuccess();
-      const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: 'AllowList'});
-      await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected;
-    });
+    await expect(collection.setPermissions(alice, {access: 'AllowList'}))
+      .to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
-  it('setPublicAccessMode by collection admin', async () => {
-    await usingApi(async (api: ApiPromise) => {
-      // tslint:disable-next-line: no-bitwise
-      const collectionId = await createCollectionExpectSuccess();
-      await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const tx = api.tx.unique.setCollectionPermissions(collectionId, {access: 'AllowList'});
-      await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.not.rejected;
-    });
+  itSub('Re-sets the list mode already set in quantity', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'PublicAccess-Neg-2', tokenPrefix: 'TF'});
+    await collection.setPermissions(alice, {access: 'AllowList'});
+    await collection.setPermissions(alice, {access: 'AllowList'});
   });
-});
 
-describe('Negative Integration Test ext. collection admin setPublicAccessMode(): ', () => {
-  before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-    });
+  itSub('Executes method as a malefactor', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {name: 'PublicAccess-Neg-3', tokenPrefix: 'TF'});
+
+    await expect(collection.setPermissions(bob, {access: 'AllowList'}))
+      .to.be.rejectedWith(/common\.NoPermission/);
   });
 });

--- a/tests/src/toggleContractAllowList.test.ts
+++ b/tests/src/toggleContractAllowList.test.ts
@@ -31,6 +31,7 @@
 const value = 0;
 const gasLimit = 3000n * 1000000n;
 
+// todo:playgrounds skipped ~ postpone
 describe.skip('Integration Test toggleContractAllowList', () => {
 
   it('Enable allow list contract mode', async () => {