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

--- 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.getTokenAddress({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, UniqueNFToken} 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<UniqueNFToken[]> {
+  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].nestingAccount(), tokens[7].nestingAccount()),
+      '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() => {

--- a/tests/src/nesting/nest.test.ts
+++ b/tests/src/nesting/nest.test.ts
@@ -1,840 +1,667 @@
-import {expect} from 'chai';
-import {tokenIdToAddress} from '../eth/util/helpers';
-import usingApi, {executeTransaction} from '../substrate/substrate-api';
-import {
-  addCollectionAdminExpectSuccess,
-  addToAllowListExpectSuccess,
-  createCollectionExpectSuccess,
-  createItemExpectSuccess,
-  enableAllowListExpectSuccess,
-  enablePublicMintingExpectSuccess,
-  getTokenChildren,
-  getTokenOwner,
-  getTopmostTokenOwner,
-  normalizeAccountId,
-  setCollectionPermissionsExpectSuccess,
-  transferExpectFailure,
-  transferExpectSuccess,
-  transferFromExpectSuccess,
-  setCollectionLimitsExpectSuccess,
-  requirePallets,
-  Pallets,
-} from '../util/helpers';
-import {IKeyringPair} from '@polkadot/types/types';
+// 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.
 
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let charlie: IKeyringPair;
+// 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, itSub, Pallets, usingPlaygrounds} from '../util/playgrounds';
+
 describe('Integration Test: Composite nesting tests', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (_, 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);
     });
   });
 
-  it('Performs the full suite: bundles a token, transfers, and unnests', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+  itSub('Performs the full suite: bundles a token, transfers, and unnests', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    const targetToken = await collection.mintToken(alice);
 
-      // Create a nested token
-      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+    // Create an immediately nested token
+    const nestedToken = await collection.mintToken(alice, targetToken.nestingAccount());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
+    
+    // Create a token to be nested
+    const newToken = await collection.mintToken(alice);
 
-      // Create a token to be nested
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
-
-      // Nest
-      await transferExpectSuccess(collection, newToken, alice, {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+    // Nest
+    await newToken.nest(alice, targetToken);
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
 
-      // Move bundle to different user
-      await transferExpectSuccess(collection, targetToken, alice, {Substrate: bob.address});
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: bob.address});
-      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+    // Move bundle to different user
+    await targetToken.transfer(alice, {Substrate: bob.address});
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
 
-      // Unnest
-      await transferFromExpectSuccess(collection, newToken, bob, {Ethereum: tokenIdToAddress(collection, targetToken)}, {Substrate: bob.address});
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
-    });
+    // Unnest
+    await newToken.unnest(bob, targetToken, {Substrate: bob.address});
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
+    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});
   });
-
-  it('Transfers an already bundled token', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
 
-      const tokenA = await createItemExpectSuccess(alice, collection, 'NFT');
-      const tokenB = await createItemExpectSuccess(alice, collection, 'NFT');
-
-      // Create a nested token
-      const tokenC = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, tokenA)});
-      expect(await getTopmostTokenOwner(api, collection, tokenC)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, tokenC)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, tokenA).toLowerCase()});
+  itSub('Transfers an already bundled token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    const tokenA = await collection.mintToken(alice);
+    const tokenB = await collection.mintToken(alice);
 
-      // Transfer the nested token to another token
-      await expect(executeTransaction(
-        api,
-        alice,
-        api.tx.unique.transferFrom(
-          normalizeAccountId({Ethereum: tokenIdToAddress(collection, tokenA)}),
-          normalizeAccountId({Ethereum: tokenIdToAddress(collection, tokenB)}),
-          collection,
-          tokenC,
-          1,
-        ),
-      )).to.not.be.rejected;
-      expect(await getTopmostTokenOwner(api, collection, tokenC)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, tokenC)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, tokenB).toLowerCase()});
-    });
+    // Create a nested token
+    const tokenC = await collection.mintToken(alice, tokenA.nestingAccount());
+    expect(await tokenC.getOwner()).to.be.deep.equal(tokenA.nestingAccountInLowerCase());
+    
+    // Transfer the nested token to another token
+    await expect(tokenC.transferFrom(alice, tokenA.nestingAccount(), tokenB.nestingAccount())).to.be.fulfilled;
+    expect(await tokenC.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
+    expect(await tokenC.getOwner()).to.be.deep.equal(tokenB.nestingAccountInLowerCase());
   });
 
-  it('Checks token children', async () => {
-    await usingApi(async api => {
-      const collectionA = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionLimitsExpectSuccess(alice, collectionA, {ownerCanTransfer: true});
-      await setCollectionPermissionsExpectSuccess(alice, collectionA, {nesting: {tokenOwner: true}});
-      const collectionB = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+  itSub('Checks token children', async ({helper}) => {
+    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    const collectionB = await helper.ft.mintCollection(alice);
+    
+    const targetToken = await collectionA.mintToken(alice);
+    expect((await targetToken.getChildren()).length).to.be.equal(0, 'Children length check at creation');
 
-      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionA, targetToken)};
-      let children = await getTokenChildren(api, collectionA, targetToken);
-      expect(children.length).to.be.equal(0, 'Children length check at creation');
+    // Create a nested NFT token
+    const tokenA = await collectionA.mintToken(alice, targetToken.nestingAccount());
+    expect(await targetToken.getChildren()).to.have.deep.members([
+      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
+    ], 'Children contents check at nesting #1').and.be.length(1, 'Children length check at nesting #1');
 
-      // Create a nested NFT token
-      const tokenA = await createItemExpectSuccess(alice, collectionA, 'NFT', targetAddress);
-      children = await getTokenChildren(api, collectionA, targetToken);
-      expect(children.length).to.be.equal(1, 'Children length check at nesting #1');
-      expect(children).to.have.deep.members([
-        {token: tokenA, collection: collectionA},
-      ], 'Children contents check at nesting #1');
+    // Create then nest
+    const tokenB = await collectionA.mintToken(alice);
+    await tokenB.nest(alice, targetToken);
+    expect(await targetToken.getChildren()).to.have.deep.members([
+      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
+      {tokenId: tokenB.tokenId, collectionId: collectionA.collectionId},
+    ], 'Children contents check at nesting #2').and.be.length(2, 'Children length check at nesting #2');
 
-      // Create then nest
-      const tokenB = await createItemExpectSuccess(alice, collectionA, 'NFT');
-      await transferExpectSuccess(collectionA, tokenB, alice, targetAddress);
-      children = await getTokenChildren(api, collectionA, targetToken);
-      expect(children.length).to.be.equal(2, 'Children length check at nesting #2');
-      expect(children).to.have.deep.members([
-        {token: tokenA, collection: collectionA},
-        {token: tokenB, collection: collectionA},
-      ], 'Children contents check at nesting #2');
+    // Move token B to a different user outside the nesting tree
+    await tokenB.unnest(alice, targetToken, {Substrate: bob.address});
+    expect(await targetToken.getChildren()).to.be.have.deep.members([
+      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
+    ], 'Children contents check at nesting #3 (unnesting)').and.be.length(1, 'Children length check at nesting #3 (unnesting)');
 
-      // Move token B to a different user outside the nesting tree
-      await transferFromExpectSuccess(collectionA, tokenB, alice, targetAddress, bob);
-      children = await getTokenChildren(api, collectionA, targetToken);
-      expect(children.length).to.be.equal(1, 'Children length check at unnesting');
-      expect(children).to.be.have.deep.members([
-        {token: tokenA, collection: collectionA},
-      ], 'Children contents check at unnesting');
+    // Create a fungible token in another collection and then nest
+    await collectionB.mint(alice, 10n);
+    await collectionB.transfer(alice, targetToken.nestingAccount(), 2n);
+    expect(await targetToken.getChildren()).to.be.have.deep.members([
+      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
+      {tokenId: 0, collectionId: collectionB.collectionId},
+    ], 'Children contents check at nesting #4 (from another collection)')
+      .and.be.length(2, 'Children length check at nesting #4 (from another collection)');
+    
+    // Move part of the fungible token inside token A deeper in the nesting tree
+    await collectionB.transferFrom(alice, targetToken.nestingAccount(), tokenA.nestingAccount(), 1n);
+    expect(await targetToken.getChildren()).to.be.have.deep.members([
+      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
+      {tokenId: 0, collectionId: collectionB.collectionId},
+    ], 'Children contents check at nesting #5 (deeper)').and.be.length(2, 'Children length check at nesting #5 (deeper)');
+    expect(await tokenA.getChildren()).to.be.have.deep.members([
+      {tokenId: 0, collectionId: collectionB.collectionId},
+    ], 'Children contents check at nesting #5.5 (deeper)').and.be.length(1, 'Children length check at nesting #5.5 (deeper)');
 
-      // Create a fungible token in another collection and then nest
-      const tokenC = await createItemExpectSuccess(alice, collectionB, 'Fungible');
-      await transferExpectSuccess(collectionB, tokenC, alice, targetAddress, 1, 'Fungible');
-      children = await getTokenChildren(api, collectionA, targetToken);
-      expect(children.length).to.be.equal(2, 'Children length check at nesting #3 (from another collection)');
-      expect(children).to.be.have.deep.members([
-        {token: tokenA, collection: collectionA},
-        {token: tokenC, collection: collectionB},
-      ], 'Children contents check at nesting #3 (from another collection)');
-
-      // Move the fungible token inside token A deeper in the nesting tree
-      await transferFromExpectSuccess(collectionB, tokenC, alice, targetAddress, {Ethereum: tokenIdToAddress(collectionA, tokenA)}, 1, 'Fungible');
-      children = await getTokenChildren(api, collectionA, targetToken);
-      expect(children.length).to.be.equal(1, 'Children length check at deeper nesting');
-      expect(children).to.be.have.deep.members([
-        {token: tokenA, collection: collectionA},
-      ], 'Children contents check at deeper nesting');
-    });
+    // Move the remaining part of the fungible token inside token A deeper in the nesting tree
+    await collectionB.transferFrom(alice, targetToken.nestingAccount(), tokenA.nestingAccount(), 1n);
+    expect(await targetToken.getChildren()).to.be.have.deep.members([
+      {tokenId: tokenA.tokenId, collectionId: collectionA.collectionId},
+    ], 'Children contents check at nesting #6 (deeper)').and.be.length(1, 'Children length check at nesting #6 (deeper)');
+    expect(await tokenA.getChildren()).to.be.have.deep.members([
+      {tokenId: 0, collectionId: collectionB.collectionId},
+    ], 'Children contents check at nesting #6.5 (deeper)').and.be.length(1, 'Children length check at nesting #6.5 (deeper)');
   });
 });
 
-describe('Integration Test: Various token type nesting', async () => {
+describe('Integration Test: Various token type nesting', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+  let charlie: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (_, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
-      charlie = privateKeyWrapper('//Charlie');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob, charlie] = await helper.arrange.createAccounts([50n, 10n, 10n], donor);
     });
   });
 
-  it('Admin (NFT): allows an Admin to nest a token', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);
+  itSub('Admin (NFT): allows an Admin to nest a token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true}}});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    const targetToken = await collection.mintToken(alice, {Substrate: charlie.address});
 
-      // Create a nested token
-      const nestedToken = await createItemExpectSuccess(bob, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: charlie.address});
-      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+    // Create an immediately nested token
+    const nestedToken = await collection.mintToken(bob, targetToken.nestingAccount());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
 
-      // Create a token to be nested and nest
-      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
-      await transferExpectSuccess(collection, newToken, bob, {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
-    });
+    // Create a token to be nested and nest
+    const newToken = await collection.mintToken(bob);
+    await newToken.nest(bob, targetToken);
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
   });
 
-  it('Admin (NFT): Admin and Token Owner can operate together', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, collectionAdmin: true}});
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);
+  itSub('Admin (NFT): Admin and Token Owner can operate together', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true}}});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    const targetToken = await collection.mintToken(alice, {Substrate: charlie.address});
 
-      // Create a nested token by an administrator
-      const nestedToken = await createItemExpectSuccess(bob, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: charlie.address});
-      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+    // Create an immediately nested token by an administrator
+    const nestedToken = await collection.mintToken(bob, targetToken.nestingAccount());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
 
-      // Create a token and allow the owner to nest too
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT', charlie.address);
-      await transferExpectSuccess(collection, newToken, charlie, {Ethereum: tokenIdToAddress(collection, nestedToken)});
-      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: charlie.address});
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, nestedToken).toLowerCase()});
-    });
+    // Create a token to be nested and nest
+    const newToken = await collection.mintToken(alice, {Substrate: charlie.address});
+    await newToken.nest(charlie, targetToken);
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
   });
 
-  it('Admin (NFT): allows an Admin to nest a token (Restricted nesting)', async () => {
-    await usingApi(async api => {
-      const collectionA = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await addCollectionAdminExpectSuccess(alice, collectionA, bob.address);
-      const collectionB = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await addCollectionAdminExpectSuccess(alice, collectionB, bob.address);
-      await setCollectionPermissionsExpectSuccess(alice, collectionA, {nesting: {collectionAdmin: true, restricted:[collectionA, collectionB]}});
-      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT', charlie.address);
+  itSub('Admin (NFT): allows an Admin to nest a token (Restricted nesting)', async ({helper}) => {
+    const collectionA = await helper.nft.mintCollection(alice);
+    await collectionA.addAdmin(alice, {Substrate: bob.address});
+    const collectionB = await helper.nft.mintCollection(alice);
+    await collectionB.addAdmin(alice, {Substrate: bob.address});
+    await collectionA.setPermissions(alice, {nesting: {collectionAdmin: true, restricted:[collectionB.collectionId]}});
+    const targetToken = await collectionA.mintToken(alice, {Substrate: charlie.address});
 
-      // Create a nested token
-      const nestedToken = await createItemExpectSuccess(bob, collectionB, 'NFT', {Ethereum: tokenIdToAddress(collectionA, targetToken)});
-      expect(await getTopmostTokenOwner(api, collectionB, nestedToken)).to.be.deep.equal({Substrate: charlie.address});
-      expect(await getTokenOwner(api, collectionB, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collectionA, targetToken).toLowerCase()});
+    // Create an immediately nested token
+    const nestedToken = await collectionB.mintToken(bob, targetToken.nestingAccount());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
 
-      // Create a token to be nested and nest
-      const newToken = await createItemExpectSuccess(bob, collectionB, 'NFT');
-      await transferExpectSuccess(collectionB, newToken, bob, {Ethereum: tokenIdToAddress(collectionA, targetToken)});
-      expect(await getTopmostTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Substrate: charlie.address});
-      expect(await getTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collectionA, targetToken).toLowerCase()});
-    });
+    // Create a token to be nested and nest
+    const newToken = await collectionB.mintToken(bob);
+    await newToken.nest(bob, targetToken);
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
   });
 
   // ---------- Non-Fungible ----------
 
-  it('NFT: allows an Owner to nest/unnest their token', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+  itSub('NFT: allows an Owner to nest/unnest their token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
+    await collection.addToAllowList(alice, {Substrate: charlie.address});
+    const targetToken = await collection.mintToken(charlie);
+    await collection.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a nested token
-      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+    // Create an immediately nested token
+    const nestedToken = await collection.mintToken(charlie, targetToken.nestingAccount());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
 
-      // Create a token to be nested and nest
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
-      await transferExpectSuccess(collection, newToken, alice, {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
-    });
+    // Create a token to be nested and nest
+    const newToken = await collection.mintToken(charlie);
+    await newToken.nest(charlie, targetToken);
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
   });
 
-  it('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, restricted:[collection]}});
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+  itSub('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async ({helper}) => {
+    const collectionA = await helper.nft.mintCollection(alice);
+    const collectionB = await helper.nft.mintCollection(alice);
+    //await collectionB.addAdmin(alice, {Substrate: bob.address});
+    const targetToken = await collectionA.mintToken(alice, {Substrate: charlie.address});
 
-      // Create a nested token
-      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
+    await collectionA.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionB.collectionId]}});
+    await collectionA.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionA.addToAllowList(alice, targetToken.nestingAccount());
+
+    await collectionB.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collectionB.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionB.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a token to be nested and nest
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
-      await transferExpectSuccess(collection, newToken, alice, {Ethereum: tokenIdToAddress(collection, targetToken)});
-      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()});
-    });
+    // Create an immediately nested token
+    const nestedToken = await collectionB.mintToken(charlie, targetToken.nestingAccount());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
+
+    // Create a token to be nested and nest
+    const newToken = await collectionB.mintToken(charlie);
+    await newToken.nest(charlie, targetToken);
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
   });
 
   // ---------- Fungible ----------
 
-  it('Fungible: allows an Owner to nest/unnest their token', async () => {
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+  itSub('Fungible: allows an Owner to nest/unnest their token', async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
+    const collectionFT = await helper.ft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
 
-      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a nested token
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionFT,
-        targetAddress,
-        {Fungible: {Value: 10}},
-      ))).to.not.be.rejected;
+    await collectionFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collectionFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Nest a new token
-      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
-      await transferExpectSuccess(collectionFT, newToken, alice, targetAddress, 1, 'Fungible');
-    });
+    // Create an immediately nested token
+    await collectionFT.mint(charlie, 5n, targetToken.nestingAccount());
+    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
+
+    // Create a token to be nested and nest
+    await collectionFT.mint(charlie, 5n);
+    await collectionFT.transfer(charlie, targetToken.nestingAccount(), 2n);
+    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(7n);
   });
 
-  it('Fungible: allows an Owner to nest/unnest their token (Restricted nesting)', async () => {
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+  itSub('Fungible: allows an Owner to nest/unnest their token (Restricted nesting)', async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice);
+    const collectionFT = await helper.ft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
 
-      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionFT.collectionId]}});
+    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted: [collectionFT]}});
+    await collectionFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collectionFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a nested token
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionFT,
-        targetAddress,
-        {Fungible: {Value: 10}},
-      ))).to.not.be.rejected;
+    // Create an immediately nested token
+    await collectionFT.mint(charlie, 5n, targetToken.nestingAccount());
+    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
 
-      // Nest a new token
-      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
-      await transferExpectSuccess(collectionFT, newToken, alice, targetAddress, 1, 'Fungible');
-    });
+    // Create a token to be nested and nest
+    await collectionFT.mint(charlie, 5n);
+    await collectionFT.transfer(charlie, targetToken.nestingAccount(), 2n);
+    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(7n);
   });
 
   // ---------- Re-Fungible ----------
 
-  it('ReFungible: allows an Owner to nest/unnest their token', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub.ifWithPallets('ReFungible: allows an Owner to nest/unnest their token', [Pallets.ReFungible], async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
+    const collectionRFT = await helper.rft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
 
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
+    await collectionRFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collectionRFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionRFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a nested token
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionRFT,
-        targetAddress,
-        {ReFungible: {pieces: 100}},
-      ))).to.not.be.rejected;
+    // Create an immediately nested token
+    const nestedToken = await collectionRFT.mintToken(charlie, 5n, targetToken.nestingAccount());
+    expect(await nestedToken.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
 
-      // Nest a new token
-      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
-      await transferExpectSuccess(collectionRFT, newToken, alice, targetAddress, 100, 'ReFungible');
-    });
+    // Create a token to be nested and nest
+    const newToken = await collectionRFT.mintToken(charlie, 5n);
+    await newToken.transfer(charlie, targetToken.nestingAccount(), 2n);
+    expect(await newToken.getBalance(targetToken.nestingAccount())).to.be.equal(2n);
   });
 
-  it('ReFungible: allows an Owner to nest/unnest their token (Restricted nesting)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub.ifWithPallets('ReFungible: allows an Owner to nest/unnest their token (Restricted nesting)', [Pallets.ReFungible], async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice);
+    const collectionRFT = await helper.rft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
 
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT', {Substrate: alice.address});
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionRFT.collectionId]}});
+    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
+    await collectionRFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collectionRFT.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionRFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[collectionRFT]}});
+    // Create an immediately nested token
+    const nestedToken = await collectionRFT.mintToken(charlie, 5n, targetToken.nestingAccount());
+    expect(await nestedToken.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
 
-      // Create a nested token
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionRFT,
-        targetAddress,
-        {ReFungible: {pieces: 100}},
-      ))).to.not.be.rejected;
-
-      // Nest a new token
-      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
-      await transferExpectSuccess(collectionRFT, newToken, alice, targetAddress, 100, 'ReFungible');
-    });
+    // Create a token to be nested and nest
+    const newToken = await collectionRFT.mintToken(charlie, 5n);
+    await newToken.transfer(charlie, targetToken.nestingAccount(), 2n);
+    expect(await newToken.getBalance(targetToken.nestingAccount())).to.be.equal(2n);
   });
 });
 
-describe('Negative Test: Nesting', async() => {
+describe('Negative Test: Nesting', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
-    await usingApi(async (_, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
-      bob = privateKeyWrapper('//Bob');
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 50n], donor);
     });
   });
 
-  it('Disallows excessive token nesting', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
-
-      const maxNestingLevel = 5;
-      let prevToken = targetToken;
+  itSub('Disallows excessive token nesting', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    let token = await collection.mintToken(alice);
 
-      // Create a nested-token matryoshka
-      for (let i = 0; i < maxNestingLevel; i++) {
-        const nestedToken = await createItemExpectSuccess(
-          alice,
-          collection,
-          'NFT',
-          {Ethereum: tokenIdToAddress(collection, prevToken)},
-        );
+    const maxNestingLevel = 5;
 
-        prevToken = nestedToken;
-      }
-
-      // The nesting depth is limited by `maxNestingLevel`
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collection,
-        {Ethereum: tokenIdToAddress(collection, prevToken)},
-          {nft: {}} as any,
-      )), 'while creating nested token').to.be.rejectedWith(/^structure\.DepthLimit$/);
+    // Create a nested-token matryoshka
+    for (let i = 0; i < maxNestingLevel; i++) {
+      token = await collection.mintToken(alice, token.nestingAccount());
+    }
 
-      expect(await getTopmostTokenOwner(api, collection, prevToken)).to.be.deep.equal({Substrate: alice.address});
-    });
+    // The nesting depth is limited by `maxNestingLevel`
+    await expect(collection.mintToken(alice, token.nestingAccount()))
+      .to.be.rejectedWith(/structure\.DepthLimit/);
+    expect(await token.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
+    expect(await token.getChildren()).to.be.length(0);
   });
 
   // ---------- Admin ------------
 
-  it('Admin (NFT): disallows an Admin to operate nesting when only TokenOwner is allowed', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
-      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+  itSub('Admin (NFT): disallows an Admin to operate nesting when only TokenOwner is allowed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+    await collection.addAdmin(alice, {Substrate: bob.address});
+    const targetToken = await collection.mintToken(alice);
 
-      // Try to create a nested token as collection admin when it's disallowed
-      await expect(executeTransaction(api, bob, api.tx.unique.createItem(
-        collection,
-        {Ethereum: tokenIdToAddress(collection, targetToken)},
-          {nft: {}} as any,
-      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Try to create an immediately nested token as collection admin when it's disallowed
+    await expect(collection.mintToken(bob, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1),
-      ), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
-    });
+    // Try to create a token to be nested and nest
+    const newToken = await collection.mintToken(bob);
+    await expect(newToken.nest(bob, targetToken))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});
   });
 
-  it('Admin (NFT): disallows a Token Owner to operate nesting when only Admin is allowed', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
-      await addToAllowListExpectSuccess(alice, collection, bob.address);
-      await enableAllowListExpectSuccess(alice, collection);
-      await enablePublicMintingExpectSuccess(alice, collection);
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+  itSub('Admin (NFT): disallows a Token Owner to operate nesting when only Admin is allowed', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {collectionAdmin: true}}});
+    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, targetToken.nestingAccount());
+
+    // Try to create a nested token as token owner when it's disallowed
+    await expect(collection.mintToken(bob, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
 
-      // Try to create a nested token as collection admin when it's disallowed
-      await expect(executeTransaction(api, bob, api.tx.unique.createItem(
-        collection,
-        {Ethereum: tokenIdToAddress(collection, targetToken)},
-          {nft: {}} as any,
-      )), 'while creating nested token').to.be.rejectedWith(/common\.AddressNotInAllowlist/); 
+    // Try to create a token to be nested and nest
+    const newToken = await collection.mintToken(bob);
+    await expect(newToken.nest(bob, targetToken))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
-      await expect(executeTransaction(
-        api, 
-        bob, 
-        api.tx.unique.transfer({Ethereum: tokenIdToAddress(collection, targetToken)}, collection, newToken, 1),
-      ), 'while nesting new token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
-    });
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});
   });
 
-  it('Admin (NFT): disallows an Admin to nest and unnest someone else\'s token', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionLimitsExpectSuccess(alice, collection, {ownerCanTransfer: true});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
+  itSub('Admin (NFT): disallows an Admin to unnest someone else\'s token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice, {limits: {ownerCanTransfer: true}, permissions: {access: 'AllowList', mintMode: true, nesting: {collectionAdmin: true}}});
+    //await collection.addAdmin(alice, {Substrate: bob.address});
+    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, targetToken.nestingAccount());
 
-      await addToAllowListExpectSuccess(alice, collection, bob.address);
-      await enableAllowListExpectSuccess(alice, collection);
-      await enablePublicMintingExpectSuccess(alice, collection);
-
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(bob, collection, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collection, targetToken).toLowerCase()};
+    // Try to nest somebody else's token
+    const newToken = await collection.mintToken(bob);
+    await expect(newToken.nest(alice, targetToken))
+      .to.be.rejectedWith(/common\.NoPermission/);
 
-      // Try to nest somebody else's token
-      const newToken = await createItemExpectSuccess(bob, collection, 'NFT');
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.transferFrom(targetAddress, {Substrate: bob.address}, collection, newToken, 1),
-      ), 'while nesting another\'s token token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: bob.address});
+    // Try to unnest a token belonging to someone else as collection admin
+    const nestedToken = await collection.mintToken(alice, targetToken.nestingAccount());
+    await expect(nestedToken.unnest(alice, targetToken, {Substrate: bob.address}))
+      .to.be.rejectedWith(/common\.AddressNotInAllowlist/);
 
-      // Nest a token as admin and try to unnest it, now belonging to someone else
-      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', targetAddress);
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.transferFrom(targetAddress, normalizeAccountId(alice), collection, nestedToken, 1),
-      ), 'while unnesting another\'s token').to.be.rejectedWith(/common\.AddressNotInAllowlist/);
-      expect(await getTokenOwner(api, collection, nestedToken)).to.be.deep.equal(targetAddress);
-      expect(await getTopmostTokenOwner(api, collection, nestedToken)).to.be.deep.equal({Substrate: bob.address});
-    });
+    expect(await targetToken.getChildren()).to.be.length(1);
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccountInLowerCase());
   });
 
-  it('Admin (NFT): disallows an Admin to nest a token from an unlisted collection (Restricted nesting)', async () => {
-    await usingApi(async api => {
-      const collectionA = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      const collectionB = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionA, {nesting: {collectionAdmin: true, restricted:[collectionA]}});
+  itSub('Admin (NFT): disallows an Admin to nest a token from an unlisted collection (Restricted nesting)', async ({helper}) => {
+    const collectionA = await helper.nft.mintCollection(alice);
+    const collectionB = await helper.nft.mintCollection(alice);
+    await collectionA.setPermissions(alice, {nesting: {collectionAdmin: true, restricted: [collectionA.collectionId]}});
+    const targetToken = await collectionA.mintToken(alice);
 
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(alice, collectionA, 'NFT');
+    // Try to create a nested token from another collection
+    await expect(collectionB.mintToken(alice, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collectionB, 'NFT');
-      await expect(executeTransaction(
-        api, 
-        alice, 
-        api.tx.unique.transfer({Ethereum: tokenIdToAddress(collectionA, targetToken)}, collectionB, newToken, 1),
-      ), 'while nesting a foreign token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
-      expect(await getTokenOwner(api, collectionB, newToken)).to.be.deep.equal({Substrate: alice.address});
-    });
+    // Create a token in another collection yet to be nested and try to nest
+    const newToken = await collectionB.mintToken(alice);
+    await expect(newToken.nest(alice, targetToken))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
   });
 
   // ---------- Non-Fungible ----------
 
-  it('NFT: disallows to nest token if nesting is disabled', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {}});
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+  itSub('NFT: disallows to nest token if nesting is disabled', async ({helper}) => {
+    // Collection is implicitly not allowed nesting at creation
+    const collection = await helper.nft.mintCollection(alice);
+    const targetToken = await collection.mintToken(alice);
 
-      // Try to create a nested token
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collection,
-        {Ethereum: tokenIdToAddress(collection, targetToken)},
-          {nft: {}} as any,
-      )), 'while creating nested token').to.be.rejectedWith(/^common\.UserIsNotAllowedToNest$/);
+    // Try to create a nested token as token owner when it's disallowed
+    await expect(collection.mintToken(alice, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
 
-      // Create a token to be nested
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
-      // Try to nest
-      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/);
-      expect(await getTopmostTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-    });
+    // Try to create a token to be nested and nest
+    const newToken = await collection.mintToken(alice);
+    await expect(newToken.nest(alice, targetToken))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
   });
 
-  it('NFT: disallows a non-Owner to nest someone else\'s token', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
+  itSub('NFT: disallows a non-Owner to nest someone else\'s token', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice);
+    const targetToken = await collection.mintToken(alice);
 
-      await addToAllowListExpectSuccess(alice, collection, bob.address);
-      await enableAllowListExpectSuccess(alice, collection);
-      await enablePublicMintingExpectSuccess(alice, collection);
-
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(bob, collection, 'NFT');
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collection,
-        {Ethereum: tokenIdToAddress(collection, targetToken)},
-          {nft: {}} as any,
-      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Try to create a token to be nested and nest
+    const newToken = await collection.mintToken(alice);
+    await expect(newToken.nest(bob, targetToken)).to.be.rejectedWith(/common\.NoPermission/);
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
-      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/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-    });
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
   });
 
-  it('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, restricted:[collection]}});
+  itSub('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async ({helper}) => {
+    const collection = await helper.nft.mintCollection(alice);
+    const targetToken = await collection.mintToken(alice);
 
-      await addToAllowListExpectSuccess(alice, collection, bob.address);
-      await enableAllowListExpectSuccess(alice, collection);
-      await enablePublicMintingExpectSuccess(alice, collection);
+    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(bob, collection, 'NFT');
+    const collectionB = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true}});
+    await collectionB.addToAllowList(alice, {Substrate: bob.address});
+    await collectionB.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collection,
-        {Ethereum: tokenIdToAddress(collection, targetToken)},
-          {nft: {}} as any,
-      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Try to create a token to be nested and nest
+    const newToken = await collectionB.mintToken(alice);
+    await expect(newToken.nest(bob, targetToken)).to.be.rejectedWith(/common\.NoPermission/);
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
-      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/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-    });
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
   });
 
-  it('NFT: disallows to nest token in an unlisted collection', async () => {
-    await usingApi(async api => {
-      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true, restricted:[]}});
+  itSub('NFT: disallows to nest token in an unlisted collection', async ({helper}) => {
+    // Create collection with restricted nesting -- even self is not allowed
+    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted: []}}});
+    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});
 
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(alice, collection, 'NFT');
+    await collection.addToAllowList(alice, {Substrate: bob.address});
+    await collection.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collection,
-        {Ethereum: tokenIdToAddress(collection, targetToken)},
-          {nft: {}} as any,
-      )), 'while creating nested token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
-
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collection, 'NFT');
-      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/);
-      expect(await getTokenOwner(api, collection, newToken)).to.be.deep.equal({Substrate: alice.address});
-    });
+    // Try to mint in own collection after allowlisting the accounts
+    await expect(collection.mintToken(bob, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
   });
 
   // ---------- Fungible ----------
-
-  it('Fungible: disallows to nest token if nesting is disabled', async () => {
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {}});
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
-
-      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
 
-      // Try to create a nested token
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionFT,
-        targetAddress,
-        {Fungible: {Value: 10}},
-      )), 'while creating nested token').to.be.rejectedWith(/^common\.UserIsNotAllowedToNest$/);
+  itSub('Fungible: disallows to nest token if nesting is disabled', async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice);
+    const collectionFT = await helper.ft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice);
 
-      // Create a token to be nested
-      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
-      // Try to nest
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Try to create an immediately nested token
+    await expect(collectionFT.mint(alice, 5n, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
 
-      // Create another token to be nested
-      const newToken2 = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
-      // Try to nest inside a fungible token
-      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/);
-    });
+    // Try to create a token to be nested and nest
+    await collectionFT.mint(alice, 5n);
+    await expect(collectionFT.transfer(alice, targetToken.nestingAccount(), 2n))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    expect(await collectionFT.getBalance({Substrate: alice.address})).to.be.equal(5n);
   });
 
-  it('Fungible: disallows a non-Owner to nest someone else\'s token', async () => {
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});
+  itSub('Fungible: disallows a non-Owner to unnest someone else\'s token', async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true}}});
+    const collectionFT = await helper.ft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice, {Substrate: bob.address});
 
-      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);
-      await enableAllowListExpectSuccess(alice, collectionNFT);
-      await enablePublicMintingExpectSuccess(alice, collectionNFT);
+    // Nest some tokens as Alice into Bob's token
+    await collectionFT.mint(alice, 5n, targetToken.nestingAccount());
 
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
-
-      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionFT,
-        targetAddress,
-        {Fungible: {Value: 10}},
-      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-    });
+    // Try to pull it out
+    await expect(collectionFT.transferFrom(alice, targetToken.nestingAccount(), {Substrate: bob.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
   });
 
-  it('Fungible: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async () => {
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);
-      await enableAllowListExpectSuccess(alice, collectionNFT);
-      await enablePublicMintingExpectSuccess(alice, collectionNFT);
-
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+  itSub('Fungible: disallows a non-Owner to unnest someone else\'s token (Restricted nesting)', async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice);
+    const collectionFT = await helper.ft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice, {Substrate: bob.address});
 
-      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[collectionFT]}});
+    await collectionNFT.setPermissions(alice, {nesting: {collectionAdmin: true, tokenOwner: true, restricted: [collectionFT.collectionId]}});
 
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionFT,
-        targetAddress,
-        {Fungible: {Value: 10}},
-      )), 'while creating nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Nest some tokens as Alice into Bob's token
+    await collectionFT.mint(alice, 5n, targetToken.nestingAccount());
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-    });
+    // Try to pull it out as Alice still
+    await expect(collectionFT.transferFrom(alice, targetToken.nestingAccount(), {Substrate: bob.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
   });
 
-  it('Fungible: disallows to nest token in an unlisted collection', async () => {
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[]}});
-
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+  itSub('Fungible: disallows to nest token in an unlisted collection', async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true, restricted: []}}});
+    const collectionFT = await helper.ft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice);
 
-      const collectionFT = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+    // Try to mint an immediately nested token
+    await expect(collectionFT.mint(alice, 5n, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
 
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionFT,
-        targetAddress,
-        {Fungible: {Value: 10}},
-      )), 'while creating a nested token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+    // Mint a token and try to nest it
+    await collectionFT.mint(alice, 5n);
+    await expect(collectionFT.transfer(alice, targetToken.nestingAccount(), 1n))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collectionFT, 'Fungible');
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
-    });
+    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(0n);
+    expect(await collectionFT.getBalance({Substrate: alice.address})).to.be.equal(5n);
   });
 
   // ---------- Re-Fungible ----------
-
-  it('ReFungible: disallows to nest token if nesting is disabled', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {}});
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
-
-      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-
-      // Create a nested token
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionRFT,
-        targetAddress,
-        {ReFungible: {pieces: 100}},
-      )), 'while creating a nested token').to.be.rejectedWith(/^common\.UserIsNotAllowedToNest$/);
+  itSub.ifWithPallets('ReFungible: disallows to nest token if nesting is disabled', [Pallets.ReFungible], async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice);
+    const collectionRFT = await helper.rft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice);
 
-      // Create a token to be nested
-      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
-      // Try to nest
-      await transferExpectFailure(collectionRFT, newToken, alice, targetAddress, 100);
-      // Try to nest
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Try to create an immediately nested token
+    await expect(collectionRFT.mintToken(alice, 5n, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
 
-      // Create another token to be nested
-      const newToken2 = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
-      // Try to nest inside a fungible token
-      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/);
-    });
+    // Try to create a token to be nested and nest
+    const token = await collectionRFT.mintToken(alice, 5n);
+    await expect(token.transfer(alice, targetToken.nestingAccount(), 2n))
+      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(5n);
   });
-
-  it('ReFungible: disallows a non-Owner to nest someone else\'s token', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
 
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true}});
+  itSub.ifWithPallets('ReFungible: disallows a non-Owner to nest someone else\'s token', [Pallets.ReFungible], async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice);
+    const collectionRFT = await helper.rft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice);
 
-      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);
-      await enableAllowListExpectSuccess(alice, collectionNFT);
-      await enablePublicMintingExpectSuccess(alice, collectionNFT);
+    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
+    await collectionNFT.addToAllowList(alice, {Substrate: bob.address});
+    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+    // Try to create a token to be nested and nest
+    const newToken = await collectionRFT.mintToken(alice);
+    await expect(newToken.transfer(bob, targetToken.nestingAccount())).to.be.rejectedWith(/common\.TokenValueTooLow/);
 
-      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getBalance({Substrate: alice.address})).to.be.equal(1n);
 
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionRFT,
-        targetAddress,
-        {ReFungible: {pieces: 100}},
-      )), 'while creating a nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Nest some tokens as Alice into Bob's token
+    await newToken.transfer(alice, targetToken.nestingAccount());
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-    });
+    // Try to pull it out
+    await expect(newToken.transferFrom(bob, targetToken.nestingAccount(), {Substrate: alice.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await newToken.getBalance(targetToken.nestingAccount())).to.be.equal(1n);
   });
 
-  it('ReFungible: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub.ifWithPallets('ReFungible: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', [Pallets.ReFungible], async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice);
+    const collectionRFT = await helper.rft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice);
 
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await addToAllowListExpectSuccess(alice, collectionNFT, bob.address);
-      await enableAllowListExpectSuccess(alice, collectionNFT);
-      await enablePublicMintingExpectSuccess(alice, collectionNFT);
+    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted: [collectionRFT.collectionId]}});
+    await collectionNFT.addToAllowList(alice, {Substrate: bob.address});
+    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
 
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(bob, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
+    // Try to create a token to be nested and nest
+    const newToken = await collectionRFT.mintToken(alice);
+    await expect(newToken.transfer(bob, targetToken.nestingAccount())).to.be.rejectedWith(/common\.TokenValueTooLow/);
 
-      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[collectionRFT]}});
+    expect(await targetToken.getChildren()).to.be.length(0);
+    expect(await newToken.getBalance({Substrate: alice.address})).to.be.equal(1n);
 
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionRFT,
-        targetAddress,
-        {ReFungible: {pieces: 100}},
-      )), 'while creating a nested token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+    // Nest some tokens as Alice into Bob's token
+    await newToken.transfer(alice, targetToken.nestingAccount());
 
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-    });
+    // Try to pull it out
+    await expect(newToken.transferFrom(bob, targetToken.nestingAccount(), {Substrate: alice.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await newToken.getBalance(targetToken.nestingAccount())).to.be.equal(1n);
   });
 
-  it('ReFungible: disallows to nest token to an unlisted collection', async function() {
-    await requirePallets(this, [Pallets.ReFungible]);
+  itSub.ifWithPallets('ReFungible: disallows to nest token to an unlisted collection', [Pallets.ReFungible], async ({helper}) => {
+    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true, restricted: []}}});
+    const collectionRFT = await helper.rft.mintCollection(alice);
+    const targetToken = await collectionNFT.mintToken(alice);
 
-    await usingApi(async api => {
-      const collectionNFT = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[]}});
+    // Try to create an immediately nested token
+    await expect(collectionRFT.mintToken(alice, 5n, targetToken.nestingAccount()))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
 
-      // Create a token to attempt to be nested into
-      const targetToken = await createItemExpectSuccess(alice, collectionNFT, 'NFT');
-      const targetAddress = {Ethereum: tokenIdToAddress(collectionNFT, targetToken)};
-
-      const collectionRFT = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
-
-      // Try to create a nested token in the wrong collection
-      await expect(executeTransaction(api, alice, api.tx.unique.createItem(
-        collectionRFT,
-        targetAddress,
-        {ReFungible: {pieces: 100}},
-      )), 'while creating a nested token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
-
-      // Try to create and nest a token in the wrong collection
-      const newToken = await createItemExpectSuccess(alice, collectionRFT, 'ReFungible');
-      await expect(executeTransaction(api, alice, api.tx.unique.transfer(targetAddress, collectionRFT, newToken, 1)), 'while nesting new token').to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
-    });
+    // Try to create a token to be nested and nest
+    const token = await collectionRFT.mintToken(alice, 5n);
+    await expect(token.transfer(alice, targetToken.nestingAccount(), 2n))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(5n);
   });
 });

1import {expect} from 'chai';
2import usingApi, {executeTransaction} from '../substrate/substrate-api';1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
3import {
4  addCollectionAdminExpectSuccess,
5  CollectionMode,
6  createCollectionExpectSuccess,
7  setCollectionPermissionsExpectSuccess,
8  createItemExpectSuccess,
9  getCreateCollectionResult,
10  transferExpectSuccess,
11  requirePallets,
12  Pallets,
13} from '../util/helpers';2// This file is part of Unique Network.
14import {IKeyringPair} from '@polkadot/types/types';
15import {tokenIdToAddress} from '../eth/util/helpers';
163
17let alice: IKeyringPair;4// Unique Network is free software: you can redistribute it and/or modify
18let bob: IKeyringPair;5// it under the terms of the GNU General Public License as published by
19let charlie: IKeyringPair;6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
208
21describe('Composite Properties Test', () => {9// Unique Network is distributed in the hope that it will be useful,
22  before(async () => {
23    await usingApi(async (api, privateKeyWrapper) => {10// but WITHOUT ANY WARRANTY; without even the implied warranty of
24      alice = privateKeyWrapper('//Alice');11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25      bob = privateKeyWrapper('//Bob');12// GNU General Public License for more details.
26    });
27  });
2813
29  async function testMakeSureSuppliesRequired(mode: CollectionMode) {14// You should have received a copy of the GNU General Public License
30    await usingApi(async api => {
31      const collectionId = await createCollectionExpectSuccess({mode: mode});15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
3216
33      const collectionOption = await api.rpc.unique.collectionById(collectionId);17import {IKeyringPair} from '@polkadot/types/types';
34      expect(collectionOption.isSome).to.be.true;18import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from '../util/playgrounds';
35      let collection = collectionOption.unwrap();
36      expect(collection.tokenPropertyPermissions.toHuman()).to.be.empty;19import {UniqueHelper, UniqueBaseCollection, UniqueNFTCollection, UniqueNFToken, UniqueRFTCollection, UniqueRFToken} from '../util/playgrounds/unique';
37      expect(collection.properties.toHuman()).to.be.empty;
3820
39      const propertyPermissions = [21// ---------- COLLECTION PROPERTIES
40        {key: 'mindgame', permission: {collectionAdmin: true, mutable: false, tokenOwner: true}},
41        {key: 'skullduggery', permission: {collectionAdmin: false, mutable: true, tokenOwner: false}},
42      ];
43      await expect(executeTransaction(
44        api, 
45        alice, 
46        api.tx.unique.setTokenPropertyPermissions(collectionId, propertyPermissions), 
47      )).to.not.be.rejected;
4822
49      const collectionProperties = [
50        {key: 'black_hole', value: 'LIGO'},23describe('Integration Test: Collection Properties', () => {
51        {key: 'electron', value: 'come bond'}, 
52      ];
53      await expect(executeTransaction(
54        api, 
55        alice, 24  let alice: IKeyringPair;
56        api.tx.unique.setCollectionProperties(collectionId, collectionProperties), 25  let bob: IKeyringPair;
57      )).to.not.be.rejected;
5826
59      collection = (await api.rpc.unique.collectionById(collectionId)).unwrap();27  before(async () => {
28    await usingPlaygrounds(async (helper, privateKey) => {
60      expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);29      const donor = privateKey('//Alice');
61      expect(collection.properties.toHuman()).to.be.deep.equal(collectionProperties);30      [alice, bob] = await helper.arrange.createAccounts([50n, 10n], donor);
62    });31    });
63  }32  });
6433
65  it('Makes sure collectionById supplies required fields for NFT', async () => {34  itSub('Properties are initially empty', async ({helper}) => {
66    await testMakeSureSuppliesRequired({type: 'NFT'});35    const collection = await helper.nft.mintCollection(alice);
36    expect(await collection.getProperties()).to.be.empty;
67  });37  });
6838
69  it('Makes sure collectionById supplies required fields for ReFungible', async function() {39  async function testSetsPropertiesForCollection(collection: UniqueBaseCollection) {
40    // As owner
70    await requirePallets(this, [Pallets.ReFungible]);41    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}])).to.be.fulfilled;
7142
72    await testMakeSureSuppliesRequired({type: 'ReFungible'});43    await collection.addAdmin(alice, {Substrate: bob.address});
73  });
74});
7544
76// ---------- COLLECTION PROPERTIES45    // As administrator
46    await expect(collection.setProperties(bob, [{key: 'black_hole'}])).to.be.fulfilled;
7747
78describe('Integration Test: Collection Properties', () => {48    const properties = await collection.getProperties();
79  before(async () => {49    expect(properties).to.include.deep.members([
80    await usingApi(async (api, privateKeyWrapper) => {50      {key: 'electron', value: 'come bond'},
81      alice = privateKeyWrapper('//Alice');51      {key: 'black_hole', value: ''},
52    ]);
82      bob = privateKeyWrapper('//Bob');53  }
54
55  itSub('Sets properties for a NFT collection', async ({helper}) =>  {
83    });56    await testSetsPropertiesForCollection(await helper.nft.mintCollection(alice));
84  });57  });
8558
86  it('Reads properties from a collection', async () => {59  itSub.ifWithPallets('Sets properties for a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
87    await usingApi(async api => {60    await testSetsPropertiesForCollection(await helper.rft.mintCollection(alice));
88      const collection = await createCollectionExpectSuccess();
89      const properties = (await api.query.common.collectionProperties(collection)).toJSON();
90      expect(properties.map).to.be.empty;
91      expect(properties.consumedSpace).to.equal(0);
92    });
93  });61  });
9462
63  async function testCheckValidNames(collection: UniqueBaseCollection) {
64    // alpha symbols
65    await expect(collection.setProperties(alice, [{key: 'answer'}])).to.be.fulfilled;
9566
96  async function testSetsPropertiesForCollection(mode: string) {67    // numeric symbols
97    await usingApi(async api => {68    await expect(collection.setProperties(alice, [{key: '451'}])).to.be.fulfilled;
98      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));
99      const {collectionId} = getCreateCollectionResult(events);
10069
101      // As owner70    // underscore symbol
102      await expect(executeTransaction(71    await expect(collection.setProperties(alice, [{key: 'black_hole'}])).to.be.fulfilled;
103        api, 
104        bob, 
105        api.tx.unique.setCollectionProperties(collectionId, [{key: 'electron', value: 'come bond'}]), 
106      )).to.not.be.rejected;
10772
108      await addCollectionAdminExpectSuccess(bob, collectionId, alice.address);73    // dash symbol
74    await expect(collection.setProperties(alice, [{key: '-'}])).to.be.fulfilled;
10975
110      // As administrator76    // dot symbol
111      await expect(executeTransaction(77    await expect(collection.setProperties(alice, [{key: 'once.in.a.long.long.while...', value: 'you get a little lost'}])).to.be.fulfilled;
112        api, 
113        alice, 
114        api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 
115      )).to.not.be.rejected;
11678
117      const properties = (await api.rpc.unique.collectionProperties(collectionId, ['electron', 'black_hole'])).toHuman();79    const properties = await collection.getProperties();
118      expect(properties).to.be.deep.equal([80    expect(properties).to.include.deep.members([
119        {key: 'electron', value: 'come bond'},81      {key: 'answer', value: ''},
82      {key: '451', value: ''},
120        {key: 'black_hole', value: ''},83      {key: 'black_hole', value: ''},
84      {key: '-', value: ''},
121      ]);85      {key: 'once.in.a.long.long.while...', value: 'you get a little lost'},
122    });86    ]);
123  }87  }
124  it('Sets properties for a NFT collection', async () => {
125    await testSetsPropertiesForCollection('NFT');
126  });
127  it('Sets properties for a ReFungible collection', async function() {
128    await requirePallets(this, [Pallets.ReFungible]);
12988
130    await testSetsPropertiesForCollection('ReFungible');89  itSub('Check valid names for NFT collection properties keys', async ({helper}) =>  {
90    await testCheckValidNames(await helper.nft.mintCollection(alice));
131  });91  });
13292
133  async function testCheckValidNames(mode: string) {93  itSub.ifWithPallets('Check valid names for ReFungible collection properties keys', [Pallets.ReFungible], async ({helper}) => {
134    await usingApi(async api => {
135      const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));
136      const {collectionId} = getCreateCollectionResult(events);
137  
138      // alpha symbols
139      await expect(executeTransaction(
140        api, 
141        bob, 
142        api.tx.unique.setCollectionProperties(collectionId, [{key: 'alpha'}]), 
143      )).to.not.be.rejected;
144  
145      // numeric symbols
146      await expect(executeTransaction(
147        api, 
148        bob, 
149        api.tx.unique.setCollectionProperties(collectionId, [{key: '123'}]), 
150      )).to.not.be.rejected;
151  
152      // underscore symbol
153      await expect(executeTransaction(
154        api, 
155        bob, 
156        api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 
157      )).to.not.be.rejected;
158  
159      // dash symbol
160      await expect(executeTransaction(
161        api, 
162        bob, 
163        api.tx.unique.setCollectionProperties(collectionId, [{key: 'semi-automatic'}]), 
164      )).to.not.be.rejected;
165  
166      // underscore symbol
167      await expect(executeTransaction(
168        api, 
169        bob, 
170        api.tx.unique.setCollectionProperties(collectionId, [{key: 'build.rs'}]), 
171      )).to.not.be.rejected;
172  
173      const propertyKeys = ['alpha', '123', 'black_hole', 'semi-automatic', 'build.rs'];
174      const properties = (await api.rpc.unique.collectionProperties(collectionId, propertyKeys)).toHuman();94    await testCheckValidNames(await helper.rft.mintCollection(alice));
175      expect(properties).to.be.deep.equal([
176        {key: 'alpha', value: ''},
177        {key: '123', value: ''},
178        {key: 'black_hole', value: ''},
179        {key: 'semi-automatic', value: ''},
180        {key: 'build.rs', value: ''},
181      ]);
182    });
183  }
184  it('Check valid names for NFT collection properties keys', async () => {
185    await testCheckValidNames('NFT');
186  });95  });
187  it('Check valid names for ReFungible collection properties keys', async function() {
188    await requirePallets(this, [Pallets.ReFungible]);
18996
190    await testCheckValidNames('ReFungible');97  async function testChangesProperties(collection: UniqueBaseCollection) {
191  });98    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: ''}])).to.be.fulfilled;
19299
193  async function testChangesProperties(mode: CollectionMode) {100    // Mutate the properties
194    await usingApi(async api => {
195      const collection = await createCollectionExpectSuccess({mode: mode});
196  
197      await expect(executeTransaction(
198        api, 
199        alice, 
200        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole'}]), 
201      )).to.not.be.rejected;
202  
203      // Mutate the properties
204      await expect(executeTransaction(101    await expect(collection.setProperties(alice, [{key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;
205        api, 102
206        alice, 
207        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'bonded'}, {key: 'black_hole', value: 'LIGO'}]), 
208      )).to.not.be.rejected;
209  
210      const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();103    const properties = await collection.getProperties();
211      expect(properties).to.be.deep.equal([104    expect(properties).to.include.deep.members([
212        {key: 'electron', value: 'bonded'},105      {key: 'electron', value: 'come bond'},
213        {key: 'black_hole', value: 'LIGO'},106      {key: 'black_hole', value: 'LIGO'},
214      ]);107    ]);
215    });
216  }108  }
109
217  it('Changes properties of a NFT collection', async () => {110  itSub('Changes properties of a NFT collection', async ({helper}) =>  {
218    await testChangesProperties({type: 'NFT'});111    await testChangesProperties(await helper.nft.mintCollection(alice));
219  });112  });
220  it('Changes properties of a ReFungible collection', async function() {
221    await requirePallets(this, [Pallets.ReFungible]);
222113
223    await testChangesProperties({type: 'ReFungible'});114  itSub.ifWithPallets('Changes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
115    await testChangesProperties(await helper.rft.mintCollection(alice));
224  });116  });
225117
226  async function testDeleteProperties(mode: CollectionMode) {118  async function testDeleteProperties(collection: UniqueBaseCollection) {
227    await usingApi(async api => {119    await expect(collection.setProperties(alice, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}])).to.be.fulfilled;
228      const collection = await createCollectionExpectSuccess({mode: mode});120
229  
230      await expect(executeTransaction(
231        api, 
232        alice, 
233        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 
234      )).to.not.be.rejected;
235  
236      await expect(executeTransaction(121    await expect(collection.deleteProperties(alice, ['electron'])).to.be.fulfilled;
237        api, 122
238        alice, 
239        api.tx.unique.deleteCollectionProperties(collection, ['electron']), 
240      )).to.not.be.rejected;
241  
242      const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();123    const properties = await collection.getProperties(['black_hole', 'electron']);
243      expect(properties).to.be.deep.equal([124    expect(properties).to.be.deep.equal([
244        {key: 'black_hole', value: 'LIGO'},125      {key: 'black_hole', value: 'LIGO'},
245      ]);126    ]);
246    });  
247  }127  }
128
248  it('Deletes properties of a NFT collection', async () => {129  itSub('Deletes properties of a NFT collection', async ({helper}) =>  {
249    await testDeleteProperties({type: 'NFT'});130    await testDeleteProperties(await helper.nft.mintCollection(alice));
250  });131  });
251  it('Deletes properties of a ReFungible collection', async function() {
252    await requirePallets(this, [Pallets.ReFungible]);
253132
254    await testDeleteProperties({type: 'ReFungible'});133  itSub.ifWithPallets('Deletes properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
134    await testDeleteProperties(await helper.rft.mintCollection(alice));
255  });135  });
256});136});
257137
258describe('Negative Integration Test: Collection Properties', () => {138describe('Negative Integration Test: Collection Properties', () => {
139  let alice: IKeyringPair;
140  let bob: IKeyringPair;
141
259  before(async () => {142  before(async () => {
260    await usingApi(async (api, privateKeyWrapper) => {143    await usingPlaygrounds(async (helper, privateKey) => {
261      alice = privateKeyWrapper('//Alice');144      const donor = privateKey('//Alice');
262      bob = privateKeyWrapper('//Bob');145      [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
263    });146    });
264  });147  });
265  148  
266  async function testFailsSetPropertiesIfNotOwnerOrAdmin(mode: CollectionMode) {149  async function testFailsSetPropertiesIfNotOwnerOrAdmin(collection: UniqueBaseCollection) {  
267    await usingApi(async api => {
268      const collection = await createCollectionExpectSuccess({mode: mode});150    await expect(collection.setProperties(bob, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]))
269  
270      await expect(executeTransaction(
271        api, 
272        bob, 
273        api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 
274      )).to.be.rejectedWith(/common\.NoPermission/);151      .to.be.rejectedWith(/common\.NoPermission/);
275  152
276      const properties = (await api.query.common.collectionProperties(collection)).toJSON();153    expect(await collection.getProperties()).to.be.empty;
277      expect(properties.map).to.be.empty;
278      expect(properties.consumedSpace).to.equal(0);
279    });  
280  }154  }
155
281  it('Fails to set properties in a NFT collection if not its onwer/administrator', async () => {156  itSub('Fails to set properties in a NFT collection if not its onwer/administrator', async ({helper}) =>  {
282    await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'NFT'});157    await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.nft.mintCollection(alice));
283  });158  });
284  it('Fails to set properties in a ReFungible collection if not its onwer/administrator', async function() {
285    await requirePallets(this, [Pallets.ReFungible]);
286159
287    await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'ReFungible'});160  itSub.ifWithPallets('Fails to set properties in a ReFungible collection if not its onwer/administrator', [Pallets.ReFungible], async ({helper}) => {
161    await testFailsSetPropertiesIfNotOwnerOrAdmin(await helper.rft.mintCollection(alice));
288  });162  });
289  163  
290  async function testFailsSetPropertiesThatExeedLimits(mode: CollectionMode) {164  async function testFailsSetPropertiesThatExeedLimits(collection: UniqueBaseCollection) {
291    await usingApi(async api => {165    const spaceLimit = (await (collection.helper!.api! as any).query.common.collectionProperties(collection.collectionId)).spaceLimit.toNumber();
292      const collection = await createCollectionExpectSuccess({mode: mode});
293      const spaceLimit = (await api.query.common.collectionProperties(collection)).toJSON().spaceLimit as number; 
294  166  
295      // Mute the general tx parsing error, too many bytes to process167    // Mute the general tx parsing error, too many bytes to process
296      {168    {
297        console.error = () => {};169      console.error = () => {};
298        await expect(executeTransaction(170      await expect(collection.setProperties(alice, [
299          api, 
300          alice, 
301          api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}]), 171        {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))},
302        )).to.be.rejected;172      ])).to.be.rejected;
303      }173    }
304  174
305      let properties = (await api.rpc.unique.collectionProperties(collection, ['electron'])).toJSON();175    expect(await collection.getProperties(['electron'])).to.be.empty;
306      expect(properties).to.be.empty;176
307  
308      await expect(executeTransaction(177    await expect(collection.setProperties(alice, [
309        api, 
310        alice, 
311        api.tx.unique.setCollectionProperties(collection, [
312          {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 178      {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 
313          {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 179      {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 
314        ]), 180    ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);
315      )).to.be.rejectedWith(/common\.NoSpaceForProperty/);181
316  
317      properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON();182    expect(await collection.getProperties(['electron', 'black_hole'])).to.be.empty;
318      expect(properties).to.be.empty;
319    });  
320  }183  }
184
321  it('Fails to set properties that exceed the limits (NFT)', async () => {185  itSub('Fails to set properties that exceed the limits (NFT)', async ({helper}) =>  {
322    await testFailsSetPropertiesThatExeedLimits({type: 'NFT'});186    await testFailsSetPropertiesThatExeedLimits(await helper.nft.mintCollection(alice));
323  });187  });
324  it('Fails to set properties that exceed the limits (ReFungible)', async function() {
325    await requirePallets(this, [Pallets.ReFungible]);
326188
327    await testFailsSetPropertiesThatExeedLimits({type: 'ReFungible'});189  itSub.ifWithPallets('Fails to set properties that exceed the limits (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
190    await testFailsSetPropertiesThatExeedLimits(await helper.rft.mintCollection(alice));
328  });191  });
329  192  
330  async function testFailsSetMorePropertiesThanAllowed(mode: CollectionMode) {193  async function testFailsSetMorePropertiesThanAllowed(collection: UniqueBaseCollection) {
331    await usingApi(async api => {194    const propertiesToBeSet = [];
332      const collection = await createCollectionExpectSuccess({mode: mode});
333  
334      const propertiesToBeSet = [];
335      for (let i = 0; i < 65; i++) {195    for (let i = 0; i < 65; i++) {
336        propertiesToBeSet.push({196      propertiesToBeSet.push({
337          key: 'electron_' + i,197        key: 'electron_' + i,
338          value: Math.random() > 0.5 ? 'high' : 'low',198        value: Math.random() > 0.5 ? 'high' : 'low',
339        });199      });
340      }200    }
341  201
342      await expect(executeTransaction(202    await expect(collection.setProperties(alice, propertiesToBeSet)).
343        api, 
344        alice, 
345        api.tx.unique.setCollectionProperties(collection, propertiesToBeSet), 
346      )).to.be.rejectedWith(/common\.PropertyLimitReached/);203      to.be.rejectedWith(/common\.PropertyLimitReached/);
347  204
348      const properties = (await api.query.common.collectionProperties(collection)).toJSON();205    expect(await collection.getProperties()).to.be.empty;
349      expect(properties.map).to.be.empty;
350      expect(properties.consumedSpace).to.equal(0);
351    });  
352  }206  }
207
353  it('Fails to set more properties than it is allowed (NFT)', async () => {208  itSub('Fails to set more properties than it is allowed (NFT)', async ({helper}) =>  {
354    await testFailsSetMorePropertiesThanAllowed({type: 'NFT'});209    await testFailsSetMorePropertiesThanAllowed(await helper.nft.mintCollection(alice));
355  });210  });
356  it('Fails to set more properties than it is allowed (ReFungible)', async function() {
357    await requirePallets(this, [Pallets.ReFungible]);
358211
359    await testFailsSetMorePropertiesThanAllowed({type: 'ReFungible'});212  itSub.ifWithPallets('Fails to set more properties than it is allowed (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
213    await testFailsSetMorePropertiesThanAllowed(await helper.rft.mintCollection(alice));
360  });214  });
361  215  
362  async function testFailsSetPropertiesWithInvalidNames(mode: CollectionMode) {216  async function testFailsSetPropertiesWithInvalidNames(collection: UniqueBaseCollection) {
363    await usingApi(async api => {217    const invalidProperties = [
364      const collection = await createCollectionExpectSuccess({mode: mode});
365  
366      const invalidProperties = [
367        [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],218      [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],
368        [{key: 'Mr/Sandman', value: 'Bring me a gene'}],219      [{key: 'Mr/Sandman', value: 'Bring me a gene'}],
369        [{key: 'déjà vu', value: 'hmm...'}],220      [{key: 'déjà vu', value: 'hmm...'}],
370      ];221    ];
371  222
372      for (let i = 0; i < invalidProperties.length; i++) {223    for (let i = 0; i < invalidProperties.length; i++) {
373        await expect(executeTransaction(224      await expect(
374          api, 225        collection.setProperties(alice, invalidProperties[i]), 
375          alice, 
376          api.tx.unique.setCollectionProperties(collection, invalidProperties[i]), 
377        ), `on rejecting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);226        `on rejecting the new badly-named property #${i}`,
227      ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
378      }228    }
379  229
380      await expect(executeTransaction(230    await expect(
381        api, 231      collection.setProperties(alice, [{key: '', value: 'nothing must not exist'}]), 
382        alice, 
383        api.tx.unique.setCollectionProperties(collection, [{key: '', value: 'nothing must not exist'}]), 
384      ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);232      'on rejecting an unnamed property',
385  233    ).to.be.rejectedWith(/common\.EmptyPropertyKey/);
234
386      await expect(executeTransaction(235    await expect(
387        api, 236      collection.setProperties(alice, [{key: 'CRISPR-Cas9', value: 'rewriting nature!'}]), 
388        alice, 
389        api.tx.unique.setCollectionProperties(collection, [
390          {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
391        ]), 
392      ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;237      'on setting the correctly-but-still-badly-named property',
393  238    ).to.be.fulfilled;
239
394      const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');240    const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');
395  241
396      const properties = (await api.rpc.unique.collectionProperties(collection, keys)).toHuman();242    const properties = await collection.getProperties(keys);
397      expect(properties).to.be.deep.equal([243    expect(properties).to.be.deep.equal([
398        {key: 'CRISPR-Cas9', value: 'rewriting nature!'},244      {key: 'CRISPR-Cas9', value: 'rewriting nature!'},
399      ]);245    ]);
400  246
401      for (let i = 0; i < invalidProperties.length; i++) {247    for (let i = 0; i < invalidProperties.length; i++) {
402        await expect(executeTransaction(248      await expect(
403          api, 249        collection.deleteProperties(alice, invalidProperties[i].map(propertySet => propertySet.key)), 
404          alice, 
405          api.tx.unique.deleteCollectionProperties(collection, invalidProperties[i].map(propertySet => propertySet.key)), 
406        ), `on trying to delete the non-existent badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);250        `on trying to delete the non-existent badly-named property #${i}`,
251      ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
407      }252    }
408    });
409  }253  }
254
410  it('Fails to set properties with invalid names (NFT)', async () => {255  itSub('Fails to set properties with invalid names (NFT)', async ({helper}) =>  {
411    await testFailsSetPropertiesWithInvalidNames({type: 'NFT'});256    await testFailsSetPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));
412  });257  });
413  it('Fails to set properties with invalid names (ReFungible)', async function() {
414    await requirePallets(this, [Pallets.ReFungible]);
415258
416    await testFailsSetPropertiesWithInvalidNames({type: 'ReFungible'});259  itSub.ifWithPallets('Fails to set properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
260    await testFailsSetPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));
417  });261  });
418});262});
419263
420// ---------- ACCESS RIGHTS264// ---------- ACCESS RIGHTS
421265
422describe('Integration Test: Access Rights to Token Properties', () => {266describe('Integration Test: Access Rights to Token Properties', () => {
267  let alice: IKeyringPair;
268  let bob: IKeyringPair;
269
423  before(async () => {270  before(async () => {
424    await usingApi(async (api, privateKeyWrapper) => {271    await usingPlaygrounds(async (helper, privateKey) => {
425      alice = privateKeyWrapper('//Alice');272      const donor = privateKey('//Alice');
426      bob = privateKeyWrapper('//Bob');273      [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
427    });274    });
428  });275  });
429  276  
430  it('Reads access rights to properties of a collection', async () => {277  itSub('Reads access rights to properties of a collection', async ({helper}) =>  {
431    await usingApi(async api => {
432      const collection = await createCollectionExpectSuccess();278    const collection = await helper.nft.mintCollection(alice);
433      const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();279    const propertyRights = (await helper.api!.query.common.collectionPropertyPermissions(collection.collectionId)).toJSON();
434      expect(propertyRights).to.be.empty;280    expect(propertyRights).to.be.empty;
435    });
436  });281  });
437  282  
438  async function testSetsAccessRightsToProperties(mode: CollectionMode) {283  async function testSetsAccessRightsToProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {  
439    await usingApi(async api => {
440      const collection = await createCollectionExpectSuccess({mode: mode});
441  284    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true}}]))
442      await expect(executeTransaction(
443        api, 
444        alice, 
445        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true}}]), 
446      )).to.not.be.rejected;285      .to.be.fulfilled;
447  286
448      await addCollectionAdminExpectSuccess(alice, collection, bob.address);287    await collection.addAdmin(alice, {Substrate: bob.address});
449  288
450      await expect(executeTransaction(289    await expect(collection.setTokenPropertyPermissions(bob, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]))
451        api, 
452        alice, 
453        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]), 
454      )).to.not.be.rejected;290      .to.be.fulfilled;
455  291
456      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery', 'mindgame'])).toHuman();292    const propertyRights = await collection.getPropertyPermissions(['skullduggery', 'mindgame']);
457      expect(propertyRights).to.be.deep.equal([293    expect(propertyRights).to.include.deep.members([
458        {key: 'skullduggery', permission: {'mutable': true, 'collectionAdmin': false, 'tokenOwner': false}},294      {key: 'skullduggery', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}},
459        {key: 'mindgame', permission: {'mutable': false, 'collectionAdmin': true, 'tokenOwner': false}},295      {key: 'mindgame', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
460      ]);296    ]);
461    });  
462  }297  }
298
463  it('Sets access rights to properties of a collection (NFT)', async () => {299  itSub('Sets access rights to properties of a collection (NFT)', async ({helper}) =>  {
464    await testSetsAccessRightsToProperties({type: 'NFT'});300    await testSetsAccessRightsToProperties(await helper.nft.mintCollection(alice));
465  });301  });
466  it('Sets access rights to properties of a collection (ReFungible)', async function() {
467    await requirePallets(this, [Pallets.ReFungible]);
468302
469    await testSetsAccessRightsToProperties({type: 'ReFungible'});303  itSub.ifWithPallets('Sets access rights to properties of a collection (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
304    await testSetsAccessRightsToProperties(await helper.rft.mintCollection(alice));
470  });305  });
471  306  
472  async function testChangesAccessRightsToProperty(mode: CollectionMode) {307  async function testChangesAccessRightsToProperty(collection: UniqueNFTCollection | UniqueRFTCollection) {
473    await usingApi(async api => {
474      const collection = await createCollectionExpectSuccess({mode: mode});308    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]))
475  
476      await expect(executeTransaction(
477        api, 
478        alice, 
479        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]), 
480      )).to.not.be.rejected;309      .to.be.fulfilled;
481  310
482      await expect(executeTransaction(311    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))
483        api, 
484        alice, 
485        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 
486      )).to.not.be.rejected;312      .to.be.fulfilled;
487  313
488      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();314    const propertyRights = await collection.getPropertyPermissions();
489      expect(propertyRights).to.be.deep.equal([315    expect(propertyRights).to.be.deep.equal([
490        {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},316      {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
491      ]);317    ]);
492    });
493  }318  }
319
494  it('Changes access rights to properties of a NFT collection', async () => {320  itSub('Changes access rights to properties of a NFT collection', async ({helper}) =>  {
495    await testChangesAccessRightsToProperty({type: 'NFT'});321    await testChangesAccessRightsToProperty(await helper.nft.mintCollection(alice));
496  });322  });
497  it('Changes access rights to properties of a ReFungible collection', async function() {
498    await requirePallets(this, [Pallets.ReFungible]);
499323
500    await testChangesAccessRightsToProperty({type: 'ReFungible'});324  itSub.ifWithPallets('Changes access rights to properties of a ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
325    await testChangesAccessRightsToProperty(await helper.rft.mintCollection(alice));
501  });326  });
502});327});
503328
504describe('Negative Integration Test: Access Rights to Token Properties', () => {329describe('Negative Integration Test: Access Rights to Token Properties', () => {
330  let alice: IKeyringPair;
331  let bob: IKeyringPair;
332
505  before(async () => {333  before(async () => {
506    await usingApi(async (api, privateKeyWrapper) => {334    await usingPlaygrounds(async (helper, privateKey) => {
507      alice = privateKeyWrapper('//Alice');335      const donor = privateKey('//Alice');
508      bob = privateKeyWrapper('//Bob');336      [alice, bob] = await helper.arrange.createAccounts([50n, 10n], donor);
509    });337    });
510  });338  });
511339
512  async function testPreventsFromSettingAccessRightsNotAdminOrOwner(mode: CollectionMode) {340  async function testPreventsFromSettingAccessRightsNotAdminOrOwner(collection: UniqueNFTCollection | UniqueRFTCollection) {
513    await usingApi(async api => {
514      const collection = await createCollectionExpectSuccess({mode: mode});341    await expect(collection.setTokenPropertyPermissions(bob, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]))
515  
516      await expect(executeTransaction(
517        api, 
518        bob, 
519        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]), 
520      )).to.be.rejectedWith(/common\.NoPermission/);342      .to.be.rejectedWith(/common\.NoPermission/);
521  343
522      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON();344    const propertyRights = await collection.getPropertyPermissions(['skullduggery']);
523      expect(propertyRights).to.be.empty;345    expect(propertyRights).to.be.empty;
524    });
525  }346  }
347
526  it('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async () => {348  itSub('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async ({helper}) =>  {
527    await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'NFT'});349    await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.nft.mintCollection(alice));
528  });350  });
529  it('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', async function() {
530    await requirePallets(this, [Pallets.ReFungible]);
531351
532    await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'ReFungible'});352  itSub.ifWithPallets('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', [Pallets.ReFungible], async ({helper}) => {
353    await testPreventsFromSettingAccessRightsNotAdminOrOwner(await helper.rft.mintCollection(alice));
533  });354  });
534355
535  async function testPreventFromAddingTooManyPossibleProperties(mode: CollectionMode) {356  async function testPreventFromAddingTooManyPossibleProperties(collection: UniqueNFTCollection | UniqueRFTCollection) {  
536    await usingApi(async api => {
537      const collection = await createCollectionExpectSuccess({mode: mode});
538  357    const constitution = [];
539      const constitution = [];
540      for (let i = 0; i < 65; i++) {358    for (let i = 0; i < 65; i++) {
541        constitution.push({359      constitution.push({
542          key: 'property_' + i,360        key: 'property_' + i,
543          permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},361        permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},
544        });362      });
545      }363    }
546  364
547      await expect(executeTransaction(365    await expect(collection.setTokenPropertyPermissions(alice, constitution))
548        api, 
549        alice, 
550        api.tx.unique.setTokenPropertyPermissions(collection, constitution), 
551      )).to.be.rejectedWith(/common\.PropertyLimitReached/);366      .to.be.rejectedWith(/common\.PropertyLimitReached/);
552  367
553      const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();368    const propertyRights = await collection.getPropertyPermissions();
554      expect(propertyRights).to.be.empty;369    expect(propertyRights).to.be.empty;
555    });  
556  }370  }
371
557  it('Prevents from adding too many possible properties (NFT)', async () => {372  itSub('Prevents from adding too many possible properties (NFT)', async ({helper}) =>  {
558    await testPreventFromAddingTooManyPossibleProperties({type: 'NFT'});373    await testPreventFromAddingTooManyPossibleProperties(await helper.nft.mintCollection(alice));
559  });374  });
560  it('Prevents from adding too many possible properties (ReFungible)', async function() {
561    await requirePallets(this, [Pallets.ReFungible]);
562375
563    await testPreventFromAddingTooManyPossibleProperties({type: 'ReFungible'});376  itSub.ifWithPallets('Prevents from adding too many possible properties (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
377    await testPreventFromAddingTooManyPossibleProperties(await helper.rft.mintCollection(alice));
564  });378  });
565379
566  async function testPreventAccessRightsModifiedIfConstant(mode: CollectionMode) {380  async function testPreventAccessRightsModifiedIfConstant(collection: UniqueNFTCollection | UniqueRFTCollection) {
567    await usingApi(async api => {
568      const collection = await createCollectionExpectSuccess({mode: mode});381    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]))
569  
570      await expect(executeTransaction(
571        api, 
572        alice, 
573        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 
574      )).to.not.be.rejected;382      .to.be.fulfilled;
575  383
576      await expect(executeTransaction(384    await expect(collection.setTokenPropertyPermissions(alice, [{key: 'skullduggery', permission: {collectionAdmin: true}}]))
577        api, 
578        alice, 
579        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {}}]), 
580      )).to.be.rejectedWith(/common\.NoPermission/);385      .to.be.rejectedWith(/common\.NoPermission/);
581  386
582      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();387    const propertyRights = await collection.getPropertyPermissions(['skullduggery']);
583      expect(propertyRights).to.deep.equal([388    expect(propertyRights).to.deep.equal([
584        {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},389      {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},
585      ]);390    ]);
586    });  
587  }391  }
392
588  it('Prevents access rights to be modified if constant (NFT)', async () => {393  itSub('Prevents access rights to be modified if constant (NFT)', async ({helper}) =>  {
589    await testPreventAccessRightsModifiedIfConstant({type: 'NFT'});394    await testPreventAccessRightsModifiedIfConstant(await helper.nft.mintCollection(alice));
590  });395  });
591  it('Prevents access rights to be modified if constant (ReFungible)', async function() {
592    await requirePallets(this, [Pallets.ReFungible]);
593396
594    await testPreventAccessRightsModifiedIfConstant({type: 'ReFungible'});397  itSub.ifWithPallets('Prevents access rights to be modified if constant (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
398    await testPreventAccessRightsModifiedIfConstant(await helper.rft.mintCollection(alice));
595  });399  });
596400
597  async function testPreventsAddingPropertiesWithInvalidNames(mode: CollectionMode) {401  async function testPreventsAddingPropertiesWithInvalidNames(collection: UniqueNFTCollection | UniqueRFTCollection) {
598    await usingApi(async api => {
599      const collection = await createCollectionExpectSuccess({mode: mode});402    const invalidProperties = [
600  
601      const invalidProperties = [
602        [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],403      [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],
603        [{key: 'G#4', permission: {tokenOwner: true}}],404      [{key: 'G#4', permission: {tokenOwner: true}}],
604        [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],405      [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],
605      ];406    ];
606  407
607      for (let i = 0; i < invalidProperties.length; i++) {408    for (let i = 0; i < invalidProperties.length; i++) {
608        await expect(executeTransaction(409      await expect(
609          api, 410        collection.setTokenPropertyPermissions(alice, invalidProperties[i]), 
610          alice, 
611          api.tx.unique.setTokenPropertyPermissions(collection, invalidProperties[i]), 
612        ), `on setting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);411        `on setting the new badly-named property #${i}`,
412      ).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);
613      }413    }
614  414
615      await expect(executeTransaction(415    await expect(
616        api, 416      collection.setTokenPropertyPermissions(alice, [{key: '', permission: {}}]), 
617        alice, 
618        api.tx.unique.setTokenPropertyPermissions(collection, [{key: '', permission: {}}]), 
619      ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);417      'on rejecting an unnamed property',
620  418    ).to.be.rejectedWith(/common\.EmptyPropertyKey/);
419
621      const correctKey = '--0x03116e387820CA05'; // PolkadotJS would parse this as an already encoded hex-string420    const correctKey = '--0x03116e387820CA05'; // PolkadotJS would parse this as an already encoded hex-string
622      await expect(executeTransaction(421    await expect(
623        api, 422      collection.setTokenPropertyPermissions(alice, [
624        alice, 
625        api.tx.unique.setTokenPropertyPermissions(collection, [
626          {key: correctKey, permission: {collectionAdmin: true}},423        {key: correctKey, permission: {collectionAdmin: true}},
627        ]), 424      ]), 
628      ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;425      'on setting the correctly-but-still-badly-named property',
629  426    ).to.be.fulfilled;
427
630      const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');428    const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');
631  429
632      const propertyRights = (await api.rpc.unique.propertyPermissions(collection, keys)).toHuman();430    const propertyRights = await collection.getPropertyPermissions(keys);
633      expect(propertyRights).to.be.deep.equal([431    expect(propertyRights).to.be.deep.equal([
634        {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},432      {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},
635      ]);433    ]);
636    });
637  }434  }
435
638  it('Prevents adding properties with invalid names (NFT)', async () => {436  itSub('Prevents adding properties with invalid names (NFT)', async ({helper}) =>  {
639    await testPreventsAddingPropertiesWithInvalidNames({type: 'NFT'});437    await testPreventsAddingPropertiesWithInvalidNames(await helper.nft.mintCollection(alice));
640  });438  });
641  it('Prevents adding properties with invalid names (ReFungible)', async function() {
642    await requirePallets(this, [Pallets.ReFungible]);
643439
644    await testPreventsAddingPropertiesWithInvalidNames({type: 'ReFungible'});440  itSub.ifWithPallets('Prevents adding properties with invalid names (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
441    await testPreventsAddingPropertiesWithInvalidNames(await helper.rft.mintCollection(alice));
645  });442  });
646});443});
647444
648// ---------- TOKEN PROPERTIES445// ---------- TOKEN PROPERTIES
649446
650describe('Integration Test: Token Properties', () => {447describe('Integration Test: Token Properties', () => {
448  let alice: IKeyringPair; // collection owner
449  let bob: IKeyringPair; // collection admin
450  let charlie: IKeyringPair; // token owner
451
651  let permissions: {permission: any, signers: IKeyringPair[]}[];452  let permissions: {permission: any, signers: IKeyringPair[]}[];
652453
653  before(async () => {454  before(async () => {
654    await usingApi(async (api, privateKeyWrapper) => {455    await usingPlaygrounds(async (helper, privateKey) => {
655      alice = privateKeyWrapper('//Alice'); // collection owner456      const donor = privateKey('//Alice');
656      bob = privateKeyWrapper('//Bob'); // collection admin457      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
657      charlie = privateKeyWrapper('//Charlie'); // token owner
658
659      permissions = [
660        {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},
661        {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},
662        {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},
663        {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},
664        {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
665        {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
666      ];
667    });458    });
459
460    // todo:playgrounds probably separate these tests later
461    permissions = [
462      {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},
463      {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},
464      {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},
465      {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},
466      {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
467      {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},
468    ];
668  });469  });
669  470  
670  async function testReadsYetEmptyProperties(mode: CollectionMode) {471  async function testReadsYetEmptyProperties(token: UniqueNFToken | UniqueRFToken) {
671    await usingApi(async api => {
672      const collection = await createCollectionExpectSuccess({mode: mode});472    const properties = await token.getProperties();
673      const token = await createItemExpectSuccess(alice, collection, mode.type);
674  
675      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
676      expect(properties.map).to.be.empty;473    expect(properties).to.be.empty;
677      expect(properties.consumedSpace).to.be.equal(0);474
678  475    const tokenData = await token.getData();
679      const tokenData = (await api.rpc.unique.tokenData(collection, token, ['anything'])).toJSON().properties;
680      expect(tokenData).to.be.empty;476    expect(tokenData!.properties).to.be.empty;
681    });
682  }477  }
478
683  it('Reads yet empty properties of a token (NFT)', async () => {479  itSub('Reads yet empty properties of a token (NFT)', async ({helper}) => {
684    await testReadsYetEmptyProperties({type: 'NFT'});480    const collection = await helper.nft.mintCollection(alice);
481    const token = await collection.mintToken(alice);
482    await testReadsYetEmptyProperties(token);
685  });483  });
686  it('Reads yet empty properties of a token (ReFungible)', async function() {
687    await requirePallets(this, [Pallets.ReFungible]);
688484
689    await testReadsYetEmptyProperties({type: 'ReFungible'});485  itSub.ifWithPallets('Reads yet empty properties of a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
486    const collection = await helper.rft.mintCollection(alice);
487    const token = await collection.mintToken(alice);
488    await testReadsYetEmptyProperties(token);
690  });489  });
691490
692  async function testAssignPropertiesAccordingToPermissions(mode: CollectionMode, pieces: number) {491  async function testAssignPropertiesAccordingToPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
693    await usingApi(async api => {492    await token.collection.addAdmin(alice, {Substrate: bob.address});
694      const collection = await createCollectionExpectSuccess({mode: mode});
695      const token = await createItemExpectSuccess(alice, collection, mode.type);
696      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
697      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);493    await token.transfer(alice, {Substrate: charlie.address}, pieces);
698494
699      const propertyKeys: string[] = [];495    const propertyKeys: string[] = [];
700      let i = 0;496    let i = 0;
701      for (const permission of permissions) {497    for (const permission of permissions) {
702        for (const signer of permission.signers) {498      i++;
499      let j = 0;
500      for (const signer of permission.signers) {
703          const key = i + '_' + signer.address;501        j++;
502        const key = i + '_' + signer.address;
704          propertyKeys.push(key);503        propertyKeys.push(key);
705504
706          await expect(executeTransaction(505        await expect(
707            api, 506          token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
708            alice, 
709            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
710          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;507          `on setting permission #${i} by alice`,
508        ).to.be.fulfilled;
711509
712          await expect(executeTransaction(510        await expect(
713            api, 511          token.setProperties(signer, [{key: key, value: 'Serotonin increase'}]), 
714            signer, 
715            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
716          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;512          `on adding property #${i} by signer #${j}`,
717        }513        ).to.be.fulfilled;
718
719        i++;
720      }514      }
515    }
721516
722      const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];517    const properties = await token.getProperties(propertyKeys);
723      const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];518    const tokenData = await token.getData();
724      for (let i = 0; i < properties.length; i++) {519    for (let i = 0; i < properties.length; i++) {
725        expect(properties[i].value).to.be.equal('Serotonin increase');520      expect(properties[i].value).to.be.equal('Serotonin increase');
726        expect(tokensData[i].value).to.be.equal('Serotonin increase');521      expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');
727      }522    }
728    });
729  }523  }
524
730  it('Assigns properties to a token according to permissions (NFT)', async () => {525  itSub('Assigns properties to a token according to permissions (NFT)', async ({helper}) =>  {
731    await testAssignPropertiesAccordingToPermissions({type: 'NFT'}, 1);526    const collection = await helper.nft.mintCollection(alice);
527    const token = await collection.mintToken(alice);
528    await testAssignPropertiesAccordingToPermissions(token, 1n);
732  });529  });
733  it('Assigns properties to a token according to permissions (ReFungible)', async function() {
734    await requirePallets(this, [Pallets.ReFungible]);
735530
736    await testAssignPropertiesAccordingToPermissions({type: 'ReFungible'}, 100);531  itSub.ifWithPallets('Assigns properties to a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
532    const collection = await helper.rft.mintCollection(alice);
533    const token = await collection.mintToken(alice, 100n);
534    await testAssignPropertiesAccordingToPermissions(token, 100n);
737  });535  });
738536
739  async function testChangesPropertiesAccordingPermission(mode: CollectionMode, pieces: number) {537  async function testChangesPropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
740    await usingApi(async api => {538    await token.collection.addAdmin(alice, {Substrate: bob.address});
741      const collection = await createCollectionExpectSuccess({mode: mode});
742      const token = await createItemExpectSuccess(alice, collection, mode.type);
743      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
744      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);539    await token.transfer(alice, {Substrate: charlie.address}, pieces);
745540
746      const propertyKeys: string[] = [];541    const propertyKeys: string[] = [];
747      let i = 0;542    let i = 0;
748      for (const permission of permissions) {543    for (const permission of permissions) {
749        if (!permission.permission.mutable) continue;544      i++;
545      if (!permission.permission.mutable) continue;
750        546      
751        for (const signer of permission.signers) {547      let j = 0;
548      for (const signer of permission.signers) {
752          const key = i + '_' + signer.address;549        j++;
550        const key = i + '_' + signer.address;
753          propertyKeys.push(key);551        propertyKeys.push(key);
754  552
755          await expect(executeTransaction(553        await expect(
756            api, 554          token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
757            alice, 
758            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
759          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;555          `on setting permission #${i} by alice`,
760  556        ).to.be.fulfilled;
557
761          await expect(executeTransaction(558        await expect(
762            api, 559          token.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
763            signer, 
764            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
765          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;560          `on adding property #${i} by signer #${j}`,
766  561        ).to.be.fulfilled;
562
767          await expect(executeTransaction(563        await expect(
768            api, 564          token.setProperties(signer, [{key, value: 'Serotonin stable'}]), 
769            signer, 
770            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin stable'}]), 
771          ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;565          `on changing property #${i} by signer #${j}`,
772        }566        ).to.be.fulfilled;
773  
774        i++;
775      }567      }
776  568    }
569
777      const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];570    const properties = await token.getProperties(propertyKeys);
778      const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];571    const tokenData = await token.getData();
779      for (let i = 0; i < properties.length; i++) {572    for (let i = 0; i < properties.length; i++) {
780        expect(properties[i].value).to.be.equal('Serotonin stable');573      expect(properties[i].value).to.be.equal('Serotonin stable');
781        expect(tokensData[i].value).to.be.equal('Serotonin stable');574      expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');
782      }575    }
783    });
784  }576  }
577
785  it('Changes properties of a token according to permissions (NFT)', async () => {578  itSub('Changes properties of a token according to permissions (NFT)', async ({helper}) =>  {
786    await testChangesPropertiesAccordingPermission({type: 'NFT'}, 1);579    const collection = await helper.nft.mintCollection(alice);
580    const token = await collection.mintToken(alice);
581    await testChangesPropertiesAccordingPermission(token, 1n);
787  });582  });
788  it('Changes properties of a token according to permissions (ReFungible)', async function() {
789    await requirePallets(this, [Pallets.ReFungible]);
790583
791    await testChangesPropertiesAccordingPermission({type: 'ReFungible'}, 100);584  itSub.ifWithPallets('Changes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
585    const collection = await helper.rft.mintCollection(alice);
586    const token = await collection.mintToken(alice, 100n);
587    await testChangesPropertiesAccordingPermission(token, 100n);
792  });588  });
793589
794  async function testDeletePropertiesAccordingPermission(mode: CollectionMode, pieces: number) {590  async function testDeletePropertiesAccordingPermission(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
795    await usingApi(async api => {591    await token.collection.addAdmin(alice, {Substrate: bob.address});
796      const collection = await createCollectionExpectSuccess({mode: mode});
797      const token = await createItemExpectSuccess(alice, collection, mode.type);
798      await addCollectionAdminExpectSuccess(alice, collection, bob.address);
799      await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);592    await token.transfer(alice, {Substrate: charlie.address}, pieces);
800593
801      const propertyKeys: string[] = [];594    const propertyKeys: string[] = [];
802      let i = 0;595    let i = 0;
803  596
804      for (const permission of permissions) {597    for (const permission of permissions) {
805        if (!permission.permission.mutable) continue;598      i++;
599      if (!permission.permission.mutable) continue;
806        600      
807        for (const signer of permission.signers) {601      let j = 0;
602      for (const signer of permission.signers) {
808          const key = i + '_' + signer.address;603        j++;
604        const key = i + '_' + signer.address;
809          propertyKeys.push(key);605        propertyKeys.push(key);
810  606
811          await expect(executeTransaction(607        await expect(
812            api, 608          token.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
813            alice, 
814            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
815          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;609          `on setting permission #${i} by alice`,
816  610        ).to.be.fulfilled;
611
817          await expect(executeTransaction(612        await expect(
818            api, 613          token.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
819            signer, 
820            api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 
821          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;614          `on adding property #${i} by signer #${j}`,
822  615        ).to.be.fulfilled;
616
823          await expect(executeTransaction(617        await expect(
824            api, 618          token.deleteProperties(signer, [key]), 
825            signer, 
826            api.tx.unique.deleteTokenProperties(collection, token, [key]), 
827          ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;619          `on deleting property #${i} by signer #${j}`,
828        }620        ).to.be.fulfilled;
829        
830        i++;
831      }621      }
832  622    }
833      const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[];623
834      expect(properties).to.be.empty;624    expect(await token.getProperties(propertyKeys)).to.be.empty;
835      const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[];
836      expect(tokensData).to.be.empty;
837      expect((await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace).to.be.equal(0);625    expect((await token.getData())!.properties).to.be.empty;
838    });
839  }626  }
840  it('Deletes properties of a token according to permissions (NFT)', async () => {627  
628  itSub('Deletes properties of a token according to permissions (NFT)', async ({helper}) =>  {
841    await testDeletePropertiesAccordingPermission({type: 'NFT'}, 1);629    const collection = await helper.nft.mintCollection(alice);
630    const token = await collection.mintToken(alice);
631    await testDeletePropertiesAccordingPermission(token, 1n);
842  });632  });
843  it('Deletes properties of a token according to permissions (ReFungible)', async function() {
844    await requirePallets(this, [Pallets.ReFungible]);
845633
846    await testDeletePropertiesAccordingPermission({type: 'ReFungible'}, 100);634  itSub.ifWithPallets('Deletes properties of a token according to permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
635    const collection = await helper.rft.mintCollection(alice);
636    const token = await collection.mintToken(alice, 100n);
637    await testDeletePropertiesAccordingPermission(token, 100n);
847  });638  });
848639
849  it('Assigns properties to a nested token according to permissions', async () => {640  itSub('Assigns properties to a nested token according to permissions', async ({helper}) =>  {
850    await usingApi(async api => {
851      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});641    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
852      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
853      const token = await createItemExpectSuccess(alice, collection, 'NFT');642    const collectionB = await helper.nft.mintCollection(alice);
854      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});643    const targetToken = await collectionA.mintToken(alice);
855      await addCollectionAdminExpectSuccess(alice, collection, bob.address);644    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
856      await transferExpectSuccess(collection, token, alice, charlie);
857645
858      const propertyKeys: string[] = [];646    await collectionB.addAdmin(alice, {Substrate: bob.address});
859      let i = 0;
860      for (const permission of permissions) {
861        for (const signer of permission.signers) {
862          const key = i + '_' + signer.address;647    await targetToken.transfer(alice, {Substrate: charlie.address});
863          propertyKeys.push(key);
864648
865          await expect(executeTransaction(649    const propertyKeys: string[] = [];
650    let i = 0;
651    for (const permission of permissions) {
652      i++;
653      let j = 0;
654      for (const signer of permission.signers) {
866            api, 655        j++;
656        const key = i + '_' + signer.address;
867            alice, 657        propertyKeys.push(key);
658        
868            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 659        await expect(
660          nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
869          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;661          `on setting permission #${i} by alice`,
662        ).to.be.fulfilled;
870663
871          await expect(executeTransaction(664        await expect(
872            api, 665          nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
873            signer, 
874            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 
875          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;666          `on adding property #${i} by signer #${j}`,
876        }667        ).to.be.fulfilled;
877
878        i++;
879      }668      }
880669
881      const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];670    }
671
672    const properties = await nestedToken.getProperties(propertyKeys);
882      const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];673    const tokenData = await nestedToken.getData();
883      for (let i = 0; i < properties.length; i++) {674    for (let i = 0; i < properties.length; i++) {
884        expect(properties[i].value).to.be.equal('Serotonin increase');675      expect(properties[i].value).to.be.equal('Serotonin increase');
885        expect(tokensData[i].value).to.be.equal('Serotonin increase');676      expect(tokenData!.properties[i].value).to.be.equal('Serotonin increase');
886      }677    }
887    });678    expect(await targetToken.getProperties()).to.be.empty;
888  });679  });
889680
890  it('Changes properties of a nested token according to permissions', async () => {681  itSub('Changes properties of a nested token according to permissions', async ({helper}) =>  {
891    await usingApi(async api => {
892      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});682    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
893      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
894      const token = await createItemExpectSuccess(alice, collection, 'NFT');683    const collectionB = await helper.nft.mintCollection(alice);
895      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});684    const targetToken = await collectionA.mintToken(alice);
896      await addCollectionAdminExpectSuccess(alice, collection, bob.address);685    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
897      await transferExpectSuccess(collection, token, alice, charlie);
898686
899      const propertyKeys: string[] = [];687    await collectionB.addAdmin(alice, {Substrate: bob.address});
900      let i = 0;
901      for (const permission of permissions) {
902        if (!permission.permission.mutable) continue;
903        688    await targetToken.transfer(alice, {Substrate: charlie.address});
904        for (const signer of permission.signers) {
905          const key = i + '_' + signer.address;
906          propertyKeys.push(key);
907689
908          await expect(executeTransaction(690    const propertyKeys: string[] = [];
691    let i = 0;
909            api, 692    for (const permission of permissions) {
693      i++;
910            alice, 694      if (!permission.permission.mutable) continue;
695      
911            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 696      let j = 0;
697      for (const signer of permission.signers) {
912          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;698        j++;
699        const key = i + '_' + signer.address;
700        propertyKeys.push(key);
913701
914          await expect(executeTransaction(702        await expect(
915            api, 703          nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
916            signer, 
917            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 
918          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;704          `on setting permission #${i} by alice`,
705        ).to.be.fulfilled;
919706
920          await expect(executeTransaction(707        await expect(
921            api, 708          nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
922            signer, 
923            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin stable'}]), 
924          ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;709          `on adding property #${i} by signer #${j}`,
925        }710        ).to.be.fulfilled;
926711
927        i++;712        await expect(
713          nestedToken.setProperties(signer, [{key, value: 'Serotonin stable'}]), 
714          `on changing property #${i} by signer #${j}`,
715        ).to.be.fulfilled;
928      }716      }
717    }
929718
930      const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];719    const properties = await nestedToken.getProperties(propertyKeys);
931      const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];720    const tokenData = await nestedToken.getData();
932      for (let i = 0; i < properties.length; i++) {721    for (let i = 0; i < properties.length; i++) {
933        expect(properties[i].value).to.be.equal('Serotonin stable');722      expect(properties[i].value).to.be.equal('Serotonin stable');
934        expect(tokensData[i].value).to.be.equal('Serotonin stable');723      expect(tokenData!.properties[i].value).to.be.equal('Serotonin stable');
935      }724    }
936    });725    expect(await targetToken.getProperties()).to.be.empty;
937  });726  });
938727
939  it('Deletes properties of a nested token according to permissions', async () => {728  itSub('Deletes properties of a nested token according to permissions', async ({helper}) =>  {
940    await usingApi(async api => {
941      const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});729    const collectionA = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
942      await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});
943      const token = await createItemExpectSuccess(alice, collection, 'NFT');730    const collectionB = await helper.nft.mintCollection(alice);
944      const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});731    const targetToken = await collectionA.mintToken(alice);
945      await addCollectionAdminExpectSuccess(alice, collection, bob.address);732    const nestedToken = await collectionB.mintToken(alice, targetToken.nestingAccount());
946      await transferExpectSuccess(collection, token, alice, charlie);
947733
948      const propertyKeys: string[] = [];734    await collectionB.addAdmin(alice, {Substrate: bob.address});
949      let i = 0;735    await targetToken.transfer(alice, {Substrate: charlie.address});
950736
951      for (const permission of permissions) {737    const propertyKeys: string[] = [];
738    let i = 0;
739    for (const permission of permissions) {
952        if (!permission.permission.mutable) continue;740      i++;
741      if (!permission.permission.mutable) continue;
953        742      
954        for (const signer of permission.signers) {743      let j = 0;
744      for (const signer of permission.signers) {
955          const key = i + '_' + signer.address;745        j++;
746        const key = i + '_' + signer.address;
956          propertyKeys.push(key);747        propertyKeys.push(key);
957748
958          await expect(executeTransaction(749        await expect(
959            api, 750          nestedToken.collection.setTokenPropertyPermissions(alice, [{key: key, permission: permission.permission}]), 
960            alice, 
961            api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 
962          ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;751          `on setting permission #${i} by alice`,
752        ).to.be.fulfilled;
963753
964          await expect(executeTransaction(754        await expect(
965            api, 755          nestedToken.setProperties(signer, [{key, value: 'Serotonin increase'}]), 
966            signer, 
967            api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 
968          ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;756          `on adding property #${i} by signer #${j}`,
757        ).to.be.fulfilled;
969758
970          await expect(executeTransaction(759        await expect(
971            api, 760          nestedToken.deleteProperties(signer, [key]), 
972            signer, 
973            api.tx.unique.deleteTokenProperties(collection, nestedToken, [key]), 
974          ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;761          `on deleting property #${i} by signer #${j}`,
975        }762        ).to.be.fulfilled;
976        
977        i++;
978      }763      }
764    }
979765
980      const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toJSON() as any[];766    expect(await nestedToken.getProperties(propertyKeys)).to.be.empty;
981      expect(properties).to.be.empty;
982      const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toJSON().properties as any[];767    expect((await nestedToken.getData())!.properties).to.be.empty;
983      expect(tokensData).to.be.empty;
984      expect((await api.query.nonfungible.tokenProperties(collection, nestedToken)).toJSON().consumedSpace).to.be.equal(0);768    expect(await targetToken.getProperties()).to.be.empty;
985    });
986  });769  });
987});770});
988771
989describe('Negative Integration Test: Token Properties', () => {772describe('Negative Integration Test: Token Properties', () => {
990  let collection: number;773  let alice: IKeyringPair; // collection owner
991  let token: number;774  let bob: IKeyringPair; // collection admin
992  let originalSpace: number;775  let charlie: IKeyringPair; // token owner
776
993  let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];777  let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];
994778
995  before(async () => {779  before(async () => {
996    await usingApi(async (api, privateKeyWrapper) => {780    await usingPlaygrounds(async (helper, privateKey) => {
997      alice = privateKeyWrapper('//Alice');781      const donor = privateKey('//Alice');
998      bob = privateKeyWrapper('//Bob');782      let dave: IKeyringPair;
999      charlie = privateKeyWrapper('//Charlie');783      [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor);
1000      const dave = privateKeyWrapper('//Dave');
1001784
785      // todo:playgrounds probably separate these tests later
1002      constitution = [786      constitution = [
1003        {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},787        {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},
1004        {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},788        {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},
1010    });794    });
1011  });795  });
1012796
1013  async function prepare(mode: CollectionMode, pieces: number) {797  async function getConsumedSpace(api: any, collectionId: number, tokenId: number, mode: 'NFT' | 'RFT'): Promise<number> {
1014    collection = await createCollectionExpectSuccess({mode: mode});
1015    token = await createItemExpectSuccess(alice, collection, mode.type);
1016    await addCollectionAdminExpectSuccess(alice, collection, bob.address);
1017    await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);
1018        
1019    await usingApi(async api => {
1020      let i = 0;798    return (await (mode == 'NFT' ? api.query.nonfungible : api.query.refungible).tokenProperties(collectionId, tokenId)).toJSON().consumedSpace;
1021      for (const passage of constitution) {
1022        const signer = passage.signers[0];
1023        
1024        await expect(executeTransaction(
1025          api, 
1026          alice, 
1027          api.tx.unique.setTokenPropertyPermissions(collection, [{key: `${i}`, permission: passage.permission}]), 
1028        ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;
1029  
1030        await expect(executeTransaction(
1031          api, 
1032          signer, 
1033          api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin increase'}]), 
1034        ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;
1035  
1036        i++;
1037      }
1038  
1039      originalSpace = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace as number;
1040    }); 
1041  }799  }
1042800
1043  async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(mode: CollectionMode, pieces: number) {801  async function prepare(token: UniqueNFToken | UniqueRFToken, pieces: bigint): Promise<number> {
1044    await prepare(mode, pieces);802    await token.collection.addAdmin(alice, {Substrate: bob.address});
1045  803    await token.transfer(alice, {Substrate: charlie.address}, pieces);
1046    await usingApi(async api => {804
1047      let i = -1;805    let i = 0;
1048      for (const forbiddance of constitution) {806    for (const passage of constitution) {
1049        i++;807      i++;
1050        if (!forbiddance.permission.mutable) continue;808      const signer = passage.signers[0];
1051  809      
1052        await expect(executeTransaction(810      await expect(
1053          api, 811        token.collection.setTokenPropertyPermissions(alice, [{key: `${i}`, permission: passage.permission}]), 
1054          forbiddance.sinner, 
1055          api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 
1056        ), `on failing to change property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);812        `on setting permission ${i} by alice`,
1057  813      ).to.be.fulfilled;
814
1058        await expect(executeTransaction(815      await expect(
1059          api, 816        token.setProperties(signer, [{key: `${i}`, value: 'Serotonin increase'}]), 
1060          forbiddance.sinner, 
1061          api.tx.unique.deleteTokenProperties(collection, token, [`${i}`]), 
1062        ), `on failing to delete property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);817        `on adding property ${i} by ${signer.address}`,
818      ).to.be.fulfilled;
1063      }819    }
1064  820
1065      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();821    const originalSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
1066      expect(properties.consumedSpace).to.be.equal(originalSpace);
1067    });822    return originalSpace;
1068  }823  }
824
1069  it('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async () => {825  async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
826    const originalSpace = await prepare(token, pieces);
827
828    let i = 0;
829    for (const forbiddance of constitution) {
830      i++;
831      if (!forbiddance.permission.mutable) continue;
832
833      await expect(
834        token.setProperties(forbiddance.sinner, [{key: `${i}`, value: 'Serotonin down'}]), 
835        `on failing to change property ${i} by the malefactor`,
836      ).to.be.rejectedWith(/common\.NoPermission/);
837
838      await expect(
839        token.deleteProperties(forbiddance.sinner, [`${i}`]), 
840        `on failing to delete property ${i} by the malefactor`,
841      ).to.be.rejectedWith(/common\.NoPermission/);
842    }
843
844    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
845    expect(consumedSpace).to.be.equal(originalSpace);
846  }
847
848  itSub('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async ({helper}) =>  {
1070    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'NFT'}, 1);849    const collection = await helper.nft.mintCollection(alice);
850    const token = await collection.mintToken(alice);
851    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 1n);
1071  });852  });
1072  it('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', async function() {
1073    await requirePallets(this, [Pallets.ReFungible]);
1074853
1075    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'ReFungible'}, 100);854  itSub.ifWithPallets('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
855    const collection = await helper.rft.mintCollection(alice);
856    const token = await collection.mintToken(alice, 100n);
857    await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(token, 100n);
1076  });858  });
1077859
1078  async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(mode: CollectionMode, pieces: number) {860  async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
1079    await prepare(mode, pieces);861    const originalSpace = await prepare(token, pieces);
862
1080    863    let i = 0;
1081    await usingApi(async api => {864    for (const permission of constitution) {
1082      let i = -1;865      i++;
866      if (permission.permission.mutable) continue;
867
1083      for (const permission of constitution) {868      await expect(
869        token.setProperties(permission.signers[0], [{key: `${i}`, value: 'Serotonin down'}]), 
1084        i++;870        `on failing to change property ${i} by signer #0`,
871      ).to.be.rejectedWith(/common\.NoPermission/);
872
1085        if (permission.permission.mutable) continue;873      await expect(
874        token.deleteProperties(permission.signers[0], [i.toString()]), 
875        `on failing to delete property ${i} by signer #0`,
876      ).to.be.rejectedWith(/common\.NoPermission/);
877    }
1086  878  
1087        await expect(executeTransaction(879    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
1088          api, 
1089          permission.signers[0], 
1090          api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 
1091        ), `on failing to change property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);
1092  
1093        await expect(executeTransaction(
1094          api, 
1095          permission.signers[0], 
1096          api.tx.unique.deleteTokenProperties(collection, token, [i.toString()]), 
1097        ), `on failing to delete property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);
1098      }
1099  880    expect(consumedSpace).to.be.equal(originalSpace);
1100      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
1101      expect(properties.consumedSpace).to.be.equal(originalSpace);
1102    });  
1103  }881  }
882
1104  it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async () => {883  itSub('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async ({helper}) =>  {
1105    await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'NFT'}, 1);884    const collection = await helper.nft.mintCollection(alice);
885    const token = await collection.mintToken(alice);
886    await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 1n);
1106  });887  });
1107  it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', async function() {
1108    await requirePallets(this, [Pallets.ReFungible]);
1109888
1110    await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'ReFungible'}, 100);889  itSub.ifWithPallets('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
890    const collection = await helper.rft.mintCollection(alice);
891    const token = await collection.mintToken(alice, 100n);
892    await testForbidsChangingDeletingPropertiesIfPropertyImmutable(token, 100n);
1111  });893  });
1112894
1113  async function testForbidsAddingPropertiesIfPropertyNotDeclared(mode: CollectionMode, pieces: number) {895  async function testForbidsAddingPropertiesIfPropertyNotDeclared(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
1114    await prepare(mode, pieces);896    const originalSpace = await prepare(token, pieces);
1115897
1116    await usingApi(async api => {898    await expect(
1117      await expect(executeTransaction(
1118        api, 899      token.setProperties(alice, [{key: 'non-existent', value: 'I exist!'}]), 
1119        alice, 
1120        api.tx.unique.setTokenProperties(collection, token, [{key: 'non-existent', value: 'I exist!'}]), 
1121      ), 'on failing to add a previously non-existent property').to.be.rejectedWith(/common\.NoPermission/);900      'on failing to add a previously non-existent property',
901    ).to.be.rejectedWith(/common\.NoPermission/);
1122        902      
1123      await expect(executeTransaction(903    await expect(
1124        api, 904      token.collection.setTokenPropertyPermissions(alice, [{key: 'now-existent', permission: {}}]), 
1125        alice, 
1126        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'now-existent', permission: {}}]), 
1127      ), 'on setting a new non-permitted property').to.not.be.rejected;905      'on setting a new non-permitted property',
1128  906    ).to.be.fulfilled;
907
1129      await expect(executeTransaction(908    await expect(
1130        api, 909      token.setProperties(alice, [{key: 'now-existent', value: 'I exist!'}]), 
1131        alice, 
1132        api.tx.unique.setTokenProperties(collection, token, [{key: 'now-existent', value: 'I exist!'}]), 
1133      ), 'on failing to add a property forbidden by the \'None\' permission').to.be.rejectedWith(/common\.NoPermission/);910      'on failing to add a property forbidden by the \'None\' permission',
1134  911    ).to.be.rejectedWith(/common\.NoPermission/);
912
1135      expect((await api.rpc.unique.tokenProperties(collection, token, ['non-existent', 'now-existent'])).toJSON()).to.be.empty;913    expect(await token.getProperties(['non-existent', 'now-existent'])).to.be.empty;
1136      const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();914      
915    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
1137      expect(properties.consumedSpace).to.be.equal(originalSpace);916    expect(consumedSpace).to.be.equal(originalSpace);
1138    });
1139  }917  }
918
1140  it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async () => {919  itSub('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async ({helper}) =>  {
1141    await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'NFT'}, 1);920    const collection = await helper.nft.mintCollection(alice);
921    const token = await collection.mintToken(alice);
922    await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 1n);
1142  });923  });
1143  it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', async function() {
1144    await requirePallets(this, [Pallets.ReFungible]);
1145924
1146    await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'ReFungible'}, 100);925  itSub.ifWithPallets('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
926    const collection = await helper.rft.mintCollection(alice);
927    const token = await collection.mintToken(alice, 100n);
928    await testForbidsAddingPropertiesIfPropertyNotDeclared(token, 100n);
1147  });929  });
1148930
1149  async function testForbidsAddingTooManyProperties(mode: CollectionMode, pieces: number) {931  async function testForbidsAddingTooManyProperties(token: UniqueNFToken | UniqueRFToken, pieces: bigint) {
1150    await prepare(mode, pieces);932    const originalSpace = await prepare(token, pieces);
1151933
1152    await usingApi(async api => {934    await expect(
1153      await expect(executeTransaction(
1154        api, 935      token.collection.setTokenPropertyPermissions(alice, [
1155        alice, 
1156        api.tx.unique.setTokenPropertyPermissions(collection, [
1157          {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 936        {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 
1158          {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},937        {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},
1159        ]), 938      ]), 
939      'on setting new permissions for properties',
940    ).to.be.fulfilled;
941
942    // Mute the general tx parsing error
943    {
944      console.error = () => {};
945      await expect(token.setProperties(alice, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]))
946        .to.be.rejected;
947    }
948
949    await expect(token.setProperties(alice, [
1160      ), 'on setting a new non-permitted property').to.not.be.rejected;950      {key: 'a_holy_book', value: 'word '.repeat(3277)}, 
951      {key: 'young_years', value: 'neverending'.repeat(1490)},
952    ])).to.be.rejectedWith(/common\.NoSpaceForProperty/);
1161  953  
1162      // Mute the general tx parsing error954    expect(await token.getProperties(['a_holy_book', 'young_years'])).to.be.empty;
1163      {
1164        console.error = () => {};
1165        await expect(executeTransaction(
1166          api, 
1167          alice, 
1168          api.tx.unique.setCollectionProperties(collection, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]), 
1169        )).to.be.rejected;
1170      }955    const consumedSpace = await getConsumedSpace(token.collection.helper.api, token.collectionId, token.tokenId, pieces == 1n ? 'NFT' : 'RFT'); 
1171  
1172      await expect(executeTransaction(
1173        api, 
1174        alice, 
1175        api.tx.unique.setTokenProperties(collection, token, [
1176          {key: 'a_holy_book', value: 'word '.repeat(3277)}, 
1177          {key: 'young_years', value: 'neverending'.repeat(1490)},
1178        ]), 
1179      )).to.be.rejectedWith(/common\.NoSpaceForProperty/);
1180  
1181      expect((await api.rpc.unique.tokenProperties(collection, token, ['a_holy_book', 'young_years'])).toJSON()).to.be.empty;956    expect(consumedSpace).to.be.equal(originalSpace);
1182      const propertiesMap = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();
1183      expect(propertiesMap.consumedSpace).to.be.equal(originalSpace);
1184    });
1185  }957  }
958
1186  it('Forbids adding too many properties to a token (NFT)', async () => {959  itSub('Forbids adding too many properties to a token (NFT)', async ({helper}) =>  {
1187    await testForbidsAddingTooManyProperties({type: 'NFT'}, 1);960    const collection = await helper.nft.mintCollection(alice);
961    const token = await collection.mintToken(alice);
962    await testForbidsAddingTooManyProperties(token, 1n);
1188  });963  });
1189  it('Forbids adding too many properties to a token (ReFungible)', async function() {
1190    await requirePallets(this, [Pallets.ReFungible]);
1191964
1192    await testForbidsAddingTooManyProperties({type: 'ReFungible'}, 100);965  itSub.ifWithPallets('Forbids adding too many properties to a token (ReFungible)', [Pallets.ReFungible], async ({helper}) => {
966    const collection = await helper.rft.mintCollection(alice);
967    const token = await collection.mintToken(alice, 100n);
968    await testForbidsAddingTooManyProperties(token, 100n);
1193  });969  });
1194});970});
1195971
1196describe('ReFungible token properties permissions tests', () => {972describe('ReFungible token properties permissions tests', () => {
1197  let collection: number;973  let alice: IKeyringPair;
1198  let token: number;974  let bob: IKeyringPair;
975  let charlie: IKeyringPair;
1199976
1200  before(async function() {977  before(async function() {
1201    await requirePallets(this, [Pallets.ReFungible]);978    await usingPlaygrounds(async (helper, privateKey) => {
979      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
1202980
1203    await usingApi(async (api, privateKeyWrapper) => {981      const donor = privateKey('//Alice');
1204      alice = privateKeyWrapper('//Alice');
1205      bob = privateKeyWrapper('//Bob');982      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
1206      charlie = privateKeyWrapper('//Charlie');
1207    });983    });
1208  });984  });
1209985
1210  beforeEach(async () => {986  async function prepare(helper: UniqueHelper): Promise<UniqueRFToken> {
1211    await usingApi(async api => {987    const collection = await helper.rft.mintCollection(alice);
988    const token = await collection.mintToken(alice, 100n);
1212      collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});989    
990    await collection.addAdmin(alice, {Substrate: bob.address});
1213      token = await createItemExpectSuccess(alice, collection, 'ReFungible');991    await collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable: true, tokenOwner: true}}]);
1214      await addCollectionAdminExpectSuccess(alice, collection, bob.address);992    
993    return token;
994  }
1215995
1216      await expect(executeTransaction(996  itSub('Forbids adding token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) =>  {
1217        api, 
1218        alice, 997    const token = await prepare(helper);
998
1219        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 999    await token.transfer(alice, {Substrate: charlie.address}, 33n);
1000
1001    await expect(token.setProperties(alice, [
1002      {key: 'fractals', value: 'multiverse'}, 
1220      )).to.not.be.rejected;1003    ])).to.be.rejectedWith(/common\.NoPermission/);
1221    });
1222  });1004  });
12231005
1224  it('Forbids add token property with tokenOwher==true but signer have\'t all pieces', async () => {1006  itSub('Forbids mutating token property with tokenOwher==true when signer doesn\'t have all pieces', async ({helper}) =>  {
1225    await usingApi(async api => {1007    const token = await prepare(helper);
1008
1226      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');1009    await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, tokenOwner: true}}]))
1227  1010      .to.be.fulfilled;
1011
1228      await expect(executeTransaction(1012    await expect(token.setProperties(alice, [
1229        api, 1013      {key: 'fractals', value: 'multiverse'}, 
1230        alice, 1014    ])).to.be.fulfilled;
1015
1231        api.tx.unique.setTokenProperties(collection, token, [1016    await token.transfer(alice, {Substrate: charlie.address}, 33n);
1017
1018    await expect(token.setProperties(alice, [
1232          {key: 'key', value: 'word'}, 1019      {key: 'fractals', value: 'want to rule the world'}, 
1233        ]), 
1234      )).to.be.rejectedWith(/common\.NoPermission/);1020    ])).to.be.rejectedWith(/common\.NoPermission/);
1235    });
1236  });1021  });
12371022
1238  it('Forbids mutate token property with tokenOwher==true but signer have\'t all pieces', async () => {1023  itSub('Forbids deleting token property with tokenOwner==true when signer doesn\'t have all pieces', async ({helper}) =>  {
1239    await usingApi(async api => {1024    const token = await prepare(helper);
1240      await expect(executeTransaction(
1241        api, 
1242        alice, 
1243        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 
1244      )).to.not.be.rejected;
1245  
1246      await expect(executeTransaction(
1247        api, 
1248        alice, 
1249        api.tx.unique.setTokenProperties(collection, token, [
1250          {key: 'key', value: 'word'}, 
1251        ]), 
1252      )).to.be.not.rejected;
12531025
1254      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');1026    await expect(token.setProperties(alice, [
1255  1027      {key: 'fractals', value: 'one headline - why believe it'}, 
1256      await expect(executeTransaction(
1257        api, 
1258        alice, 
1259        api.tx.unique.setTokenProperties(collection, token, [1028    ])).to.be.fulfilled;
1029
1260          {key: 'key', value: 'bad word'}, 1030    await token.transfer(alice, {Substrate: charlie.address}, 33n);
1031
1261        ]), 1032    await expect(token.deleteProperties(alice, ['fractals'])).
1262      )).to.be.rejectedWith(/common\.NoPermission/);1033      to.be.rejectedWith(/common\.NoPermission/);
1263    });
1264  });1034  });
12651035
1266  it('Forbids delete token property with tokenOwher==true but signer have\'t all pieces', async () => {1036  itSub('Allows token property mutation with collectionOwner==true when admin doesn\'t have all pieces', async ({helper}) =>  {
1267    await usingApi(async api => {1037    const token = await prepare(helper);
1268      await expect(executeTransaction(
1269        api, 
1270        alice, 
1271        api.tx.unique.setTokenProperties(collection, token, [
1272          {key: 'key', value: 'word'}, 
1273        ]), 
1274      )).to.be.not.rejected;
12751038
1276      await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');1039    await token.transfer(alice, {Substrate: charlie.address}, 33n);
1277  1040
1278      await expect(executeTransaction(1041    await expect(token.collection.setTokenPropertyPermissions(alice, [{key: 'fractals', permission: {mutable:true, collectionAdmin: true}}]))
1279        api, 
1280        alice, 1042      .to.be.fulfilled;
1043
1281        api.tx.unique.deleteTokenProperties(collection, token, [1044    await expect(token.setProperties(alice, [
1282          'key',1045      {key: 'fractals', value: 'multiverse'}, 
1283        ]), 
1284      )).to.be.rejectedWith(/common\.NoPermission/);1046    ])).to.be.fulfilled;
1285    });
1286  });1047  });
1287});1048});
12881049