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

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

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

--- a/tests/src/nesting/graphs.test.ts
+++ b/tests/src/nesting/graphs.test.ts
@@ -1,9 +1,22 @@
-import {ApiPromise} from '@polkadot/api';
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
 import {IKeyringPair} from '@polkadot/types/types';
-import {expect} from 'chai';
-import {tokenIdToCross} from '../eth/util/helpers';
-import usingApi, {executeTransaction} from '../substrate/substrate-api';
-import {getCreateCollectionResult, transferExpectSuccess, setCollectionLimitsExpectSuccess} from '../util/helpers';
+import {expect, itSub, usingPlaygrounds} from '../util/playgrounds';
+import {UniqueHelper, UniqueNFTToken} from '../util/playgrounds/unique';
 
 /**
  * ```dot
@@ -12,46 +25,47 @@
  * 8 -> 5
  * ```
  */
-async function buildComplexObjectGraph(api: ApiPromise, sender: IKeyringPair): Promise<number> {
-  const events = await executeTransaction(api, sender, api.tx.unique.createCollectionEx({mode: 'NFT', permissions: {nesting: {tokenOwner: true}}}));
-  const {collectionId} = getCreateCollectionResult(events);
+async function buildComplexObjectGraph(helper: UniqueHelper, sender: IKeyringPair): Promise<UniqueNFTToken[]> {
+  const collection = await helper.nft.mintCollection(sender, {permissions: {nesting: {tokenOwner: true}}});
+  const tokens = await collection.mintMultipleTokens(sender, Array(8).fill({owner: {Substrate: sender.address}}));
 
-  await executeTransaction(api, sender, api.tx.unique.createMultipleItemsEx(collectionId, {NFT: Array(8).fill({owner: {Substrate: sender.address}})}));
-
-  await transferExpectSuccess(collectionId, 8, sender, tokenIdToCross(collectionId, 5));
-
-  await transferExpectSuccess(collectionId, 7, sender, tokenIdToCross(collectionId, 6));
-  await transferExpectSuccess(collectionId, 6, sender, tokenIdToCross(collectionId, 5));
-  await transferExpectSuccess(collectionId, 5, sender, tokenIdToCross(collectionId, 2));
+  await tokens[7].nest(sender, tokens[4]);
+  await tokens[6].nest(sender, tokens[5]);
+  await tokens[5].nest(sender, tokens[4]);
+  await tokens[4].nest(sender, tokens[1]);
+  await tokens[3].nest(sender, tokens[2]);
+  await tokens[2].nest(sender, tokens[1]);
+  await tokens[1].nest(sender, tokens[0]);
 
-  await transferExpectSuccess(collectionId, 4, sender, tokenIdToCross(collectionId, 3));
-  await transferExpectSuccess(collectionId, 3, sender, tokenIdToCross(collectionId, 2));
-  await transferExpectSuccess(collectionId, 2, sender, tokenIdToCross(collectionId, 1));
-
-  return collectionId;
+  return tokens;
 }
 
 describe('Graphs', () => {
-  it('Ouroboros can\'t be created in a complex graph', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      const alice = privateKeyWrapper('//Alice');
-      const collection = await buildComplexObjectGraph(api, alice);
-      const tokenTwoParent = tokenIdToCross(collection, 1);
+  let alice: IKeyringPair;
 
-      // to self
-      await expect(
-        executeTransaction(api, alice, api.tx.unique.transfer(tokenIdToCross(collection, 1), collection, 1, 1)),
-        'first transaction',  
-      ).to.be.rejectedWith(/structure\.OuroborosDetected/);
-      // to nested part of graph
-      await expect(
-        executeTransaction(api, alice, api.tx.unique.transfer(tokenIdToCross(collection, 5), collection, 1, 1)),
-        'second transaction',
-      ).to.be.rejectedWith(/structure\.OuroborosDetected/);
-      await expect(
-        executeTransaction(api, alice, api.tx.unique.transferFrom(tokenTwoParent, tokenIdToCross(collection, 8), collection, 2, 1)),
-        'third transaction',
-      ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+  before(async () => {
+    await usingPlaygrounds(async (helper, privateKey) => {
+      const donor = privateKey('//Alice');
+      [alice] = await helper.arrange.createAccounts([10n], donor);
     });
   });
+
+  itSub('Ouroboros can\'t be created in a complex graph', async ({helper}) => {
+    const tokens = await buildComplexObjectGraph(helper, alice);
+
+    // to self
+    await expect(
+      tokens[0].nest(alice, tokens[0]),
+      'first transaction',  
+    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+    // to nested part of graph
+    await expect(
+      tokens[0].nest(alice, tokens[4]),
+      'second transaction',
+    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+    await expect(
+      tokens[1].transferFrom(alice, tokens[0].nestingAddress(), tokens[7].nestingAddress()),
+      'third transaction',
+    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
+  });
 });

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

--- 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.nestingAddress());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
+    
+    // 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.nestingAddress());
 
-      // 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.nestingAddress());
+    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
+    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
 
-      // 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.nestingAddress());
+    expect(await tokenC.getOwner()).to.be.deep.equal(tokenA.nestingAddress());
+    
+    // Transfer the nested token to another token
+    await expect(tokenC.transferFrom(alice, tokenA.nestingAddress(), tokenB.nestingAddress())).to.be.fulfilled;
+    expect(await tokenC.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
+    expect(await tokenC.getOwner()).to.be.deep.equal(tokenB.nestingAddress());
   });
 
-  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.nestingAddress());
+    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.nestingAddress(), 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.nestingAddress(), tokenA.nestingAddress(), 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.nestingAddress(), tokenA.nestingAddress(), 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.nestingAddress());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
 
-      // 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.nestingAddress());
   });
 
-  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.nestingAddress());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
 
-      // 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.nestingAddress());
   });
 
-  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.nestingAddress());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
 
-      // 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.nestingAddress());
   });
 
   // ---------- 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.nestingAddress());
 
-      // 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.nestingAddress());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
 
-      // 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.nestingAddress());
   });
 
-  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.nestingAddress());
+
+    await collectionB.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    await collectionB.addToAllowList(alice, {Substrate: charlie.address});
+    await collectionB.addToAllowList(alice, targetToken.nestingAddress());
 
-      // 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.nestingAddress());
+    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
+    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAddress());
+
+    // 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.nestingAddress());
   });
 
   // ---------- 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.nestingAddress());
 
-      // 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.nestingAddress());
 
-      // 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.nestingAddress());
+    expect(await collectionFT.getBalance(targetToken.nestingAddress())).to.be.equal(5n);
+
+    // Create a token to be nested and nest
+    await collectionFT.mint(charlie, 5n);
+    await collectionFT.transfer(charlie, targetToken.nestingAddress(), 2n);
+    expect(await collectionFT.getBalance(targetToken.nestingAddress())).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.nestingAddress());
 
-      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.nestingAddress());
 
-      // 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.nestingAddress());
+    expect(await collectionFT.getBalance(targetToken.nestingAddress())).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.nestingAddress(), 2n);
+    expect(await collectionFT.getBalance(targetToken.nestingAddress())).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.nestingAddress());
 
-      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.nestingAddress());
 
-      // 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.nestingAddress());
+    expect(await nestedToken.getBalance(targetToken.nestingAddress())).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.nestingAddress(), 2n);
+    expect(await newToken.getBalance(targetToken.nestingAddress())).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.nestingAddress());
 
-      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.nestingAddress());
 
-      await setCollectionPermissionsExpectSuccess(alice, collectionNFT, {nesting: {tokenOwner: true, restricted:[collectionRFT]}});
+    // Create an immediately nested token
+    const nestedToken = await collectionRFT.mintToken(charlie, 5n, targetToken.nestingAddress());
+    expect(await nestedToken.getBalance(targetToken.nestingAddress())).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.nestingAddress(), 2n);
+    expect(await newToken.getBalance(targetToken.nestingAddress())).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.nestingAddress());
+    }
 
-      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.nestingAddress()))
+      .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.nestingAddress()))
+      .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.nestingAddress());
+
+    // Try to create a nested token as token owner when it's disallowed
+    await expect(collection.mintToken(bob, targetToken.nestingAddress()))
+      .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.nestingAddress());
 
-      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.nestingAddress());
+    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.nestingAddress());
   });
 
-  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.nestingAddress()))
+      .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.nestingAddress()))
+      .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.nestingAddress());
 
-      // 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.nestingAddress());
 
-      // 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.nestingAddress());
 
-      // 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.nestingAddress());
 
-      // 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.nestingAddress()))
+      .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.nestingAddress()))
+      .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.nestingAddress(), 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.nestingAddress());
 
-      // 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.nestingAddress(), {Substrate: bob.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await collectionFT.getBalance(targetToken.nestingAddress())).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.nestingAddress());
 
-      // 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.nestingAddress(), {Substrate: bob.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await collectionFT.getBalance(targetToken.nestingAddress())).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.nestingAddress()))
+      .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.nestingAddress(), 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.nestingAddress())).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.nestingAddress()))
+      .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.nestingAddress(), 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.nestingAddress());
 
-      // 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.nestingAddress())).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.nestingAddress());
 
-      // 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.nestingAddress(), {Substrate: alice.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await newToken.getBalance(targetToken.nestingAddress())).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.nestingAddress());
 
-      // 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.nestingAddress())).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.nestingAddress());
 
-      // 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.nestingAddress(), {Substrate: alice.address}, 1n))
+      .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
+    expect(await newToken.getBalance(targetToken.nestingAddress())).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.nestingAddress()))
+      .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.nestingAddress(), 2n))
+      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(5n);
   });
 });

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