git.delta.rocks / unique-network / refs/commits / 04cd15cc5d24

--- a/tests/src/eth/util/playgrounds/index.ts
+++ b/tests/src/eth/util/playgrounds/index.ts
@@ -12,7 +12,7 @@
 
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
-import { requirePalletsOrSkip } from '../../../util/playgrounds';
+import {requirePalletsOrSkip} from '../../../util/playgrounds';
 chai.use(chaiAsPromised);
 export const expect = chai.expect;
 

--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -240,7 +240,7 @@
   }
 
   fromTokenId(collectionId: number, tokenId: number): string  {
-    return this.helper.util.getNestingTokenAddress(collectionId, tokenId);
+    return this.helper.util.getNestingTokenAddressRaw({collectionId, tokenId});
   }
 
   normalizeAddress(address: string): string {

--- a/tests/src/nesting/graphs.test.ts
+++ b/tests/src/nesting/graphs.test.ts
@@ -1,9 +1,22 @@
-import {ApiPromise} from '@polkadot/api';
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// 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 {expect} from 'chai';
-import {tokenIdToCross} from '../eth/util/helpers';
-import usingApi, {executeTransaction} from '../substrate/substrate-api';
-import {getCreateCollectionResult, transferExpectSuccess, setCollectionLimitsExpectSuccess} from '../util/helpers';
+import {expect, itSub, usingPlaygrounds} from '../util/playgrounds';
+import {UniqueHelper, UniqueNFTToken} from '../util/playgrounds/unique';
 
 /**
  * ```dot
@@ -12,46 +25,47 @@
  * 8 -> 5
  * ```
  */
-async function buildComplexObjectGraph(api: ApiPromise, sender: IKeyringPair): Promise<number> {
-  const events = await executeTransaction(api, sender, api.tx.unique.createCollectionEx({mode: 'NFT', permissions: {nesting: {tokenOwner: true}}}));
-  const {collectionId} = getCreateCollectionResult(events);
+async function buildComplexObjectGraph(helper: UniqueHelper, sender: IKeyringPair): Promise<UniqueNFTToken[]> {
+  const collection = await helper.nft.mintCollection(sender, {permissions: {nesting: {tokenOwner: true}}});
+  const tokens = await collection.mintMultipleTokens(sender, Array(8).fill({owner: {Substrate: sender.address}}));
 
-  await executeTransaction(api, sender, api.tx.unique.createMultipleItemsEx(collectionId, {NFT: Array(8).fill({owner: {Substrate: sender.address}})}));
-
-  await transferExpectSuccess(collectionId, 8, sender, tokenIdToCross(collectionId, 5));
-
-  await transferExpectSuccess(collectionId, 7, sender, tokenIdToCross(collectionId, 6));
-  await transferExpectSuccess(collectionId, 6, sender, tokenIdToCross(collectionId, 5));
-  await transferExpectSuccess(collectionId, 5, sender, tokenIdToCross(collectionId, 2));
+  await tokens[7].nest(sender, tokens[4]);
+  await tokens[6].nest(sender, tokens[5]);
+  await tokens[5].nest(sender, tokens[4]);
+  await tokens[4].nest(sender, tokens[1]);
+  await tokens[3].nest(sender, tokens[2]);
+  await tokens[2].nest(sender, tokens[1]);
+  await tokens[1].nest(sender, tokens[0]);
 
-  await transferExpectSuccess(collectionId, 4, sender, tokenIdToCross(collectionId, 3));
-  await transferExpectSuccess(collectionId, 3, sender, tokenIdToCross(collectionId, 2));
-  await transferExpectSuccess(collectionId, 2, sender, tokenIdToCross(collectionId, 1));
-
-  return collectionId;
+  return tokens;
 }
 
 describe('Graphs', () => {
-  it('Ouroboros can\'t be created in a complex graph', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const collection = await buildComplexObjectGraph(api, alice);
-      const tokenTwoParent = tokenIdToCross(collection, 1);
+  let alice: IKeyringPair;
 
-      // to self
-      await expect(
-        executeTransaction(api, alice, api.tx.unique.transfer(tokenIdToCross(collection, 1), collection, 1, 1)),
-        'first transaction',  
-      ).to.be.rejectedWith(/structure\.OuroborosDetected/);
-      // to nested part of graph
-      await expect(
-        executeTransaction(api, alice, api.tx.unique.transfer(tokenIdToCross(collection, 5), collection, 1, 1)),
-        'second transaction',
-      ).to.be.rejectedWith(/structure\.OuroborosDetected/);
-      await expect(
-        executeTransaction(api, alice, api.tx.unique.transferFrom(tokenTwoParent, tokenIdToCross(collection, 8), collection, 2, 1)),
-        'third transaction',
-      ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([10n], donor);
     });
   });
+
+  itSub('Ouroboros can\'t be created in a complex graph', async ({helper}) => {
+    const tokens = await buildComplexObjectGraph(helper, alice);
+
+    // to self
+    await expect(
+      tokens[0].nest(alice, tokens[0]),
+      'first transaction',  
+    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+    // to nested part of graph
+    await expect(
+      tokens[0].nest(alice, tokens[4]),
+      'second transaction',
+    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+    await expect(
+      tokens[1].transferFrom(alice, tokens[0].nestingAddress(), tokens[7].nestingAddress()),
+      'third transaction',
+    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+  });
 });

--- a/tests/src/nesting/migration-check.test.ts
+++ b/tests/src/nesting/migration-check.test.ts
@@ -8,7 +8,8 @@
 import find from 'find-process';
 
 // todo un-skip for migrations
-describe.skip('Migration testing', () => {
+// todo:playgrounds skipped, this one is outdated. Probably to be deleted/replaced.
+describe.skip('Migration testing: Properties', () => {
   let alice: IKeyringPair;
 
   before(async() => {

1import {expect} from 'chai';1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
2import {tokenIdToAddress} from '../eth/util/helpers';
3import usingApi, {executeTransaction} from '../substrate/substrate-api';2// This file is part of Unique Network.
4import {
5  addCollectionAdminExpectSuccess,
6  addToAllowListExpectSuccess,
7  createCollectionExpectSuccess,
8  createItemExpectSuccess,
9  enableAllowListExpectSuccess,
10  enablePublicMintingExpectSuccess,
11  getTokenChildren,
12  getTokenOwner,
13  getTopmostTokenOwner,
14  normalizeAccountId,
15  setCollectionPermissionsExpectSuccess,
16  transferExpectFailure,
17  transferExpectSuccess,
18  transferFromExpectSuccess,
19  setCollectionLimitsExpectSuccess,
20  requirePallets,
21  Pallets,
22} from '../util/helpers';
23import {IKeyringPair} from '@polkadot/types/types';
243
25let alice: IKeyringPair;4// Unique Network is free software: you can redistribute it and/or modify
26let bob: IKeyringPair;5// it under the terms of the GNU General Public License as published by
27let charlie: IKeyringPair;6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
288
9// Unique Network is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.
13
14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
16
17import {IKeyringPair} from '@polkadot/types/types';
18import {expect, itSub, Pallets, usingPlaygrounds} from '../util/playgrounds';
19
29describe('Integration Test: Composite nesting tests', () => {20describe('Integration Test: Composite nesting tests', () => {
21  let alice: IKeyringPair;
22  let bob: IKeyringPair;
23
30  before(async () => {24  before(async () => {
31    await usingApi(async (_, privateKeyWrapper) => {25    await usingPlaygrounds(async (helper, privateKey) => {
32      alice = privateKeyWrapper('//Alice');26      const donor = privateKey('//Alice');
33      bob = privateKeyWrapper('//Bob');27      [alice, bob] = await helper.arrange.createAccounts([50n, 10n], donor);
34    });28    });
35  });29  });
3630
37  it('Performs the full suite: bundles a token, transfers, and unnests', async () => {31  itSub('Performs the full suite: bundles a token, transfers, and unnests', async ({helper}) => {
38    await usingApi(async api => {32    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
39      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
40      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
41      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');33    const targetToken = await collection.mintToken(alice);
4234
43      // Create a nested token35    // Create an immediately nested token
44      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});36    const nestedToken = await collection.mintToken(alice, targetToken.nestingAddress());
45      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: alice.address});37    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
46      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});38    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
39    
40    // Create a token to be nested
41    const newToken = await collection.mintToken(alice);
4742
48      // Create a token to be nested43    // Nest
44    await newToken.nest(alice, targetToken);
49      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');45    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
46    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
5047
51      // Nest48    // Move bundle to different user
52      await transferExpectSuccess(collection, newToken, alice, {Ethereum: tokenIdToAddress(collection, targetToken)});49    await targetToken.transfer(alice, {Substrate: bob.address});
53      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});50    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
54      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});51    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
52    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
53    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
5554
56      // Move bundle to different user55    // Unnest
57      await transferExpectSuccess(collection, targetToken, alice, {Substrate: bob.address});56    await newToken.unnest(bob, targetToken, {Substrate: bob.address});
58      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: bob.address});57    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
59      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});58    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});
60
61      // Unnest
62      await transferFromExpectSuccess(collection, newToken, bob, {Ethereum: tokenIdToAddress(collection, targetToken)}, {Substrate: bob.address});
63      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
64    });
65  });59  });
6660
67  it('Transfers an already bundled token', async () => {61  itSub('Transfers an already bundled token', async ({helper}) => {
68    await usingApi(async api => {62    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
69      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
70      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});63    const tokenA = await collection.mintToken(alice);
64    const tokenB = await collection.mintToken(alice);
7165
72      const tokenA = await createItemExpectSuccess(alice, collection, 'NFT');66    // Create a nested token
73      const tokenB = await createItemExpectSuccess(alice, collection, 'NFT');
74
75      // Create a nested token
76      const tokenC = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, tokenA)});67    const tokenC = await collection.mintToken(alice, tokenA.nestingAddress());
77      expect(await getTopmostTokenOwner(api, collection, tokenC)).to.be.deep.equal({Substrate: alice.address});68    expect(await tokenC.getOwner()).to.be.deep.equal(tokenA.nestingAddress());
78      expect(await getTokenOwner(api, collection, tokenC)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, tokenA).toLowerCase()});
79
80      // Transfer the nested token to another token69    
70    // Transfer the nested token to another token
81      await expect(executeTransaction(71    await expect(tokenC.transferFrom(alice, tokenA.nestingAddress(), tokenB.nestingAddress())).to.be.fulfilled;
82        api,
83        alice,
84        api.tx.unique.transferFrom(
85          normalizeAccountId({Ethereum: tokenIdToAddress(collection, tokenA)}),
86          normalizeAccountId({Ethereum: tokenIdToAddress(collection, tokenB)}),
87          collection,
88          tokenC,
89          1,
90        ),
91      )).to.not.be.rejected;
92      expect(await getTopmostTokenOwner(api, collection, tokenC)).to.be.deep.equal({Substrate: alice.address});72    expect(await tokenC.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
93      expect(await getTokenOwner(api, collection, tokenC)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, tokenB).toLowerCase()});73    expect(await tokenC.getOwner()).to.be.deep.equal(tokenB.nestingAddress());
94    });
95  });74  });
9675
97  it('Checks token children', async () => {76  itSub('Checks token children', async ({helper}) => {
98    await usingApi(async api => {77    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
99      const collectionA = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
100      await setCollectionLimitsExpectSuccess(alice, collectionA, {ownerCanTransfer: true});78    const collectionB = await helper.ft.mintCollection(alice);
101      await setCollectionPermissionsExpectSuccess(alice, collectionA, {nesting: {tokenOwner: true}});79    
80    const targetToken = await collectionA.mintToken(alice);
102      const collectionB = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});81    expect((await targetToken.getChildren()).length).to.be.equal(0, 'Children length check at creation');
10382
104      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT');83    // Create a nested NFT token
105      const targetAddress = {Ethereum: tokenIdToAddress(collectionA, targetToken)};84    const tokenA = await collectionA.mintToken(alice, targetToken.nestingAddress());
106      let children = await getTokenChildren(api, collectionA, targetToken);85    expect(await targetToken.getChildren()).to.have.deep.members([
86      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
107      expect(children.length).to.be.equal(0, 'Children length check at creation');87    ], 'Children contents check at nesting #1').and.be.length(1, 'Children length check at nesting #1');
10888
109      // Create a nested NFT token89    // Create then nest
110      const tokenA = await createItemExpectSuccess(alice, collectionA, 'NFT', targetAddress);90    const tokenB = await collectionA.mintToken(alice);
111      children = await getTokenChildren(api, collectionA, targetToken);91    await tokenB.nest(alice, targetToken);
112      expect(children.length).to.be.equal(1, 'Children length check at nesting #1');92    expect(await targetToken.getChildren()).to.have.deep.members([
113      expect(children).to.have.deep.members([
114        {token: tokenA, collection: collectionA},93      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
115      ], 'Children contents check at nesting #1');94      {tokenId: tokenB.tokenId, collectionId: collectionA.collectionId},
95    ], 'Children contents check at nesting #2').and.be.length(2, 'Children length check at nesting #2');
11696
117      // Create then nest97    // Move token B to a different user outside the nesting tree
118      const tokenB = await createItemExpectSuccess(alice, collectionA, 'NFT');
119      await transferExpectSuccess(collectionA, tokenB, alice, targetAddress);98    await tokenB.unnest(alice, targetToken, {Substrate: bob.address});
120      children = await getTokenChildren(api, collectionA, targetToken);
121      expect(children.length).to.be.equal(2, 'Children length check at nesting #2');99    expect(await targetToken.getChildren()).to.be.have.deep.members([
122      expect(children).to.have.deep.members([
123        {token: tokenA, collection: collectionA},100      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
124        {token: tokenB, collection: collectionA},101    ], 'Children contents check at nesting #3 (unnesting)').and.be.length(1, 'Children length check at nesting #3 (unnesting)');
125      ], 'Children contents check at nesting #2');
126102
127      // Move token B to a different user outside the nesting tree103    // Create a fungible token in another collection and then nest
104    await collectionB.mint(alice, 10n);
128      await transferFromExpectSuccess(collectionA, tokenB, alice, targetAddress, bob);105    await collectionB.transfer(alice, targetToken.nestingAddress(), 2n);
106    expect(await targetToken.getChildren()).to.be.have.deep.members([
107      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
108      {tokenId: 0, collectionId: collectionB.collectionId},
109    ], 'Children contents check at nesting #4 (from another collection)')
110      .and.be.length(2, 'Children length check at nesting #4 (from another collection)');
129      children = await getTokenChildren(api, collectionA, targetToken);111    
112    // Move part of the fungible token inside token A deeper in the nesting tree
113    await collectionB.transferFrom(alice, targetToken.nestingAddress(), tokenA.nestingAddress(), 1n);
130      expect(children.length).to.be.equal(1, 'Children length check at unnesting');114    expect(await targetToken.getChildren()).to.be.have.deep.members([
115      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
116      {tokenId: 0, collectionId: collectionB.collectionId},
117    ], 'Children contents check at nesting #5 (deeper)').and.be.length(2, 'Children length check at nesting #5 (deeper)');
131      expect(children).to.be.have.deep.members([118    expect(await tokenA.getChildren()).to.be.have.deep.members([
132        {token: tokenA, collection: collectionA},119      {tokenId: 0, collectionId: collectionB.collectionId},
133      ], 'Children contents check at unnesting');120    ], 'Children contents check at nesting #5.5 (deeper)').and.be.length(1, 'Children length check at nesting #5.5 (deeper)');
134121
135      // Create a fungible token in another collection and then nest122    // Move the remaining part of the fungible token inside token A deeper in the nesting tree
136      const tokenC = await createItemExpectSuccess(alice, collectionB, 'Fungible');
137      await transferExpectSuccess(collectionB, tokenC, alice, targetAddress, 1, 'Fungible');123    await collectionB.transferFrom(alice, targetToken.nestingAddress(), tokenA.nestingAddress(), 1n);
138      children = await getTokenChildren(api, collectionA, targetToken);
139      expect(children.length).to.be.equal(2, 'Children length check at nesting #3 (from another collection)');124    expect(await targetToken.getChildren()).to.be.have.deep.members([
140      expect(children).to.be.have.deep.members([
141        {token: tokenA, collection: collectionA},125      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
142        {token: tokenC, collection: collectionB},126    ], 'Children contents check at nesting #6 (deeper)').and.be.length(1, 'Children length check at nesting #6 (deeper)');
143      ], 'Children contents check at nesting #3 (from another collection)');
144
145      // Move the fungible token inside token A deeper in the nesting tree
146      await transferFromExpectSuccess(collectionB, tokenC, alice, targetAddress, {Ethereum: tokenIdToAddress(collectionA, tokenA)}, 1, 'Fungible');
147      children = await getTokenChildren(api, collectionA, targetToken);
148      expect(children.length).to.be.equal(1, 'Children length check at deeper nesting');
149      expect(children).to.be.have.deep.members([127    expect(await tokenA.getChildren()).to.be.have.deep.members([
150        {token: tokenA, collection: collectionA},128      {tokenId: 0, collectionId: collectionB.collectionId},
151      ], 'Children contents check at deeper nesting');129    ], 'Children contents check at nesting #6.5 (deeper)').and.be.length(1, 'Children length check at nesting #6.5 (deeper)');
152    });
153  });130  });
154});131});
155132
156describe('Integration Test: Various token type nesting', async () => {133describe('Integration Test: Various token type nesting', () => {
134  let alice: IKeyringPair;
135  let bob: IKeyringPair;
136  let charlie: IKeyringPair;
137
157  before(async () => {138  before(async () => {
158    await usingApi(async (_, privateKeyWrapper) => {139    await usingPlaygrounds(async (helper, privateKey) => {
159      alice = privateKeyWrapper('//Alice');140      const donor = privateKey('//Alice');
160      bob = privateKeyWrapper('//Bob');141      [alice, bob, charlie] = await helper.arrange.createAccounts([50n, 10n, 10n], donor);
161      charlie = privateKeyWrapper('//Charlie');
162    });142    });
163  });143  });
164144
165  it('Admin (NFT): allows an Admin to nest a token', async () => {145  itSub('Admin (NFT): allows an Admin to nest a token', async ({helper}) => {
166    await usingApi(async api => {146    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true}}});
167      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
168      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
169      await addCollectionAdminExpectSuccess(alice, collection, bob.address);147    await collection.addAdmin(alice, {Substrate: bob.address});
170      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);148    const targetToken = await collection.mintToken(alice, {Substrate: charlie.address});
171149
172      // Create a nested token150    // Create an immediately nested token
173      const nestedToken = await createItemExpectSuccess(bob, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});151    const nestedToken = await collection.mintToken(bob, targetToken.nestingAddress());
174      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: charlie.address});152    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
175      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});153    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
176154
177      // Create a token to be nested and nest155    // Create a token to be nested and nest
178      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');156    const newToken = await collection.mintToken(bob);
179      await transferExpectSuccess(collection, newToken, bob, {Ethereum: tokenIdToAddress(collection, targetToken)});157    await newToken.nest(bob, targetToken);
180      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});158    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
181      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});159    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
182    });
183  });160  });
184161
185  it('Admin (NFT): Admin and Token Owner can operate together', async () => {162  itSub('Admin (NFT): Admin and Token Owner can operate together', async ({helper}) => {
186    await usingApi(async api => {163    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true}}});
187      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
188      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, collectionAdmin: true}});
189      await addCollectionAdminExpectSuccess(alice, collection, bob.address);164    await collection.addAdmin(alice, {Substrate: bob.address});
190      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);165    const targetToken = await collection.mintToken(alice, {Substrate: charlie.address});
191166
192      // Create a nested token by an administrator167    // Create an immediately nested token by an administrator
193      const nestedToken = await createItemExpectSuccess(bob, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});168    const nestedToken = await collection.mintToken(bob, targetToken.nestingAddress());
194      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: charlie.address});169    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
195      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});170    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
196171
197      // Create a token and allow the owner to nest too172    // Create a token to be nested and nest
198      const newToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);173    const newToken = await collection.mintToken(alice, {Substrate: charlie.address});
199      await transferExpectSuccess(collection, newToken, charlie, {Ethereum: tokenIdToAddress(collection, nestedToken)});174    await newToken.nest(charlie, targetToken);
200      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});175    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
201      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, nestedToken).toLowerCase()});176    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
202    });
203  });177  });
204178
205  it('Admin (NFT): allows an Admin to nest a token (Restricted nesting)', async () => {179  itSub('Admin (NFT): allows an Admin to nest a token (Restricted nesting)', async ({helper}) => {
206    await usingApi(async api => {180    const collectionA = await helper.nft.mintCollection(alice);
207      const collectionA = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
208      await addCollectionAdminExpectSuccess(alice, collectionA, bob.address);181    await collectionA.addAdmin(alice, {Substrate: bob.address});
209      const collectionB = await createCollectionExpectSuccess({mode: {type: 'NFT'}});182    const collectionB = await helper.nft.mintCollection(alice);
210      await addCollectionAdminExpectSuccess(alice, collectionB, bob.address);183    await collectionB.addAdmin(alice, {Substrate: bob.address});
211      await setCollectionPermissionsExpectSuccess(alice, collectionA, {nesting: {collectionAdmin: true, restricted:[collectionA, collectionB]}});184    await collectionA.setPermissions(alice, {nesting: {collectionAdmin: true, restricted:[collectionB.collectionId]}});
212      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT', charlie.address);185    const targetToken = await collectionA.mintToken(alice, {Substrate: charlie.address});
213186
214      // Create a nested token187    // Create an immediately nested token
215      const nestedToken = await createItemExpectSuccess(bob, collectionB, 'NFT', {Ethereum: tokenIdToAddress(collectionA, targetToken)});188    const nestedToken = await collectionB.mintToken(bob, targetToken.nestingAddress());
216      expect(await getTopmostTokenOwner(api, collectionB, nestedToken)).to.be.deep.equal({Substrate: charlie.address});189    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
217      expect(await getTokenOwner(api, collectionB, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collectionA, targetToken).toLowerCase()});190    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
218191
219      // Create a token to be nested and nest192    // Create a token to be nested and nest
220      const newToken = await createItemExpectSuccess(bob, collectionB, 'NFT');193    const newToken = await collectionB.mintToken(bob);
221      await transferExpectSuccess(collectionB, newToken, bob, {Ethereum: tokenIdToAddress(collectionA, targetToken)});194    await newToken.nest(bob, targetToken);
222      expect(await getTopmostTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Substrate: charlie.address});195    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
223      expect(await getTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collectionA, targetToken).toLowerCase()});196    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
224    });
225  });197  });
226198
227  // ---------- Non-Fungible ----------199  // ---------- Non-Fungible ----------
228200
229  it('NFT: allows an Owner to nest/unnest their token', async () => {201  itSub('NFT: allows an Owner to nest/unnest their token', async ({helper}) => {
230    await usingApi(async api => {202    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
231      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
232      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});203    await collection.addToAllowList(alice, {Substrate: charlie.address});
233      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');204    const targetToken = await collection.mintToken(charlie);
205    await collection.addToAllowList(alice, targetToken.nestingAddress());
234206
235      // Create a nested token207    // Create an immediately nested token
236      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});208    const nestedToken = await collection.mintToken(charlie, targetToken.nestingAddress());
237      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: alice.address});209    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
238      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});210    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
239211
240      // Create a token to be nested and nest212    // Create a token to be nested and nest
241      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');213    const newToken = await collection.mintToken(charlie);
242      await transferExpectSuccess(collection, newToken, alice, {Ethereum: tokenIdToAddress(collection, targetToken)});214    await newToken.nest(charlie, targetToken);
243      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});215    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
244      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});216    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
245    });
246  });217  });
247218
248  it('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async () => {219  itSub('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async ({helper}) => {
249    await usingApi(async api => {220    const collectionA = await helper.nft.mintCollection(alice);
250      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});221    const collectionB = await helper.nft.mintCollection(alice);
251      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, restricted:[collection]}});222    //await collectionB.addAdmin(alice, {Substrate: bob.address});
252      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');223    const targetToken = await collectionA.mintToken(alice, {Substrate: charlie.address});
253224
254      // Create a nested token225    await collectionA.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionB.collectionId]}});
255      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
256      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: alice.address});226    await collectionA.addToAllowList(alice, {Substrate: charlie.address});
257      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});227    await collectionA.addToAllowList(alice, targetToken.nestingAddress());
258228
259      // Create a token to be nested and nest229    await collectionB.setPermissions(alice, {access: 'AllowList', mintMode: true});
260      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');230    await collectionB.addToAllowList(alice, {Substrate: charlie.address});
231    await collectionB.addToAllowList(alice, targetToken.nestingAddress());
232
261      await transferExpectSuccess(collection, newToken, alice, {Ethereum: tokenIdToAddress(collection, targetToken)});233    // Create an immediately nested token
234    const nestedToken = await collectionB.mintToken(charlie, targetToken.nestingAddress());
262      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});235    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
263      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});236    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
237
238    // Create a token to be nested and nest
239    const newToken = await collectionB.mintToken(charlie);
240    await newToken.nest(charlie, targetToken);
241    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
264    });242    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
265  });243  });
266244
267  // ---------- Fungible ----------245  // ---------- Fungible ----------
268246
269  it('Fungible: allows an Owner to nest/unnest their token', async () => {247  itSub('Fungible: allows an Owner to nest/unnest their token', async ({helper}) => {
270    await usingApi(async api => {248    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
271      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
272      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});
273      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});249    const collectionFT = await helper.ft.mintCollection(alice);
274      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};250    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
275251
276      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});252    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
253    await collectionNFT.addToAllowList(alice, targetToken.nestingAddress());
277254
278      // Create a nested token255    await collectionFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
279      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
280        collectionFT,256    await collectionFT.addToAllowList(alice, {Substrate: charlie.address});
281        targetAddress,
282        {Fungible: {Value: 10}},
283      ))).to.not.be.rejected;257    await collectionFT.addToAllowList(alice, targetToken.nestingAddress());
284258
285      // Nest a new token259    // Create an immediately nested token
286      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');260    await collectionFT.mint(charlie, 5n, targetToken.nestingAddress());
261    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(5n);
262
287      await transferExpectSuccess(collectionFT, newToken, alice, targetAddress, 1, 'Fungible');263    // Create a token to be nested and nest
264    await collectionFT.mint(charlie, 5n);
265    await collectionFT.transfer(charlie, targetToken.nestingAddress(), 2n);
288    });266    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(7n);
289  });267  });
290268
291  it('Fungible: allows an Owner to nest/unnest their token (Restricted nesting)', async () => {269  itSub('Fungible: allows an Owner to nest/unnest their token (Restricted nesting)', async ({helper}) => {
292    await usingApi(async api => {270    const collectionNFT = await helper.nft.mintCollection(alice);
293      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});271    const collectionFT = await helper.ft.mintCollection(alice);
294      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});272    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
295      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
296273
297      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});274    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionFT.collectionId]}});
275    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
276    await collectionNFT.addToAllowList(alice, targetToken.nestingAddress());
298277
299      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted: [collectionFT]}});278    await collectionFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
279    await collectionFT.addToAllowList(alice, {Substrate: charlie.address});
280    await collectionFT.addToAllowList(alice, targetToken.nestingAddress());
300281
301      // Create a nested token282    // Create an immediately nested token
302      await expect(executeTransaction(api, alice, api.tx.unique.createItem(283    await collectionFT.mint(charlie, 5n, targetToken.nestingAddress());
303        collectionFT,284    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(5n);
304        targetAddress,
305        {Fungible: {Value: 10}},
306      ))).to.not.be.rejected;
307285
308      // Nest a new token286    // Create a token to be nested and nest
309      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');287    await collectionFT.mint(charlie, 5n);
310      await transferExpectSuccess(collectionFT, newToken, alice, targetAddress, 1, 'Fungible');288    await collectionFT.transfer(charlie, targetToken.nestingAddress(), 2n);
311    });289    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(7n);
312  });290  });
313291
314  // ---------- Re-Fungible ----------292  // ---------- Re-Fungible ----------
315293
316  it('ReFungible: allows an Owner to nest/unnest their token', async function() {294  itSub.ifWithPallets('ReFungible: allows an Owner to nest/unnest their token', [Pallets.ReFungible], async ({helper}) => {
317    await requirePallets(this, [Pallets.ReFungible]);295    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
296    const collectionRFT = await helper.rft.mintCollection(alice);
297    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
318298
319    await usingApi(async api => {299    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
320      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
321      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});
322      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});
323      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};300    await collectionNFT.addToAllowList(alice, targetToken.nestingAddress());
324301
325      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});302    await collectionRFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
303    await collectionRFT.addToAllowList(alice, {Substrate: charlie.address});
304    await collectionRFT.addToAllowList(alice, targetToken.nestingAddress());
326305
327      // Create a nested token306    // Create an immediately nested token
328      await expect(executeTransaction(api, alice, api.tx.unique.createItem(307    const nestedToken = await collectionRFT.mintToken(charlie, 5n, targetToken.nestingAddress());
329        collectionRFT,308    expect(await nestedToken.getBalance(targetToken.nestingAddress())).to.be.equal(5n);
330        targetAddress,
331        {ReFungible: {pieces: 100}},
332      ))).to.not.be.rejected;
333309
334      // Nest a new token310    // Create a token to be nested and nest
335      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');311    const newToken = await collectionRFT.mintToken(charlie, 5n);
336      await transferExpectSuccess(collectionRFT, newToken, alice, targetAddress, 100, 'ReFungible');312    await newToken.transfer(charlie, targetToken.nestingAddress(), 2n);
337    });313    expect(await newToken.getBalance(targetToken.nestingAddress())).to.be.equal(2n);
338  });314  });
339315
340  it('ReFungible: allows an Owner to nest/unnest their token (Restricted nesting)', async function() {316  itSub.ifWithPallets('ReFungible: allows an Owner to nest/unnest their token (Restricted nesting)', [Pallets.ReFungible], async ({helper}) => {
341    await requirePallets(this, [Pallets.ReFungible]);317    const collectionNFT = await helper.nft.mintCollection(alice);
318    const collectionRFT = await helper.rft.mintCollection(alice);
319    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
342320
343    await usingApi(async api => {321    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionRFT.collectionId]}});
344      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
345      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});322    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
346      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};323    await collectionNFT.addToAllowList(alice, targetToken.nestingAddress());
347324
348      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});325    await collectionRFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
326    await collectionRFT.addToAllowList(alice, {Substrate: charlie.address});
327    await collectionRFT.addToAllowList(alice, targetToken.nestingAddress());
349328
350      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[collectionRFT]}});329    // Create an immediately nested token
330    const nestedToken = await collectionRFT.mintToken(charlie, 5n, targetToken.nestingAddress());
331    expect(await nestedToken.getBalance(targetToken.nestingAddress())).to.be.equal(5n);
351332
352      // Create a nested token333    // Create a token to be nested and nest
353      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
354        collectionRFT,
355        targetAddress,
356        {ReFungible: {pieces: 100}},
357      ))).to.not.be.rejected;
358
359      // Nest a new token
360      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');334    const newToken = await collectionRFT.mintToken(charlie, 5n);
361      await transferExpectSuccess(collectionRFT, newToken, alice, targetAddress, 100, 'ReFungible');335    await newToken.transfer(charlie, targetToken.nestingAddress(), 2n);
362    });336    expect(await newToken.getBalance(targetToken.nestingAddress())).to.be.equal(2n);
363  });337  });
364});338});
365339
366describe('Negative Test: Nesting', async() => {340describe('Negative Test: Nesting', () => {
341  let alice: IKeyringPair;
342  let bob: IKeyringPair;
343
367  before(async () => {344  before(async () => {
368    await usingApi(async (_, privateKeyWrapper) => {345    await usingPlaygrounds(async (helper, privateKey) => {
369      alice = privateKeyWrapper('//Alice');346      const donor = privateKey('//Alice');
370      bob = privateKeyWrapper('//Bob');347      [alice, bob] = await helper.arrange.createAccounts([100n, 50n], donor);
371    });348    });
372  });349  });
373350
374  it('Disallows excessive token nesting', async () => {351  itSub('Disallows excessive token nesting', async ({helper}) => {
375    await usingApi(async api => {352    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
376      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
377      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
378      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');353    let token = await collection.mintToken(alice);
379354
380      const maxNestingLevel = 5;355    const maxNestingLevel = 5;
381      let prevToken = targetToken;
382356
383      // Create a nested-token matryoshka357    // Create a nested-token matryoshka
384      for (let i = 0; i < maxNestingLevel; i++) {358    for (let i = 0; i < maxNestingLevel; i++) {
385        const nestedToken = await createItemExpectSuccess(359      token = await collection.mintToken(alice, token.nestingAddress());
386          alice,
387          collection,
388          'NFT',
389          {Ethereum: tokenIdToAddress(collection, prevToken)},
390        );360    }
391361
392        prevToken = nestedToken;362    // The nesting depth is limited by `maxNestingLevel`
393      }
394
395      // The nesting depth is limited by `maxNestingLevel`
396      await expect(executeTransaction(api, alice, api.tx.unique.createItem(363    await expect(collection.mintToken(alice, token.nestingAddress()))
397        collection,
398        {Ethereum: tokenIdToAddress(collection, prevToken)},
399          {nft: {}} as any,364      .to.be.rejectedWith(/structure\.DepthLimit/);
400      )), 'while creating nested token').to.be.rejectedWith(/^structure\.DepthLimit$/);
401
402      expect(await getTopmostTokenOwner(api, collection, prevToken)).to.be.deep.equal({Substrate: alice.address});365    expect(await token.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
403    });366    expect(await token.getChildren()).to.be.length(0);
404  });367  });
405368
406  // ---------- Admin ------------369  // ---------- Admin ------------
407370
408  it('Admin (NFT): disallows an Admin to operate nesting when only TokenOwner is allowed', async () => {371  itSub('Admin (NFT): disallows an Admin to operate nesting when only TokenOwner is allowed', async ({helper}) => {
409    await usingApi(async api => {372    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
410      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
411      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
412      await addCollectionAdminExpectSuccess(alice, collection, bob.address);373    await collection.addAdmin(alice, {Substrate: bob.address});
413      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');374    const targetToken = await collection.mintToken(alice);
414375
415      // Try to create a nested token as collection admin when it's disallowed376    // Try to create an immediately nested token as collection admin when it's disallowed
416      await expect(executeTransaction(api, bob, api.tx.unique.createItem(377    await expect(collection.mintToken(bob, targetToken.nestingAddress()))
417        collection,
418        {Ethereum: tokenIdToAddress(collection, targetToken)},
419          {nft: {}} as any,378      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
420      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
421379
422      // Try to create and nest a token in the wrong collection380    // Try to create a token to be nested and nest
423      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');381    const newToken = await collection.mintToken(bob);
424      await expect(executeTransaction(382    await expect(newToken.nest(bob, targetToken))
425        api, 
426        bob, 
427        api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1),
428      ), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);383      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
384
429      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});385    expect(await targetToken.getChildren()).to.be.length(0);
430    });386    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});
431  });387  });
432388
433  it('Admin (NFT): disallows a Token Owner to operate nesting when only Admin is allowed', async () => {389  itSub('Admin (NFT): disallows a Token Owner to operate nesting when only Admin is allowed', async ({helper}) => {
434    await usingApi(async api => {390    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {collectionAdmin: true}}});
435      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
436      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
437      await addToAllowListExpectSuccess(alice, collection, bob.address);391    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});
438      await enableAllowListExpectSuccess(alice, collection);392    await collection.addToAllowList(alice, {Substrate: bob.address});
439      await enablePublicMintingExpectSuccess(alice, collection);393    await collection.addToAllowList(alice, targetToken.nestingAddress());
440      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
441394
442      // Try to create a nested token as collection admin when it's disallowed395    // Try to create a nested token as token owner when it's disallowed
443      await expect(executeTransaction(api, bob, api.tx.unique.createItem(396    await expect(collection.mintToken(bob, targetToken.nestingAddress()))
444        collection,
445        {Ethereum: tokenIdToAddress(collection, targetToken)},
446          {nft: {}} as any,397      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
447      )), 'while creating nested token').to.be.rejectedWith(/common\.AddressNotInAllowlist/); 
448398
449      // Try to create and nest a token in the wrong collection399    // Try to create a token to be nested and nest
450      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');400    const newToken = await collection.mintToken(bob);
451      await expect(executeTransaction(401    await expect(newToken.nest(bob, targetToken))
452        api, 
453        bob, 
454        api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1),402      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
403
455      ), 'while nesting new token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);404    expect(await targetToken.getChildren()).to.be.length(0);
456      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});405    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});
457    });
458  });406  });
459407
460  it('Admin (NFT): disallows an Admin to nest and unnest someone else\'s token', async () => {408  itSub('Admin (NFT): disallows an Admin to unnest someone else\'s token', async ({helper}) => {
461    await usingApi(async api => {409    const collection = await helper.nft.mintCollection(alice, {limits: {ownerCanTransfer: true}, permissions: {access: 'AllowList', mintMode: true, nesting: {collectionAdmin: true}}});
462      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});410    //await collection.addAdmin(alice, {Substrate: bob.address});
463      await setCollectionLimitsExpectSuccess(alice, collection, {ownerCanTransfer: true});411    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});
464      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});412    await collection.addToAllowList(alice, {Substrate: bob.address});
413    await collection.addToAllowList(alice, targetToken.nestingAddress());
465414
466      await addToAllowListExpectSuccess(alice, collection, bob.address);415    // Try to nest somebody else's token
416    const newToken = await collection.mintToken(bob);
467      await enableAllowListExpectSuccess(alice, collection);417    await expect(newToken.nest(alice, targetToken))
468      await enablePublicMintingExpectSuccess(alice, collection);418      .to.be.rejectedWith(/common\.NoPermission/);
469419
470      // Create a token to attempt to be nested into420    // Try to unnest a token belonging to someone else as collection admin
471      const targetToken = await createItemExpectSuccess(bob, collection, 'NFT');421    const nestedToken = await collection.mintToken(alice, targetToken.nestingAddress());
472      const targetAddress = {Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()};422    await expect(nestedToken.unnest(alice, targetToken, {Substrate: bob.address}))
423      .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
473424
474      // Try to nest somebody else's token425    expect(await targetToken.getChildren()).to.be.length(1);
475      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
476      await expect(executeTransaction(
477        api, 
478        alice, 
479        api.tx.unique.transferFrom(targetAddress, {Substrate: bob.address}, collection, newToken, 1),
480      ), 'while nesting another\'s token token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
481      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});426    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
482
483      // Nest a token as admin and try to unnest it, now belonging to someone else427    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
484      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', targetAddress);
485      await expect(executeTransaction(
486        api, 
487        alice, 
488        api.tx.unique.transferFrom(targetAddress, normalizeAccountId(alice), collection, nestedToken, 1),
489      ), 'while unnesting another\'s token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
490      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal(targetAddress);
491      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: bob.address});
492    });
493  });428  });
494429
495  it('Admin (NFT): disallows an Admin to nest a token from an unlisted collection (Restricted nesting)', async () => {430  itSub('Admin (NFT): disallows an Admin to nest a token from an unlisted collection (Restricted nesting)', async ({helper}) => {
496    await usingApi(async api => {431    const collectionA = await helper.nft.mintCollection(alice);
497      const collectionA = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
498      const collectionB = await createCollectionExpectSuccess({mode: {type: 'NFT'}});432    const collectionB = await helper.nft.mintCollection(alice);
499      await setCollectionPermissionsExpectSuccess(alice, collectionA, {nesting: {collectionAdmin: true, restricted:[collectionA]}});433    await collectionA.setPermissions(alice, {nesting: {collectionAdmin: true, restricted: [collectionA.collectionId]}});
434    const targetToken = await collectionA.mintToken(alice);
500435
501      // Create a token to attempt to be nested into436    // Try to create a nested token from another collection
502      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT');437    await expect(collectionB.mintToken(alice, targetToken.nestingAddress()))
438      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
503439
504      // Try to create and nest a token in the wrong collection440    // Create a token in another collection yet to be nested and try to nest
505      const newToken = await createItemExpectSuccess(alice, collectionB, 'NFT');441    const newToken = await collectionB.mintToken(alice);
506      await expect(executeTransaction(442    await expect(newToken.nest(alice, targetToken))
507        api, 
508        alice, 
509        api.tx.unique.transfer({Ethereum: tokenIdToAddress(collectionA, targetToken)}, collectionB, newToken, 1),
510      ), 'while nesting a foreign token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);443      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
444
511      expect(await getTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Substrate: alice.address});445    expect(await targetToken.getChildren()).to.be.length(0);
512    });446    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
513  });447  });
514448
515  // ---------- Non-Fungible ----------449  // ---------- Non-Fungible ----------
516450
517  it('NFT: disallows to nest token if nesting is disabled', async () => {451  itSub('NFT: disallows to nest token if nesting is disabled', async ({helper}) => {
518    await usingApi(async api => {452    // Collection is implicitly not allowed nesting at creation
519      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});453    const collection = await helper.nft.mintCollection(alice);
520      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {}});
521      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');454    const targetToken = await collection.mintToken(alice);
522455
523      // Try to create a nested token456    // Try to create a nested token as token owner when it's disallowed
524      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
525        collection,457    await expect(collection.mintToken(alice, targetToken.nestingAddress()))
526        {Ethereum: tokenIdToAddress(collection, targetToken)},
527          {nft: {}} as any,458      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
528      )), 'while creating nested token').to.be.rejectedWith(/^common\.UserIsNotAllowedToNest$/);
529459
530      // Create a token to be nested460    // Try to create a token to be nested and nest
531      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');461    const newToken = await collection.mintToken(alice);
532      // Try to nest462    await expect(newToken.nest(alice, targetToken))
533      await expect(executeTransaction(api, alice, api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);463      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
464
534      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});465    expect(await targetToken.getChildren()).to.be.length(0);
535      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});466    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
536    });
537  });467  });
538468
539  it('NFT: disallows a non-Owner to nest someone else\'s token', async () => {469  itSub('NFT: disallows a non-Owner to nest someone else\'s token', async ({helper}) => {
540    await usingApi(async api => {470    const collection = await helper.nft.mintCollection(alice);
541      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
542      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});471    const targetToken = await collection.mintToken(alice);
543472
544      await addToAllowListExpectSuccess(alice, collection, bob.address);473    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
545      await enableAllowListExpectSuccess(alice, collection);474    await collection.addToAllowList(alice, {Substrate: bob.address});
546      await enablePublicMintingExpectSuccess(alice, collection);475    await collection.addToAllowList(alice, targetToken.nestingAddress());
547476
548      // Create a token to attempt to be nested into477    // Try to create a token to be nested and nest
549      const targetToken = await createItemExpectSuccess(bob, collection, 'NFT');478    const newToken = await collection.mintToken(alice);
479    await expect(newToken.nest(bob, targetToken)).to.be.rejectedWith(/common\.NoPermission/);
550480
551      // Try to create a nested token in the wrong collection481    expect(await targetToken.getChildren()).to.be.length(0);
552      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
553        collection,
554        {Ethereum: tokenIdToAddress(collection, targetToken)},
555          {nft: {}} as any,
556      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
557
558      // Try to create and nest a token in the wrong collection482    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
559      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
560      await expect(executeTransaction(api, alice, api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
561      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
562    });
563  });483  });
564484
565  it('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async () => {485  itSub('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async ({helper}) => {
566    await usingApi(async api => {486    const collection = await helper.nft.mintCollection(alice);
567      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
568      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, restricted:[collection]}});487    const targetToken = await collection.mintToken(alice);
569488
570      await addToAllowListExpectSuccess(alice, collection, bob.address);489    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
571      await enableAllowListExpectSuccess(alice, collection);490    await collection.addToAllowList(alice, {Substrate: bob.address});
572      await enablePublicMintingExpectSuccess(alice, collection);491    await collection.addToAllowList(alice, targetToken.nestingAddress());
573492
574      // Create a token to attempt to be nested into493    const collectionB = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true}});
575      const targetToken = await createItemExpectSuccess(bob, collection, 'NFT');494    await collectionB.addToAllowList(alice, {Substrate: bob.address});
495    await collectionB.addToAllowList(alice, targetToken.nestingAddress());
576496
577      // Try to create a nested token in the wrong collection497    // Try to create a token to be nested and nest
578      await expect(executeTransaction(api, alice, api.tx.unique.createItem(498    const newToken = await collectionB.mintToken(alice);
579        collection,499    await expect(newToken.nest(bob, targetToken)).to.be.rejectedWith(/common\.NoPermission/);
580        {Ethereum: tokenIdToAddress(collection, targetToken)},
581          {nft: {}} as any,
582      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
583500
584      // Try to create and nest a token in the wrong collection501    expect(await targetToken.getChildren()).to.be.length(0);
585      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
586      await expect(executeTransaction(api, alice, api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
587      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});502    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
588    });
589  });503  });
590504
591  it('NFT: disallows to nest token in an unlisted collection', async () => {505  itSub('NFT: disallows to nest token in an unlisted collection', async ({helper}) => {
592    await usingApi(async api => {506    // Create collection with restricted nesting -- even self is not allowed
593      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});507    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted: []}}});
594      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, restricted:[]}});508    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});
595509
596      // Create a token to attempt to be nested into510    await collection.addToAllowList(alice, {Substrate: bob.address});
597      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');511    await collection.addToAllowList(alice, targetToken.nestingAddress());
598512
599      // Try to create a nested token in the wrong collection513    // Try to mint in own collection after allowlisting the accounts
600      await expect(executeTransaction(api, alice, api.tx.unique.createItem(514    await expect(collection.mintToken(bob, targetToken.nestingAddress()))
601        collection,
602        {Ethereum: tokenIdToAddress(collection, targetToken)},
603          {nft: {}} as any,
604      )), 'while creating nested token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
605
606      // Try to create and nest a token in the wrong collection
607      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
608      await expect(executeTransaction(api, alice, api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);515      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
609      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
610    });
611  });516  });
612517
613  // ---------- Fungible ----------518  // ---------- Fungible ----------
614519
615  it('Fungible: disallows to nest token if nesting is disabled', async () => {520  itSub('Fungible: disallows to nest token if nesting is disabled', async ({helper}) => {
616    await usingApi(async api => {521    const collectionNFT = await helper.nft.mintCollection(alice);
617      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
618      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {}});
619      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');522    const collectionFT = await helper.ft.mintCollection(alice);
620      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};523    const targetToken = await collectionNFT.mintToken(alice);
621524
622      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});525    // Try to create an immediately nested token
526    await expect(collectionFT.mint(alice, 5n, targetToken.nestingAddress()))
527      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
623528
624      // Try to create a nested token529    // Try to create a token to be nested and nest
625      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
626        collectionFT,
627        targetAddress,
628        {Fungible: {Value: 10}},
629      )), 'while creating nested token').to.be.rejectedWith(/^common\.UserIsNotAllowedToNest$/);
630
631      // Create a token to be nested
632      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');530    await collectionFT.mint(alice, 5n);
633      // Try to nest531    await expect(collectionFT.transfer(alice, targetToken.nestingAddress(), 2n))
634      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);532      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
635
636      // Create another token to be nested533    expect(await collectionFT.getBalance({Substrate: alice.address})).to.be.equal(5n);
637      const newToken2 = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
638      // Try to nest inside a fungible token
639      await expect(executeTransaction(api, alice, api.tx.unique.transfer({Ethereum: tokenIdToAddress(collectionFT, newToken)}, collectionFT, newToken2, 1)), 'while nesting new token inside fungible').to.be.rejectedWith(/fungible\.FungibleDisallowsNesting/);
640    });
641  });534  });
642535
643  it('Fungible: disallows a non-Owner to nest someone else\'s token', async () => {536  itSub('Fungible: disallows a non-Owner to unnest someone else\'s token', async ({helper}) => {
644    await usingApi(async api => {537    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true}}});
645      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});538    const collectionFT = await helper.ft.mintCollection(alice);
646      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});539    const targetToken = await collectionNFT.mintToken(alice, {Substrate: bob.address});
647540
648      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);541    // Nest some tokens as Alice into Bob's token
649      await enableAllowListExpectSuccess(alice, collectionNFT);
650      await enablePublicMintingExpectSuccess(alice, collectionNFT);542    await collectionFT.mint(alice, 5n, targetToken.nestingAddress());
651543
652      // Create a token to attempt to be nested into544    // Try to pull it out
653      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');
654      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
655
656      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
657
658      // Try to create a nested token in the wrong collection
659      await expect(executeTransaction(api, alice, api.tx.unique.createItem(545    await expect(collectionFT.transferFrom(alice, targetToken.nestingAddress(), {Substrate: bob.address}, 1n))
660        collectionFT,
661        targetAddress,
662        {Fungible: {Value: 10}},
663      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);546      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
664
665      // Try to create and nest a token in the wrong collection547    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(5n);
666      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
667      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
668    });
669  });548  });
670549
671  it('Fungible: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async () => {550  itSub('Fungible: disallows a non-Owner to unnest someone else\'s token (Restricted nesting)', async ({helper}) => {
672    await usingApi(async api => {551    const collectionNFT = await helper.nft.mintCollection(alice);
673      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
674      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);
675      await enableAllowListExpectSuccess(alice, collectionNFT);552    const collectionFT = await helper.ft.mintCollection(alice);
676      await enablePublicMintingExpectSuccess(alice, collectionNFT);553    const targetToken = await collectionNFT.mintToken(alice, {Substrate: bob.address});
677554
678      // Create a token to attempt to be nested into555    await collectionNFT.setPermissions(alice, {nesting: {collectionAdmin: true, tokenOwner: true, restricted: [collectionFT.collectionId]}});
679      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');
680      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
681556
682      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});557    // Nest some tokens as Alice into Bob's token
683      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[collectionFT]}});558    await collectionFT.mint(alice, 5n, targetToken.nestingAddress());
684559
685      // Try to create a nested token in the wrong collection560    // Try to pull it out as Alice still
686      await expect(executeTransaction(api, alice, api.tx.unique.createItem(561    await expect(collectionFT.transferFrom(alice, targetToken.nestingAddress(), {Substrate: bob.address}, 1n))
687        collectionFT,
688        targetAddress,
689        {Fungible: {Value: 10}},
690      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);562      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
691
692      // Try to create and nest a token in the wrong collection563    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(5n);
693      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
694      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
695    });
696  });564  });
697565
698  it('Fungible: disallows to nest token in an unlisted collection', async () => {566  itSub('Fungible: disallows to nest token in an unlisted collection', async ({helper}) => {
699    await usingApi(async api => {567    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true, restricted: []}}});
700      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
701      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[]}});568    const collectionFT = await helper.ft.mintCollection(alice);
569    const targetToken = await collectionNFT.mintToken(alice);
702570
703      // Create a token to attempt to be nested into571    // Try to mint an immediately nested token
704      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');572    await expect(collectionFT.mint(alice, 5n, targetToken.nestingAddress()))
705      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};573      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
706574
707      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});575    // Mint a token and try to nest it
576    await collectionFT.mint(alice, 5n);
577    await expect(collectionFT.transfer(alice, targetToken.nestingAddress(), 1n))
578      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
708579
709      // Try to create a nested token in the wrong collection580    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(0n);
710      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
711        collectionFT,
712        targetAddress,
713        {Fungible: {Value: 10}},
714      )), 'while creating a nested token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
715
716      // Try to create and nest a token in the wrong collection581    expect(await collectionFT.getBalance({Substrate: alice.address})).to.be.equal(5n);
717      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
718      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
719    });
720  });582  });
721583
722  // ---------- Re-Fungible ----------584  // ---------- Re-Fungible ----------
723585
724  it('ReFungible: disallows to nest token if nesting is disabled', async function() {586  itSub.ifWithPallets('ReFungible: disallows to nest token if nesting is disabled', [Pallets.ReFungible], async ({helper}) => {
725    await requirePallets(this, [Pallets.ReFungible]);587    const collectionNFT = await helper.nft.mintCollection(alice);
588    const collectionRFT = await helper.rft.mintCollection(alice);
589    const targetToken = await collectionNFT.mintToken(alice);
726590
727    await usingApi(async api => {591    // Try to create an immediately nested token
728      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
729      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {}});592    await expect(collectionRFT.mintToken(alice, 5n, targetToken.nestingAddress()))
730      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');
731      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};593      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
732594
733      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});595    // Try to create a token to be nested and nest
734
735      // Create a nested token
736      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
737        collectionRFT,
738        targetAddress,
739        {ReFungible: {pieces: 100}},
740      )), 'while creating a nested token').to.be.rejectedWith(/^common\.UserIsNotAllowedToNest$/);
741
742      // Create a token to be nested
743      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');596    const token = await collectionRFT.mintToken(alice, 5n);
744      // Try to nest
745      await transferExpectFailure(collectionRFT, newToken, alice, targetAddress, 100);
746      // Try to nest597    await expect(token.transfer(alice, targetToken.nestingAddress(), 2n))
747      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);598      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
748
749      // Create another token to be nested599    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(5n);
750      const newToken2 = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
751      // Try to nest inside a fungible token
752      await expect(executeTransaction(api, alice, api.tx.unique.transfer({Ethereum: tokenIdToAddress(collectionRFT, newToken)}, collectionRFT, newToken2, 1)), 'while nesting new token inside refungible').to.be.rejectedWith(/refungible\.RefungibleDisallowsNesting/);
753    });
754  });600  });
755601
756  it('ReFungible: disallows a non-Owner to nest someone else\'s token', async function() {602  itSub.ifWithPallets('ReFungible: disallows a non-Owner to nest someone else\'s token', [Pallets.ReFungible], async ({helper}) => {
757    await requirePallets(this, [Pallets.ReFungible]);603    const collectionNFT = await helper.nft.mintCollection(alice);
604    const collectionRFT = await helper.rft.mintCollection(alice);
605    const targetToken = await collectionNFT.mintToken(alice);
758606
759    await usingApi(async api => {607    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
760      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});608    await collectionNFT.addToAllowList(alice, {Substrate: bob.address});
761      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});609    await collectionNFT.addToAllowList(alice, targetToken.nestingAddress());
762610
763      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);611    // Try to create a token to be nested and nest
764      await enableAllowListExpectSuccess(alice, collectionNFT);612    const newToken = await collectionRFT.mintToken(alice);
765      await enablePublicMintingExpectSuccess(alice, collectionNFT);613    await expect(newToken.transfer(bob, targetToken.nestingAddress())).to.be.rejectedWith(/common\.TokenValueTooLow/);
766614
767      // Create a token to attempt to be nested into615    expect(await targetToken.getChildren()).to.be.length(0);
768      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');
769      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};616    expect(await newToken.getBalance({Substrate: alice.address})).to.be.equal(1n);
770617
771      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});618    // Nest some tokens as Alice into Bob's token
619    await newToken.transfer(alice, targetToken.nestingAddress());
772620
773      // Try to create a nested token in the wrong collection621    // Try to pull it out
774      await expect(executeTransaction(api, alice, api.tx.unique.createItem(622    await expect(newToken.transferFrom(bob, targetToken.nestingAddress(), {Substrate: alice.address}, 1n))
775        collectionRFT,
776        targetAddress,
777        {ReFungible: {pieces: 100}},
778      )), 'while creating a nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);623      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
779
780      // Try to create and nest a token in the wrong collection624    expect(await newToken.getBalance(targetToken.nestingAddress())).to.be.equal(1n);
781      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
782      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
783    });
784  });625  });
785626
786  it('ReFungible: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async function() {627  itSub.ifWithPallets('ReFungible: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', [Pallets.ReFungible], async ({helper}) => {
787    await requirePallets(this, [Pallets.ReFungible]);628    const collectionNFT = await helper.nft.mintCollection(alice);
629    const collectionRFT = await helper.rft.mintCollection(alice);
630    const targetToken = await collectionNFT.mintToken(alice);
788631
789    await usingApi(async api => {632    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted: [collectionRFT.collectionId]}});
790      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
791      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);633    await collectionNFT.addToAllowList(alice, {Substrate: bob.address});
792      await enableAllowListExpectSuccess(alice, collectionNFT);634    await collectionNFT.addToAllowList(alice, targetToken.nestingAddress());
793      await enablePublicMintingExpectSuccess(alice, collectionNFT);
794635
795      // Create a token to attempt to be nested into636    // Try to create a token to be nested and nest
796      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');637    const newToken = await collectionRFT.mintToken(alice);
797      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};638    await expect(newToken.transfer(bob, targetToken.nestingAddress())).to.be.rejectedWith(/common\.TokenValueTooLow/);
798639
799      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});640    expect(await targetToken.getChildren()).to.be.length(0);
800      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[collectionRFT]}});641    expect(await newToken.getBalance({Substrate: alice.address})).to.be.equal(1n);
801642
802      // Try to create a nested token in the wrong collection643    // Nest some tokens as Alice into Bob's token
803      await expect(executeTransaction(api, alice, api.tx.unique.createItem(644    await newToken.transfer(alice, targetToken.nestingAddress());
804        collectionRFT,
805        targetAddress,
806        {ReFungible: {pieces: 100}},
807      )), 'while creating a nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
808645
809      // Try to create and nest a token in the wrong collection646    // Try to pull it out
810      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');647    await expect(newToken.transferFrom(bob, targetToken.nestingAddress(), {Substrate: alice.address}, 1n))
811      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);648      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
812    });649    expect(await newToken.getBalance(targetToken.nestingAddress())).to.be.equal(1n);
813  });650  });
814651
815  it('ReFungible: disallows to nest token to an unlisted collection', async function() {652  itSub.ifWithPallets('ReFungible: disallows to nest token to an unlisted collection', [Pallets.ReFungible], async ({helper}) => {
816    await requirePallets(this, [Pallets.ReFungible]);653    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true, restricted: []}}});
654    const collectionRFT = await helper.rft.mintCollection(alice);
655    const targetToken = await collectionNFT.mintToken(alice);
817656
818    await usingApi(async api => {657    // Try to create an immediately nested token
819      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});658    await expect(collectionRFT.mintToken(alice, 5n, targetToken.nestingAddress()))
820      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[]}});659      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
821660
822      // Create a token to attempt to be nested into661    // Try to create a token to be nested and nest
823      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');662    const token = await collectionRFT.mintToken(alice, 5n);
824      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};663    await expect(token.transfer(alice, targetToken.nestingAddress(), 2n))
825
826      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
827
828      // Try to create a nested token in the wrong collection
829      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
830        collectionRFT,
831        targetAddress,
832        {ReFungible: {pieces: 100}},
833      )), 'while creating a nested token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);664      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
834
835      // Try to create and nest a token in the wrong collection665    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(5n);
836      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
837      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
838    });
839  });666  });
840});667});
841668

--- a/tests/src/nesting/properties.test.ts
+++ b/tests/src/nesting/properties.test.ts
@@ -1,5 +1,20 @@
-import {expect} from 'chai';
-import usingApi, {executeTransaction} from '../substrate/substrate-api';
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// 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 usingApi, {executeTransaction} from '../substrate/substrate-api';
 import {
   addCollectionAdminExpectSuccess,
   CollectionMode,
@@ -8,997 +23,776 @@
   createItemExpectSuccess,
   getCreateCollectionResult,
   transferExpectSuccess,
-  requirePallets,
-  Pallets,
-} from '../util/helpers';
+} from '../util/helpers';*/
 import {IKeyringPair} from '@polkadot/types/types';
-import {tokenIdToAddress} from '../eth/util/helpers';
+import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from '../util/playgrounds';
+import {UniqueCollectionBase, UniqueHelper, UniqueNFTCollection, UniqueNFTToken, UniqueRFTCollection, UniqueRFTToken} from '../util/playgrounds/unique';
 
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let charlie: IKeyringPair;
+// ---------- COLLECTION PROPERTIES
+
+describe('Integration Test: Collection Properties', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
 
-describe('Composite Properties Test', () => {
   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([50n, 10n], donor);
     });
   });
 
-  async function testMakeSureSuppliesRequired(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collectionId = await createCollectionExpectSuccess({mode: mode});
+  itSub('Properties are initially empty', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice);
+    expect(await collection.getProperties()).to.be.empty;
+  });
 
-      const collectionOption = await api.rpc.unique.collectionById(collectionId);
-      expect(collectionOption.isSome).to.be.true;
-      let collection = collectionOption.unwrap();
-      expect(collection.tokenPropertyPermissions.toHuman()).to.be.empty;
-      expect(collection.properties.toHuman()).to.be.empty;
+  async function testSetsPropertiesForCollection(collection: UniqueCollectionBase) {
+    // As owner
+    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled;
 
-      const propertyPermissions = [
-        {key: 'mindgame', permission: {collectionAdmin: true, mutable: false, tokenOwner: true}},
-        {key: 'skullduggery', permission: {collectionAdmin: false, mutable: true, tokenOwner: false}},
-      ];
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collectionId, propertyPermissions), 
-      )).to.not.be.rejected;
+    await collection.addAdmin(alice, {Substrate: bob.address});
 
-      const collectionProperties = [
-        {key: 'black_hole', value: 'LIGO'},
-        {key: 'electron', value: 'come bond'}, 
-      ];
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collectionId, collectionProperties), 
-      )).to.not.be.rejected;
+    // As administrator
+    await expect(collection.setProperties(bob, [{key: 'black_hole'}])).to.be.fulfilled;
 
-      collection = (await api.rpc.unique.collectionById(collectionId)).unwrap();
-      expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);
-      expect(collection.properties.toHuman()).to.be.deep.equal(collectionProperties);
-    });
+    const properties = await collection.getProperties();
+    expect(properties).to.include.deep.members([
+      {key: 'electron', value: 'come bond'},
+      {key: 'black_hole', value: ''},
+    ]);
   }
 
-  it('Makes sure collectionById supplies required fields for NFT', async () => {
-    await testMakeSureSuppliesRequired({type: 'NFT'});
+  itSub('Sets properties for a NFT collection', async ({helper}) =>  {
+    await testSetsPropertiesForCollection(await helper.nft.mintCollection(alice));
   });
 
-  it('Makes sure collectionById supplies required fields for ReFungible', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
-
-    await testMakeSureSuppliesRequired({type: 'ReFungible'});
+  itSub.ifWithPallets('Sets properties for a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    await testSetsPropertiesForCollection(await helper.rft.mintCollection(alice));
   });
-});
 
-// ---------- COLLECTION PROPERTIES
+  async function testCheckValidNames(collection: UniqueCollectionBase) {
+    // alpha symbols
+    await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled;
 
-describe('Integration Test: Collection Properties', () => {
-  before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-    });
-  });
+    // numeric symbols
+    await expect(collection.setProperties(alice, [{key: '451'}])).to.be.fulfilled;
 
-  it('Reads properties from a collection', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-      const properties = (await api.query.common.collectionProperties(collection)).toJSON();
-      expect(properties.map).to.be.empty;
-      expect(properties.consumedSpace).to.equal(0);
-    });
-  });
+    // underscore symbol
+    await expect(collection.setProperties(alice, [{key: 'black_hole'}])).to.be.fulfilled;
 
+    // dash symbol
+    await expect(collection.setProperties(alice, [{key: '-'}])).to.be.fulfilled;
 
-  async function testSetsPropertiesForCollection(mode: string) {
-    await usingApi(async api => {
-      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));
-      const {collectionId} = getCreateCollectionResult(events);
+    // dot symbol
+    await expect(collection.setProperties(alice, [{key: 'once.in.a.long.long.while...', value: 'you get a little lost'}])).to.be.fulfilled;
 
-      // As owner
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setCollectionProperties(collectionId, [{key: 'electron', value: 'come bond'}]), 
-      )).to.not.be.rejected;
+    const properties = await collection.getProperties();
+    expect(properties).to.include.deep.members([
+      {key: 'answer', value: ''},
+      {key: '451', value: ''},
+      {key: 'black_hole', value: ''},
+      {key: '-', value: ''},
+      {key: 'once.in.a.long.long.while...', value: 'you get a little lost'},
+    ]);
+  }
 
-      await addCollectionAdminExpectSuccess(bob, collectionId, alice.address);
-
-      // As administrator
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 
-      )).to.not.be.rejected;
-
-      const properties = (await api.rpc.unique.collectionProperties(collectionId, ['electron', 'black_hole'])).toHuman();
-      expect(properties).to.be.deep.equal([
-        {key: 'electron', value: 'come bond'},
-        {key: 'black_hole', value: ''},
-      ]);
-    });
-  }
-  it('Sets properties for a NFT collection', async () => {
-    await testSetsPropertiesForCollection('NFT');
+  itSub('Check valid names for NFT collection properties keys', async ({helper}) =>  {
+    await testCheckValidNames(await helper.nft.mintCollection(alice));
   });
-  it('Sets properties for a ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testSetsPropertiesForCollection('ReFungible');
+  itSub.ifWithPallets('Check valid names for ReFungible collection properties keys', [Pallets.ReFungible], async ({helper}) => {
+    await testCheckValidNames(await helper.rft.mintCollection(alice));
   });
 
-  async function testCheckValidNames(mode: string) {
-    await usingApi(async api => {
-      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));
-      const {collectionId} = getCreateCollectionResult(events);
-  
-      // alpha symbols
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setCollectionProperties(collectionId, [{key: 'alpha'}]), 
-      )).to.not.be.rejected;
-  
-      // numeric symbols
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setCollectionProperties(collectionId, [{key: '123'}]), 
-      )).to.not.be.rejected;
-  
-      // underscore symbol
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 
-      )).to.not.be.rejected;
-  
-      // dash symbol
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setCollectionProperties(collectionId, [{key: 'semi-automatic'}]), 
-      )).to.not.be.rejected;
-  
-      // underscore symbol
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setCollectionProperties(collectionId, [{key: 'build.rs'}]), 
-      )).to.not.be.rejected;
-  
-      const propertyKeys = ['alpha', '123', 'black_hole', 'semi-automatic', 'build.rs'];
-      const properties = (await api.rpc.unique.collectionProperties(collectionId, propertyKeys)).toHuman();
-      expect(properties).to.be.deep.equal([
-        {key: 'alpha', value: ''},
-        {key: '123', value: ''},
-        {key: 'black_hole', value: ''},
-        {key: 'semi-automatic', value: ''},
-        {key: 'build.rs', value: ''},
-      ]);
-    });
+  async function testChangesProperties(collection: UniqueCollectionBase) {
+    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled;
+
+    // Mutate the properties
+    await expect(collection.setProperties(alice, [{key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;
+
+    const properties = await collection.getProperties();
+    expect(properties).to.include.deep.members([
+      {key: 'electron', value: 'come bond'},
+      {key: 'black_hole', value: 'LIGO'},
+    ]);
   }
-  it('Check valid names for NFT collection properties keys', async () => {
-    await testCheckValidNames('NFT');
+
+  itSub('Changes properties of a NFT collection', async ({helper}) =>  {
+    await testChangesProperties(await helper.nft.mintCollection(alice));
   });
-  it('Check valid names for ReFungible collection properties keys', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testCheckValidNames('ReFungible');
+  itSub.ifWithPallets('Changes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    await testChangesProperties(await helper.rft.mintCollection(alice));
   });
 
-  async function testChangesProperties(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole'}]), 
-      )).to.not.be.rejected;
-  
-      // Mutate the properties
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'bonded'}, {key: 'black_hole', value: 'LIGO'}]), 
-      )).to.not.be.rejected;
-  
-      const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();
-      expect(properties).to.be.deep.equal([
-        {key: 'electron', value: 'bonded'},
-        {key: 'black_hole', value: 'LIGO'},
-      ]);
-    });
-  }
-  it('Changes properties of a NFT collection', async () => {
-    await testChangesProperties({type: 'NFT'});
-  });
-  it('Changes properties of a ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  async function testDeleteProperties(collection: UniqueCollectionBase) {
+    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;
 
-    await testChangesProperties({type: 'ReFungible'});
-  });
+    await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled;
 
-  async function testDeleteProperties(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 
-      )).to.not.be.rejected;
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.deleteCollectionProperties(collection, ['electron']), 
-      )).to.not.be.rejected;
-  
-      const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();
-      expect(properties).to.be.deep.equal([
-        {key: 'black_hole', value: 'LIGO'},
-      ]);
-    });  
+    const properties = await collection.getProperties(['black_hole', 'electron']);
+    expect(properties).to.be.deep.equal([
+      {key: 'black_hole', value: 'LIGO'},
+    ]);
   }
-  it('Deletes properties of a NFT collection', async () => {
-    await testDeleteProperties({type: 'NFT'});
+
+  itSub('Deletes properties of a NFT collection', async ({helper}) =>  {
+    await testDeleteProperties(await helper.nft.mintCollection(alice));
   });
-  it('Deletes properties of a ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testDeleteProperties({type: 'ReFungible'});
+  itSub.ifWithPallets('Deletes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    await testDeleteProperties(await helper.rft.mintCollection(alice));
   });
 });
 
 describe('Negative Integration Test: Collection Properties', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
     });
   });
   
-  async function testFailsSetPropertiesIfNotOwnerOrAdmin(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 
-      )).to.be.rejectedWith(/common\.NoPermission/);
-  
-      const properties = (await api.query.common.collectionProperties(collection)).toJSON();
-      expect(properties.map).to.be.empty;
-      expect(properties.consumedSpace).to.equal(0);
-    });  
+  async function testFailsSetPropertiesIfNotOwnerOrAdmin(collection: UniqueCollectionBase) {  
+    await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]))
+      .to.be.rejectedWith(/common\.NoPermission/);
+
+    expect(await collection.getProperties()).to.be.empty;
   }
-  it('Fails to set properties in a NFT collection if not its onwer/administrator', async () => {
-    await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'NFT'});
+
+  itSub('Fails to set properties in a NFT collection if not its onwer/administrator', async ({helper}) =>  {
+    await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.nft.mintCollection(alice));
   });
-  it('Fails to set properties in a ReFungible collection if not its onwer/administrator', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'ReFungible'});
+  itSub.ifWithPallets('Fails to set properties in a ReFungible collection if not its onwer/administrator', [Pallets.ReFungible], async ({helper}) => {
+    await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.rft.mintCollection(alice));
   });
   
-  async function testFailsSetPropertiesThatExeedLimits(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-      const spaceLimit = (await api.query.common.collectionProperties(collection)).toJSON().spaceLimit as number; 
+  async function testFailsSetPropertiesThatExeedLimits(collection: UniqueCollectionBase) {
+    const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber();
   
-      // Mute the general tx parsing error, too many bytes to process
-      {
-        console.error = () => {};
-        await expect(executeTransaction(
-          api, 
-          alice, 
-          api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}]), 
-        )).to.be.rejected;
-      }
-  
-      let properties = (await api.rpc.unique.collectionProperties(collection, ['electron'])).toJSON();
-      expect(properties).to.be.empty;
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collection, [
-          {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 
-          {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 
-        ]), 
-      )).to.be.rejectedWith(/common\.NoSpaceForProperty/);
-  
-      properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON();
-      expect(properties).to.be.empty;
-    });  
+    // Mute the general tx parsing error, too many bytes to process
+    {
+      console.error = () => {};
+      await expect(collection.setProperties(alice, [
+        {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))},
+      ])).to.be.rejected;
+    }
+
+    expect(await collection.getProperties(['electron'])).to.be.empty;
+
+    await expect(collection.setProperties(alice, [
+      {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 
+      {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 
+    ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);
+
+    expect(await collection.getProperties(['electron', 'black_hole'])).to.be.empty;
   }
-  it('Fails to set properties that exceed the limits (NFT)', async () => {
-    await testFailsSetPropertiesThatExeedLimits({type: 'NFT'});
+
+  itSub('Fails to set properties that exceed the limits (NFT)', async ({helper}) =>  {
+    await testFailsSetPropertiesThatExeedLimits(await helper.nft.mintCollection(alice));
   });
-  it('Fails to set properties that exceed the limits (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testFailsSetPropertiesThatExeedLimits({type: 'ReFungible'});
+  itSub.ifWithPallets('Fails to set properties that exceed the limits (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    await testFailsSetPropertiesThatExeedLimits(await helper.rft.mintCollection(alice));
   });
   
-  async function testFailsSetMorePropertiesThanAllowed(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      const propertiesToBeSet = [];
-      for (let i = 0; i < 65; i++) {
-        propertiesToBeSet.push({
-          key: 'electron_' + i,
-          value: Math.random() > 0.5 ? 'high' : 'low',
-        });
-      }
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collection, propertiesToBeSet), 
-      )).to.be.rejectedWith(/common\.PropertyLimitReached/);
-  
-      const properties = (await api.query.common.collectionProperties(collection)).toJSON();
-      expect(properties.map).to.be.empty;
-      expect(properties.consumedSpace).to.equal(0);
-    });  
+  async function testFailsSetMorePropertiesThanAllowed(collection: UniqueCollectionBase) {
+    const propertiesToBeSet = [];
+    for (let i = 0; i < 65; i++) {
+      propertiesToBeSet.push({
+        key: 'electron_' + i,
+        value: Math.random() > 0.5 ? 'high' : 'low',
+      });
+    }
+
+    await expect(collection.setProperties(alice, propertiesToBeSet)).
+      to.be.rejectedWith(/common\.PropertyLimitReached/);
+
+    expect(await collection.getProperties()).to.be.empty;
   }
-  it('Fails to set more properties than it is allowed (NFT)', async () => {
-    await testFailsSetMorePropertiesThanAllowed({type: 'NFT'});
+
+  itSub('Fails to set more properties than it is allowed (NFT)', async ({helper}) =>  {
+    await testFailsSetMorePropertiesThanAllowed(await helper.nft.mintCollection(alice));
   });
-  it('Fails to set more properties than it is allowed (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testFailsSetMorePropertiesThanAllowed({type: 'ReFungible'});
+  itSub.ifWithPallets('Fails to set more properties than it is allowed (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    await testFailsSetMorePropertiesThanAllowed(await helper.rft.mintCollection(alice));
   });
   
-  async function testFailsSetPropertiesWithInvalidNames(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      const invalidProperties = [
-        [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],
-        [{key: 'Mr/Sandman', value: 'Bring me a gene'}],
-        [{key: 'déjà vu', value: 'hmm...'}],
-      ];
-  
-      for (let i = 0; i < invalidProperties.length; i++) {
-        await expect(executeTransaction(
-          api, 
-          alice, 
-          api.tx.unique.setCollectionProperties(collection, invalidProperties[i]), 
-        ), `on rejecting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
-      }
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collection, [{key: '', value: 'nothing must not exist'}]), 
-      ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setCollectionProperties(collection, [
-          {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
-        ]), 
-      ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;
-  
-      const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');
-  
-      const properties = (await api.rpc.unique.collectionProperties(collection, keys)).toHuman();
-      expect(properties).to.be.deep.equal([
-        {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
-      ]);
-  
-      for (let i = 0; i < invalidProperties.length; i++) {
-        await expect(executeTransaction(
-          api, 
-          alice, 
-          api.tx.unique.deleteCollectionProperties(collection, invalidProperties[i].map(propertySet => propertySet.key)), 
-        ), `on trying to delete the non-existent badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
-      }
-    });
+  async function testFailsSetPropertiesWithInvalidNames(collection: UniqueCollectionBase) {
+    const invalidProperties = [
+      [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],
+      [{key: 'Mr/Sandman', value: 'Bring me a gene'}],
+      [{key: 'déjà vu', value: 'hmm...'}],
+    ];
+
+    for (let i = 0; i < invalidProperties.length; i++) {
+      await expect(
+        collection.setProperties(alice, invalidProperties[i]), 
+        `on rejecting the new badly-named property #${i}`,
+      ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
+    }
+
+    await expect(
+      collection.setProperties(alice, [{key: '', value: 'nothing must not exist'}]), 
+      'on rejecting an unnamed property',
+    ).to.be.rejectedWith(/common\.EmptyPropertyKey/);
+
+    await expect(
+      collection.setProperties(alice, [{key: 'CRISPR-Cas9', value: 'rewriting nature!'}]), 
+      'on setting the correctly-but-still-badly-named property',
+    ).to.be.fulfilled;
+
+    const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');
+
+    const properties = await collection.getProperties(keys);
+    expect(properties).to.be.deep.equal([
+      {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
+    ]);
+
+    for (let i = 0; i < invalidProperties.length; i++) {
+      await expect(
+        collection.deleteProperties(alice, invalidProperties[i].map(propertySet => propertySet.key)), 
+        `on trying to delete the non-existent badly-named property #${i}`,
+      ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
+    }
   }
-  it('Fails to set properties with invalid names (NFT)', async () => {
-    await testFailsSetPropertiesWithInvalidNames({type: 'NFT'});
+
+  itSub('Fails to set properties with invalid names (NFT)', async ({helper}) =>  {
+    await testFailsSetPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));
   });
-  it('Fails to set properties with invalid names (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testFailsSetPropertiesWithInvalidNames({type: 'ReFungible'});
+  itSub.ifWithPallets('Fails to set properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    await testFailsSetPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));
   });
 });
 
 // ---------- ACCESS RIGHTS
 
 describe('Integration Test: Access Rights to Token Properties', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
     });
   });
   
-  it('Reads access rights to properties of a collection', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess();
-      const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();
-      expect(propertyRights).to.be.empty;
-    });
+  itSub('Reads access rights to properties of a collection', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const propertyRights = (await helper.api!.query.common.collectionPropertyPermissions(collection.collectionId)).toJSON();
+    expect(propertyRights).to.be.empty;
   });
   
-  async function testSetsAccessRightsToProperties(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true}}]), 
-      )).to.not.be.rejected;
-  
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]), 
-      )).to.not.be.rejected;
-  
-      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery', 'mindgame'])).toHuman();
-      expect(propertyRights).to.be.deep.equal([
-        {key: 'skullduggery', permission: {'mutable': true, 'collectionAdmin': false, 'tokenOwner': false}},
-        {key: 'mindgame', permission: {'mutable': false, 'collectionAdmin': true, 'tokenOwner': false}},
-      ]);
-    });  
+  async function testSetsAccessRightsToProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {  
+    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true}}]))
+      .to.be.fulfilled;
+
+    await collection.addAdmin(alice, {Substrate: bob.address});
+
+    await expect(collection.setTokenPropertyPermissions(bob, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]))
+      .to.be.fulfilled;
+
+    const propertyRights = await collection.getPropertyPermissions(['skullduggery', 'mindgame']);
+    expect(propertyRights).to.include.deep.members([
+      {key: 'skullduggery', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}},
+      {key: 'mindgame', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
+    ]);
   }
-  it('Sets access rights to properties of a collection (NFT)', async () => {
-    await testSetsAccessRightsToProperties({type: 'NFT'});
+
+  itSub('Sets access rights to properties of a collection (NFT)', async ({helper}) =>  {
+    await testSetsAccessRightsToProperties(await helper.nft.mintCollection(alice));
   });
-  it('Sets access rights to properties of a collection (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testSetsAccessRightsToProperties({type: 'ReFungible'});
+  itSub.ifWithPallets('Sets access rights to properties of a collection (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    await testSetsAccessRightsToProperties(await helper.rft.mintCollection(alice));
   });
   
-  async function testChangesAccessRightsToProperty(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]), 
-      )).to.not.be.rejected;
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 
-      )).to.not.be.rejected;
-  
-      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();
-      expect(propertyRights).to.be.deep.equal([
-        {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
-      ]);
-    });
+  async function testChangesAccessRightsToProperty(collection: UniqueNFTCollection | UniqueRFTCollection) {
+    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]))
+      .to.be.fulfilled;
+
+    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))
+      .to.be.fulfilled;
+
+    const propertyRights = await collection.getPropertyPermissions();
+    expect(propertyRights).to.be.deep.equal([
+      {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
+    ]);
   }
-  it('Changes access rights to properties of a NFT collection', async () => {
-    await testChangesAccessRightsToProperty({type: 'NFT'});
+
+  itSub('Changes access rights to properties of a NFT collection', async ({helper}) =>  {
+    await testChangesAccessRightsToProperty(await helper.nft.mintCollection(alice));
   });
-  it('Changes access rights to properties of a ReFungible collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testChangesAccessRightsToProperty({type: 'ReFungible'});
+  itSub.ifWithPallets('Changes access rights to properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+    await testChangesAccessRightsToProperty(await helper.rft.mintCollection(alice));
   });
 });
 
 describe('Negative Integration Test: Access Rights to Token Properties', () => {
+  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([50n, 10n], donor);
     });
   });
 
-  async function testPreventsFromSettingAccessRightsNotAdminOrOwner(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]), 
-      )).to.be.rejectedWith(/common\.NoPermission/);
-  
-      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON();
-      expect(propertyRights).to.be.empty;
-    });
+  async function testPreventsFromSettingAccessRightsNotAdminOrOwner(collection: UniqueNFTCollection | UniqueRFTCollection) {
+    await expect(collection.setTokenPropertyPermissions(bob, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]))
+      .to.be.rejectedWith(/common\.NoPermission/);
+
+    const propertyRights = await collection.getPropertyPermissions(['skullduggery']);
+    expect(propertyRights).to.be.empty;
   }
-  it('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async () => {
-    await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'NFT'});
+
+  itSub('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async ({helper}) =>  {
+    await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.nft.mintCollection(alice));
   });
-  it('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'ReFungible'});
+  itSub.ifWithPallets('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', [Pallets.ReFungible], async ({helper}) => {
+    await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.rft.mintCollection(alice));
   });
 
-  async function testPreventFromAddingTooManyPossibleProperties(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      const constitution = [];
-      for (let i = 0; i < 65; i++) {
-        constitution.push({
-          key: 'property_' + i,
-          permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},
-        });
-      }
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, constitution), 
-      )).to.be.rejectedWith(/common\.PropertyLimitReached/);
-  
-      const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();
-      expect(propertyRights).to.be.empty;
-    });  
+  async function testPreventFromAddingTooManyPossibleProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {  
+    const constitution = [];
+    for (let i = 0; i < 65; i++) {
+      constitution.push({
+        key: 'property_' + i,
+        permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},
+      });
+    }
+
+    await expect(collection.setTokenPropertyPermissions(alice, constitution))
+      .to.be.rejectedWith(/common\.PropertyLimitReached/);
+
+    const propertyRights = await collection.getPropertyPermissions();
+    expect(propertyRights).to.be.empty;
   }
-  it('Prevents from adding too many possible properties (NFT)', async () => {
-    await testPreventFromAddingTooManyPossibleProperties({type: 'NFT'});
+
+  itSub('Prevents from adding too many possible properties (NFT)', async ({helper}) =>  {
+    await testPreventFromAddingTooManyPossibleProperties(await helper.nft.mintCollection(alice));
   });
-  it('Prevents from adding too many possible properties (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testPreventFromAddingTooManyPossibleProperties({type: 'ReFungible'});
+  itSub.ifWithPallets('Prevents from adding too many possible properties (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    await testPreventFromAddingTooManyPossibleProperties(await helper.rft.mintCollection(alice));
   });
 
-  async function testPreventAccessRightsModifiedIfConstant(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 
-      )).to.not.be.rejected;
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {}}]), 
-      )).to.be.rejectedWith(/common\.NoPermission/);
-  
-      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();
-      expect(propertyRights).to.deep.equal([
-        {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
-      ]);
-    });  
+  async function testPreventAccessRightsModifiedIfConstant(collection: UniqueNFTCollection | UniqueRFTCollection) {
+    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))
+      .to.be.fulfilled;
+
+    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {collectionAdmin: true}}]))
+      .to.be.rejectedWith(/common\.NoPermission/);
+
+    const propertyRights = await collection.getPropertyPermissions(['skullduggery']);
+    expect(propertyRights).to.deep.equal([
+      {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
+    ]);
   }
-  it('Prevents access rights to be modified if constant (NFT)', async () => {
-    await testPreventAccessRightsModifiedIfConstant({type: 'NFT'});
+
+  itSub('Prevents access rights to be modified if constant (NFT)', async ({helper}) =>  {
+    await testPreventAccessRightsModifiedIfConstant(await helper.nft.mintCollection(alice));
   });
-  it('Prevents access rights to be modified if constant (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testPreventAccessRightsModifiedIfConstant({type: 'ReFungible'});
+  itSub.ifWithPallets('Prevents access rights to be modified if constant (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    await testPreventAccessRightsModifiedIfConstant(await helper.rft.mintCollection(alice));
   });
 
-  async function testPreventsAddingPropertiesWithInvalidNames(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-  
-      const invalidProperties = [
-        [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],
-        [{key: 'G#4', permission: {tokenOwner: true}}],
-        [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],
-      ];
-  
-      for (let i = 0; i < invalidProperties.length; i++) {
-        await expect(executeTransaction(
-          api, 
-          alice, 
-          api.tx.unique.setTokenPropertyPermissions(collection, invalidProperties[i]), 
-        ), `on setting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
-      }
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: '', permission: {}}]), 
-      ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);
-  
-      const correctKey = '--0x03116e387820CA05'; // PolkadotJS would parse this as an already encoded hex-string
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [
-          {key: correctKey, permission: {collectionAdmin: true}},
-        ]), 
-      ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;
-  
-      const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');
-  
-      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, keys)).toHuman();
-      expect(propertyRights).to.be.deep.equal([
-        {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
-      ]);
-    });
+  async function testPreventsAddingPropertiesWithInvalidNames(collection: UniqueNFTCollection | UniqueRFTCollection) {
+    const invalidProperties = [
+      [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],
+      [{key: 'G#4', permission: {tokenOwner: true}}],
+      [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],
+    ];
+
+    for (let i = 0; i < invalidProperties.length; i++) {
+      await expect(
+        collection.setTokenPropertyPermissions(alice, invalidProperties[i]), 
+        `on setting the new badly-named property #${i}`,
+      ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
+    }
+
+    await expect(
+      collection.setTokenPropertyPermissions(alice, [{key: '', permission: {}}]), 
+      'on rejecting an unnamed property',
+    ).to.be.rejectedWith(/common\.EmptyPropertyKey/);
+
+    const correctKey = '--0x03116e387820CA05'; // PolkadotJS would parse this as an already encoded hex-string
+    await expect(
+      collection.setTokenPropertyPermissions(alice, [
+        {key: correctKey, permission: {collectionAdmin: true}},
+      ]), 
+      'on setting the correctly-but-still-badly-named property',
+    ).to.be.fulfilled;
+
+    const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');
+
+    const propertyRights = await collection.getPropertyPermissions(keys);
+    expect(propertyRights).to.be.deep.equal([
+      {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
+    ]);
   }
-  it('Prevents adding properties with invalid names (NFT)', async () => {
-    await testPreventsAddingPropertiesWithInvalidNames({type: 'NFT'});
+
+  itSub('Prevents adding properties with invalid names (NFT)', async ({helper}) =>  {
+    await testPreventsAddingPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));
   });
-  it('Prevents adding properties with invalid names (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testPreventsAddingPropertiesWithInvalidNames({type: 'ReFungible'});
+  itSub.ifWithPallets('Prevents adding properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    await testPreventsAddingPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));
   });
 });
 
 // ---------- TOKEN PROPERTIES
 
 describe('Integration Test: Token Properties', () => {
+  let alice: IKeyringPair; // collection owner
+  let bob: IKeyringPair; // collection admin
+  let charlie: IKeyringPair; // token owner
+
   let permissions: {permission: any, signers: IKeyringPair[]}[];
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice'); // collection owner
-      bob = privateKeyWrapper('//Bob'); // collection admin
-      charlie = privateKeyWrapper('//Charlie'); // token owner
-
-      permissions = [
-        {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},
-        {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},
-        {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},
-        {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},
-        {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
-        {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
-      ];
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
     });
+
+    // todo:playgrounds probably separate these tests later
+    permissions = [
+      {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},
+      {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},
+      {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},
+      {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},
+      {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
+      {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
+    ];
   });
-  
-  async function testReadsYetEmptyProperties(mode: CollectionMode) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-      const token = await createItemExpectSuccess(alice, collection, mode.type);
   
-      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
-      expect(properties.map).to.be.empty;
-      expect(properties.consumedSpace).to.be.equal(0);
-  
-      const tokenData = (await api.rpc.unique.tokenData(collection, token, ['anything'])).toJSON().properties;
-      expect(tokenData).to.be.empty;
-    });
+  async function testReadsYetEmptyProperties(token: UniqueNFTToken | UniqueRFTToken) {
+    const properties = await token.getProperties();
+    expect(properties).to.be.empty;
+
+    const tokenData = await token.getData();
+    expect(tokenData!.properties).to.be.empty;
   }
-  it('Reads yet empty properties of a token (NFT)', async () => {
-    await testReadsYetEmptyProperties({type: 'NFT'});
-  });
-  it('Reads yet empty properties of a token (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testReadsYetEmptyProperties({type: 'ReFungible'});
+  itSub('Reads yet empty properties of a token (NFT)', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testReadsYetEmptyProperties(token);
   });
 
-  async function testAssignPropertiesAccordingToPermissions(mode: CollectionMode, pieces: number) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-      const token = await createItemExpectSuccess(alice, collection, mode.type);
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
+  itSub.ifWithPallets('Reads yet empty properties of a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testReadsYetEmptyProperties(token);
+  });
 
-      const propertyKeys: string[] = [];
-      let i = 0;
-      for (const permission of permissions) {
-        for (const signer of permission.signers) {
-          const key = i + '_' + signer.address;
-          propertyKeys.push(key);
+  async function testAssignPropertiesAccordingToPermissions(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint) {
+    await token.collection.addAdmin(alice, {Substrate: bob.address});
+    await token.transfer(alice, {Substrate: charlie.address}, pieces);
 
-          await expect(executeTransaction(
-            api, 
-            alice, 
-            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
-          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
+    const propertyKeys: string[] = [];
+    let i = 0;
+    for (const permission of permissions) {
+      i++;
+      let j = 0;
+      for (const signer of permission.signers) {
+        j++;
+        const key = i + '_' + signer.address;
+        propertyKeys.push(key);
 
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
-          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-        }
+        await expect(
+          token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
+          `on setting permission #${i} by alice`,
+        ).to.be.fulfilled;
 
-        i++;
+        await expect(
+          token.setProperties(signer, [{key: key, value: 'Serotonin increase'}]), 
+          `on adding property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
       }
+    }
 
-      const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];
-      const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];
-      for (let i = 0; i < properties.length; i++) {
-        expect(properties[i].value).to.be.equal('Serotonin increase');
-        expect(tokensData[i].value).to.be.equal('Serotonin increase');
-      }
-    });
+    const properties = await token.getProperties(propertyKeys);
+    const tokenData = await token.getData();
+    for (let i = 0; i < properties.length; i++) {
+      expect(properties[i].value).to.be.equal('Serotonin increase');
+      expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');
+    }
   }
-  it('Assigns properties to a token according to permissions (NFT)', async () => {
-    await testAssignPropertiesAccordingToPermissions({type: 'NFT'}, 1);
+
+  itSub('Assigns properties to a token according to permissions (NFT)', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testAssignPropertiesAccordingToPermissions(token, 1n);
   });
-  it('Assigns properties to a token according to permissions (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testAssignPropertiesAccordingToPermissions({type: 'ReFungible'}, 100);
+  itSub.ifWithPallets('Assigns properties to a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    await testAssignPropertiesAccordingToPermissions(token, 100n);
   });
 
-  async function testChangesPropertiesAccordingPermission(mode: CollectionMode, pieces: number) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-      const token = await createItemExpectSuccess(alice, collection, mode.type);
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
+  async function testChangesPropertiesAccordingPermission(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint) {
+    await token.collection.addAdmin(alice, {Substrate: bob.address});
+    await token.transfer(alice, {Substrate: charlie.address}, pieces);
+
+    const propertyKeys: string[] = [];
+    let i = 0;
+    for (const permission of permissions) {
+      i++;
+      if (!permission.permission.mutable) continue;
+      
+      let j = 0;
+      for (const signer of permission.signers) {
+        j++;
+        const key = i + '_' + signer.address;
+        propertyKeys.push(key);
+
+        await expect(
+          token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
+          `on setting permission #${i} by alice`,
+        ).to.be.fulfilled;
+
+        await expect(
+          token.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
+          `on adding property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
 
-      const propertyKeys: string[] = [];
-      let i = 0;
-      for (const permission of permissions) {
-        if (!permission.permission.mutable) continue;
-        
-        for (const signer of permission.signers) {
-          const key = i + '_' + signer.address;
-          propertyKeys.push(key);
-  
-          await expect(executeTransaction(
-            api, 
-            alice, 
-            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
-          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
-  
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
-          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-  
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin stable'}]), 
-          ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;
-        }
-  
-        i++;
+        await expect(
+          token.setProperties(signer, [{key, value: 'Serotonin stable'}]), 
+          `on changing property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
       }
-  
-      const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];
-      const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];
-      for (let i = 0; i < properties.length; i++) {
-        expect(properties[i].value).to.be.equal('Serotonin stable');
-        expect(tokensData[i].value).to.be.equal('Serotonin stable');
-      }
-    });
+    }
+
+    const properties = await token.getProperties(propertyKeys);
+    const tokenData = await token.getData();
+    for (let i = 0; i < properties.length; i++) {
+      expect(properties[i].value).to.be.equal('Serotonin stable');
+      expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');
+    }
   }
-  it('Changes properties of a token according to permissions (NFT)', async () => {
-    await testChangesPropertiesAccordingPermission({type: 'NFT'}, 1);
+
+  itSub('Changes properties of a token according to permissions (NFT)', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testChangesPropertiesAccordingPermission(token, 1n);
   });
-  it('Changes properties of a token according to permissions (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testChangesPropertiesAccordingPermission({type: 'ReFungible'}, 100);
+  itSub.ifWithPallets('Changes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    await testChangesPropertiesAccordingPermission(token, 100n);
   });
 
-  async function testDeletePropertiesAccordingPermission(mode: CollectionMode, pieces: number) {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: mode});
-      const token = await createItemExpectSuccess(alice, collection, mode.type);
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
+  async function testDeletePropertiesAccordingPermission(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint) {
+    await token.collection.addAdmin(alice, {Substrate: bob.address});
+    await token.transfer(alice, {Substrate: charlie.address}, pieces);
+
+    const propertyKeys: string[] = [];
+    let i = 0;
+
+    for (const permission of permissions) {
+      i++;
+      if (!permission.permission.mutable) continue;
+      
+      let j = 0;
+      for (const signer of permission.signers) {
+        j++;
+        const key = i + '_' + signer.address;
+        propertyKeys.push(key);
+
+        await expect(
+          token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
+          `on setting permission #${i} by alice`,
+        ).to.be.fulfilled;
 
-      const propertyKeys: string[] = [];
-      let i = 0;
-  
-      for (const permission of permissions) {
-        if (!permission.permission.mutable) continue;
-        
-        for (const signer of permission.signers) {
-          const key = i + '_' + signer.address;
-          propertyKeys.push(key);
-  
-          await expect(executeTransaction(
-            api, 
-            alice, 
-            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
-          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
-  
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
-          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-  
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.deleteTokenProperties(collection, token, [key]), 
-          ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;
-        }
-        
-        i++;
+        await expect(
+          token.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
+          `on adding property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
+
+        await expect(
+          token.deleteProperties(signer, [key]), 
+          `on deleting property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
       }
-  
-      const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[];
-      expect(properties).to.be.empty;
-      const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[];
-      expect(tokensData).to.be.empty;
-      expect((await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace).to.be.equal(0);
-    });
+    }
+
+    expect(await token.getProperties(propertyKeys)).to.be.empty;
+    expect((await token.getData())!.properties).to.be.empty;
   }
-  it('Deletes properties of a token according to permissions (NFT)', async () => {
-    await testDeletePropertiesAccordingPermission({type: 'NFT'}, 1);
+  
+  itSub('Deletes properties of a token according to permissions (NFT)', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testDeletePropertiesAccordingPermission(token, 1n);
   });
-  it('Deletes properties of a token according to permissions (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testDeletePropertiesAccordingPermission({type: 'ReFungible'}, 100);
+  itSub.ifWithPallets('Deletes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    await testDeletePropertiesAccordingPermission(token, 100n);
   });
 
-  it('Assigns properties to a nested token according to permissions', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      const token = await createItemExpectSuccess(alice, collection, 'NFT');
-      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      await transferExpectSuccess(collection, token, alice, charlie);
+  itSub('Assigns properties to a nested token according to permissions', async ({helper}) =>  {
+    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    const collectionB = await helper.nft.mintCollection(alice);
+    const targetToken = await collectionA.mintToken(alice);
+    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAddress());
 
-      const propertyKeys: string[] = [];
-      let i = 0;
-      for (const permission of permissions) {
-        for (const signer of permission.signers) {
-          const key = i + '_' + signer.address;
-          propertyKeys.push(key);
+    await collectionB.addAdmin(alice, {Substrate: bob.address});
+    await targetToken.transfer(alice, {Substrate: charlie.address});
 
-          await expect(executeTransaction(
-            api, 
-            alice, 
-            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
-          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
+    const propertyKeys: string[] = [];
+    let i = 0;
+    for (const permission of permissions) {
+      i++;
+      let j = 0;
+      for (const signer of permission.signers) {
+        j++;
+        const key = i + '_' + signer.address;
+        propertyKeys.push(key);
+        
+        await expect(
+          nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
+          `on setting permission #${i} by alice`,
+        ).to.be.fulfilled;
 
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 
-          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-        }
-
-        i++;
+        await expect(
+          nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
+          `on adding property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
       }
 
-      const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];
-      const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];
-      for (let i = 0; i < properties.length; i++) {
-        expect(properties[i].value).to.be.equal('Serotonin increase');
-        expect(tokensData[i].value).to.be.equal('Serotonin increase');
-      }
-    });
+    }
+
+    const properties = await nestedToken.getProperties(propertyKeys);
+    const tokenData = await nestedToken.getData();
+    for (let i = 0; i < properties.length; i++) {
+      expect(properties[i].value).to.be.equal('Serotonin increase');
+      expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');
+    }
+    expect(await targetToken.getProperties()).to.be.empty;
   });
 
-  it('Changes properties of a nested token according to permissions', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      const token = await createItemExpectSuccess(alice, collection, 'NFT');
-      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      await transferExpectSuccess(collection, token, alice, charlie);
+  itSub('Changes properties of a nested token according to permissions', async ({helper}) =>  {
+    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    const collectionB = await helper.nft.mintCollection(alice);
+    const targetToken = await collectionA.mintToken(alice);
+    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAddress());
 
-      const propertyKeys: string[] = [];
-      let i = 0;
-      for (const permission of permissions) {
-        if (!permission.permission.mutable) continue;
-        
-        for (const signer of permission.signers) {
-          const key = i + '_' + signer.address;
-          propertyKeys.push(key);
+    await collectionB.addAdmin(alice, {Substrate: bob.address});
+    await targetToken.transfer(alice, {Substrate: charlie.address});
 
-          await expect(executeTransaction(
-            api, 
-            alice, 
-            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
-          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
+    const propertyKeys: string[] = [];
+    let i = 0;
+    for (const permission of permissions) {
+      i++;
+      if (!permission.permission.mutable) continue;
+      
+      let j = 0;
+      for (const signer of permission.signers) {
+        j++;
+        const key = i + '_' + signer.address;
+        propertyKeys.push(key);
 
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 
-          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
+        await expect(
+          nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
+          `on setting permission #${i} by alice`,
+        ).to.be.fulfilled;
 
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin stable'}]), 
-          ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;
-        }
+        await expect(
+          nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
+          `on adding property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
 
-        i++;
+        await expect(
+          nestedToken.setProperties(signer, [{key, value: 'Serotonin stable'}]), 
+          `on changing property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
       }
+    }
 
-      const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];
-      const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];
-      for (let i = 0; i < properties.length; i++) {
-        expect(properties[i].value).to.be.equal('Serotonin stable');
-        expect(tokensData[i].value).to.be.equal('Serotonin stable');
-      }
-    });
+    const properties = await nestedToken.getProperties(propertyKeys);
+    const tokenData = await nestedToken.getData();
+    for (let i = 0; i < properties.length; i++) {
+      expect(properties[i].value).to.be.equal('Serotonin stable');
+      expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');
+    }
+    expect(await targetToken.getProperties()).to.be.empty;
   });
 
-  it('Deletes properties of a nested token according to permissions', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      const token = await createItemExpectSuccess(alice, collection, 'NFT');
-      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      await transferExpectSuccess(collection, token, alice, charlie);
+  itSub('Deletes properties of a nested token according to permissions', async ({helper}) =>  {
+    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    const collectionB = await helper.nft.mintCollection(alice);
+    const targetToken = await collectionA.mintToken(alice);
+    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAddress());
 
-      const propertyKeys: string[] = [];
-      let i = 0;
+    await collectionB.addAdmin(alice, {Substrate: bob.address});
+    await targetToken.transfer(alice, {Substrate: charlie.address});
 
-      for (const permission of permissions) {
-        if (!permission.permission.mutable) continue;
-        
-        for (const signer of permission.signers) {
-          const key = i + '_' + signer.address;
-          propertyKeys.push(key);
+    const propertyKeys: string[] = [];
+    let i = 0;
+    for (const permission of permissions) {
+      i++;
+      if (!permission.permission.mutable) continue;
+      
+      let j = 0;
+      for (const signer of permission.signers) {
+        j++;
+        const key = i + '_' + signer.address;
+        propertyKeys.push(key);
 
-          await expect(executeTransaction(
-            api, 
-            alice, 
-            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
-          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
+        await expect(
+          nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
+          `on setting permission #${i} by alice`,
+        ).to.be.fulfilled;
 
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 
-          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
+        await expect(
+          nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
+          `on adding property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
 
-          await expect(executeTransaction(
-            api, 
-            signer, 
-            api.tx.unique.deleteTokenProperties(collection, nestedToken, [key]), 
-          ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;
-        }
-        
-        i++;
+        await expect(
+          nestedToken.deleteProperties(signer, [key]), 
+          `on deleting property #${i} by signer #${j}`,
+        ).to.be.fulfilled;
       }
+    }
 
-      const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toJSON() as any[];
-      expect(properties).to.be.empty;
-      const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toJSON().properties as any[];
-      expect(tokensData).to.be.empty;
-      expect((await api.query.nonfungible.tokenProperties(collection, nestedToken)).toJSON().consumedSpace).to.be.equal(0);
-    });
+    expect(await nestedToken.getProperties(propertyKeys)).to.be.empty;
+    expect((await nestedToken.getData())!.properties).to.be.empty;
+    expect(await targetToken.getProperties()).to.be.empty;
   });
 });
 
 describe('Negative Integration Test: Token Properties', () => {
-  let collection: number;
-  let token: number;
-  let originalSpace: number;
+  let alice: IKeyringPair; // collection owner
+  let bob: IKeyringPair; // collection admin
+  let charlie: IKeyringPair; // token owner
+
   let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      charlie = privateKeyWrapper('//Charlie');
-      const dave = privateKeyWrapper('//Dave');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      let dave: IKeyringPair;
+      [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor);
 
+      // todo:playgrounds probably separate these tests later
       constitution = [
         {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},
         {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},
@@ -1010,278 +804,255 @@
     });
   });
 
-  async function prepare(mode: CollectionMode, pieces: number) {
-    collection = await createCollectionExpectSuccess({mode: mode});
-    token = await createItemExpectSuccess(alice, collection, mode.type);
-    await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-    await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
-        
-    await usingApi(async api => {
-      let i = 0;
-      for (const passage of constitution) {
-        const signer = passage.signers[0];
-        
-        await expect(executeTransaction(
-          api, 
-          alice, 
-          api.tx.unique.setTokenPropertyPermissions(collection, [{key: `${i}`, permission: passage.permission}]), 
-        ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
-  
-        await expect(executeTransaction(
-          api, 
-          signer, 
-          api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin increase'}]), 
-        ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
-  
-        i++;
-      }
-  
-      originalSpace = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace as number;
-    }); 
+  async function getConsumedSpace(api: any, collectionId: number, tokenId: number, mode: 'NFT' | 'RFT'): Promise<number> {
+    return (await (mode == 'NFT' ? api.query.nonfungible : api.query.refungible).tokenProperties(collectionId, tokenId)).toJSON().consumedSpace;
+  }
+
+  async function prepare(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint): Promise<number> {
+    await token.collection.addAdmin(alice, {Substrate: bob.address});
+    await token.transfer(alice, {Substrate: charlie.address}, pieces);
+
+    let i = 0;
+    for (const passage of constitution) {
+      i++;
+      const signer = passage.signers[0];
+      
+      await expect(
+        token.collection.setTokenPropertyPermissions(alice, [{key: `${i}`, permission: passage.permission}]), 
+        `on setting permission ${i} by alice`,
+      ).to.be.fulfilled;
+
+      await expect(
+        token.setProperties(signer, [{key: `${i}`, value: 'Serotonin increase'}]), 
+        `on adding property ${i} by ${signer.address}`,
+      ).to.be.fulfilled;
+    }
+
+    const originalSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
+    return originalSpace;
   }
 
-  async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(mode: CollectionMode, pieces: number) {
-    await prepare(mode, pieces);
-  
-    await usingApi(async api => {
-      let i = -1;
-      for (const forbiddance of constitution) {
-        i++;
-        if (!forbiddance.permission.mutable) continue;
-  
-        await expect(executeTransaction(
-          api, 
-          forbiddance.sinner, 
-          api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 
-        ), `on failing to change property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);
-  
-        await expect(executeTransaction(
-          api, 
-          forbiddance.sinner, 
-          api.tx.unique.deleteTokenProperties(collection, token, [`${i}`]), 
-        ), `on failing to delete property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);
-      }
-  
-      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
-      expect(properties.consumedSpace).to.be.equal(originalSpace);
-    });
+  async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint) {
+    const originalSpace = await prepare(token, pieces);
+
+    let i = 0;
+    for (const forbiddance of constitution) {
+      i++;
+      if (!forbiddance.permission.mutable) continue;
+
+      await expect(
+        token.setProperties(forbiddance.sinner, [{key: `${i}`, value: 'Serotonin down'}]), 
+        `on failing to change property ${i} by the malefactor`,
+      ).to.be.rejectedWith(/common\.NoPermission/);
+
+      await expect(
+        token.deleteProperties(forbiddance.sinner, [`${i}`]), 
+        `on failing to delete property ${i} by the malefactor`,
+      ).to.be.rejectedWith(/common\.NoPermission/);
+    }
+
+    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
+    expect(consumedSpace).to.be.equal(originalSpace);
   }
-  it('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async () => {
-    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'NFT'}, 1);
+
+  itSub('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 1n);
   });
-  it('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'ReFungible'}, 100);
+  itSub.ifWithPallets('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 100n);
   });
 
-  async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(mode: CollectionMode, pieces: number) {
-    await prepare(mode, pieces);
-    
-    await usingApi(async api => {
-      let i = -1;
-      for (const permission of constitution) {
-        i++;
-        if (permission.permission.mutable) continue;
-  
-        await expect(executeTransaction(
-          api, 
-          permission.signers[0], 
-          api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 
-        ), `on failing to change property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);
+  async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint) {
+    const originalSpace = await prepare(token, pieces);
+
+    let i = 0;
+    for (const permission of constitution) {
+      i++;
+      if (permission.permission.mutable) continue;
+
+      await expect(
+        token.setProperties(permission.signers[0], [{key: `${i}`, value: 'Serotonin down'}]), 
+        `on failing to change property ${i} by signer #0`,
+      ).to.be.rejectedWith(/common\.NoPermission/);
+
+      await expect(
+        token.deleteProperties(permission.signers[0], [i.toString()]), 
+        `on failing to delete property ${i} by signer #0`,
+      ).to.be.rejectedWith(/common\.NoPermission/);
+    }
   
-        await expect(executeTransaction(
-          api, 
-          permission.signers[0], 
-          api.tx.unique.deleteTokenProperties(collection, token, [i.toString()]), 
-        ), `on failing to delete property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);
-      }
-  
-      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
-      expect(properties.consumedSpace).to.be.equal(originalSpace);
-    });  
+    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
+    expect(consumedSpace).to.be.equal(originalSpace);
   }
-  it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async () => {
-    await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'NFT'}, 1);
+
+  itSub('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 1n);
   });
-  it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'ReFungible'}, 100);
+  itSub.ifWithPallets('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 100n);
   });
 
-  async function testForbidsAddingPropertiesIfPropertyNotDeclared(mode: CollectionMode, pieces: number) {
-    await prepare(mode, pieces);
+  async function testForbidsAddingPropertiesIfPropertyNotDeclared(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint) {
+    const originalSpace = await prepare(token, pieces);
 
-    await usingApi(async api => {
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(collection, token, [{key: 'non-existent', value: 'I exist!'}]), 
-      ), 'on failing to add a previously non-existent property').to.be.rejectedWith(/common\.NoPermission/);
-        
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'now-existent', permission: {}}]), 
-      ), 'on setting a new non-permitted property').to.not.be.rejected;
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(collection, token, [{key: 'now-existent', value: 'I exist!'}]), 
-      ), 'on failing to add a property forbidden by the \'None\' permission').to.be.rejectedWith(/common\.NoPermission/);
-  
-      expect((await api.rpc.unique.tokenProperties(collection, token, ['non-existent', 'now-existent'])).toJSON()).to.be.empty;
-      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
-      expect(properties.consumedSpace).to.be.equal(originalSpace);
-    });
+    await expect(
+      token.setProperties(alice, [{key: 'non-existent', value: 'I exist!'}]), 
+      'on failing to add a previously non-existent property',
+    ).to.be.rejectedWith(/common\.NoPermission/);
+      
+    await expect(
+      token.collection.setTokenPropertyPermissions(alice, [{key: 'now-existent', permission: {}}]), 
+      'on setting a new non-permitted property',
+    ).to.be.fulfilled;
+
+    await expect(
+      token.setProperties(alice, [{key: 'now-existent', value: 'I exist!'}]), 
+      'on failing to add a property forbidden by the \'None\' permission',
+    ).to.be.rejectedWith(/common\.NoPermission/);
+
+    expect(await token.getProperties(['non-existent', 'now-existent'])).to.be.empty;
+      
+    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
+    expect(consumedSpace).to.be.equal(originalSpace);
   }
-  it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async () => {
-    await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'NFT'}, 1);
+
+  itSub('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 1n);
   });
-  it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'ReFungible'}, 100);
+  itSub.ifWithPallets('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 100n);
   });
 
-  async function testForbidsAddingTooManyProperties(mode: CollectionMode, pieces: number) {
-    await prepare(mode, pieces);
+  async function testForbidsAddingTooManyProperties(token: UniqueNFTToken | UniqueRFTToken, pieces: bigint) {
+    const originalSpace = await prepare(token, pieces);
+
+    await expect(
+      token.collection.setTokenPropertyPermissions(alice, [
+        {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 
+        {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},
+      ]), 
+      'on setting new permissions for properties',
+    ).to.be.fulfilled;
+
+    // Mute the general tx parsing error
+    {
+      console.error = () => {};
+      await expect(token.setProperties(alice, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]))
+        .to.be.rejected;
+    }
 
-    await usingApi(async api => {
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [
-          {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 
-          {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},
-        ]), 
-      ), 'on setting a new non-permitted property').to.not.be.rejected;
+    await expect(token.setProperties(alice, [
+      {key: 'a_holy_book', value: 'word '.repeat(3277)}, 
+      {key: 'young_years', value: 'neverending'.repeat(1490)},
+    ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);
   
-      // Mute the general tx parsing error
-      {
-        console.error = () => {};
-        await expect(executeTransaction(
-          api, 
-          alice, 
-          api.tx.unique.setCollectionProperties(collection, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]), 
-        )).to.be.rejected;
-      }
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(collection, token, [
-          {key: 'a_holy_book', value: 'word '.repeat(3277)}, 
-          {key: 'young_years', value: 'neverending'.repeat(1490)},
-        ]), 
-      )).to.be.rejectedWith(/common\.NoSpaceForProperty/);
-  
-      expect((await api.rpc.unique.tokenProperties(collection, token, ['a_holy_book', 'young_years'])).toJSON()).to.be.empty;
-      const propertiesMap = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
-      expect(propertiesMap.consumedSpace).to.be.equal(originalSpace);
-    });
+    expect(await token.getProperties(['a_holy_book', 'young_years'])).to.be.empty;
+    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
+    expect(consumedSpace).to.be.equal(originalSpace);
   }
-  it('Forbids adding too many properties to a token (NFT)', async () => {
-    await testForbidsAddingTooManyProperties({type: 'NFT'}, 1);
+
+  itSub('Forbids adding too many properties to a token (NFT)', async ({helper}) =>  {
+    const collection = await helper.nft.mintCollection(alice);
+    const token = await collection.mintToken(alice);
+    await testForbidsAddingTooManyProperties(token, 1n);
   });
-  it('Forbids adding too many properties to a token (ReFungible)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await testForbidsAddingTooManyProperties({type: 'ReFungible'}, 100);
+  itSub.ifWithPallets('Forbids adding too many properties to a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    await testForbidsAddingTooManyProperties(token, 100n);
   });
 });
 
 describe('ReFungible token properties permissions tests', () => {
-  let collection: number;
-  let token: number;
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  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([100n, 100n, 100n], donor);
     });
   });
 
-  beforeEach(async () => {
-    await usingApi(async api => {
-      collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      token = await createItemExpectSuccess(alice, collection, 'ReFungible');
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
+  async function prepare(helper: UniqueHelper): Promise<UniqueRFTToken> {
+    const collection = await helper.rft.mintCollection(alice);
+    const token = await collection.mintToken(alice, 100n);
+    
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    await collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable: true, tokenOwner: true}}]);
+    
+    return token;
+  }
 
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 
-      )).to.not.be.rejected;
-    });
+  itSub('Forbids adding token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) =>  {
+    const token = await prepare(helper);
+
+    await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+    await expect(token.setProperties(alice, [
+      {key: 'fractals', value: 'multiverse'}, 
+    ])).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Forbids add token property with tokenOwher==true but signer have\'t all pieces', async () => {
-    await usingApi(async api => {
-      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(collection, token, [
-          {key: 'key', value: 'word'}, 
-        ]), 
-      )).to.be.rejectedWith(/common\.NoPermission/);
-    });
+  itSub('Forbids mutating token property with tokenOwher==true when signer doesn\'t have all pieces', async ({helper}) =>  {
+    const token = await prepare(helper);
+
+    await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, tokenOwner: true}}]))
+      .to.be.fulfilled;
+
+    await expect(token.setProperties(alice, [
+      {key: 'fractals', value: 'multiverse'}, 
+    ])).to.be.fulfilled;
+
+    await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+    await expect(token.setProperties(alice, [
+      {key: 'fractals', value: 'want to rule the world'}, 
+    ])).to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Forbids mutate token property with tokenOwher==true but signer have\'t all pieces', async () => {
-    await usingApi(async api => {
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 
-      )).to.not.be.rejected;
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(collection, token, [
-          {key: 'key', value: 'word'}, 
-        ]), 
-      )).to.be.not.rejected;
+  itSub('Forbids deleting token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) =>  {
+    const token = await prepare(helper);
 
-      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(collection, token, [
-          {key: 'key', value: 'bad word'}, 
-        ]), 
-      )).to.be.rejectedWith(/common\.NoPermission/);
-    });
+    await expect(token.setProperties(alice, [
+      {key: 'fractals', value: 'one headline - why believe it'}, 
+    ])).to.be.fulfilled;
+
+    await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+    await expect(token.deleteProperties(alice, ['fractals'])).
+      to.be.rejectedWith(/common\.NoPermission/);
   });
 
-  it('Forbids delete token property with tokenOwher==true but signer have\'t all pieces', async () => {
-    await usingApi(async api => {
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.setTokenProperties(collection, token, [
-          {key: 'key', value: 'word'}, 
-        ]), 
-      )).to.be.not.rejected;
+  itSub('Allows token property mutation with collectionOwner==true when admin doesn\'t have all pieces', async ({helper}) =>  {
+    const token = await prepare(helper);
+
+    await token.transfer(alice, {Substrate: charlie.address}, 33n);
+
+    await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, collectionAdmin: true}}]))
+      .to.be.fulfilled;
 
-      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');
-  
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.deleteTokenProperties(collection, token, [
-          'key',
-        ]), 
-      )).to.be.rejectedWith(/common\.NoPermission/);
-    });
+    await expect(token.setProperties(alice, [
+      {key: 'fractals', value: 'multiverse'}, 
+    ])).to.be.fulfilled;
   });
 });