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

no syntactic changes

240  }240  }
241241
242  fromTokenId(collectionId: number, tokenId: number): string  {242  fromTokenId(collectionId: number, tokenId: number): string  {
243    return this.helper.util.getNestingTokenAddress(collectionId, tokenId);243    return this.helper.util.getTokenAddress({collectionId, tokenId});
244  }244  }
245245
246  normalizeAddress(address: string): string {246  normalizeAddress(address: string): string {

1import {ApiPromise} from '@polkadot/api';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 {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
3import {expect} from 'chai';18import {expect, itSub, usingPlaygrounds} from '../util/playgrounds';
4import {tokenIdToCross} from '../eth/util/helpers';
5import usingApi, {executeTransaction} from '../substrate/substrate-api';
6import {getCreateCollectionResult, transferExpectSuccess, setCollectionLimitsExpectSuccess} from '../util/helpers';19import {UniqueHelper, UniqueNFToken} from '../util/playgrounds/unique';
720
8/**21/**
9 * ```dot22 * ```dot
12 * 8 -> 525 * 8 -> 5
13 * ```26 * ```
14 */27 */
15async function buildComplexObjectGraph(api: ApiPromise, sender: IKeyringPair): Promise<number> {28async function buildComplexObjectGraph(helper: UniqueHelper, sender: IKeyringPair): Promise<UniqueNFToken[]> {
16  const events = await executeTransaction(api, sender, api.tx.unique.createCollectionEx({mode: 'NFT', permissions: {nesting: {tokenOwner: true}}}));29  const collection = await helper.nft.mintCollection(sender, {permissions: {nesting: {tokenOwner: true}}});
17  const {collectionId} = getCreateCollectionResult(events);30  const tokens = await collection.mintMultipleTokens(sender, Array(8).fill({owner: {Substrate: sender.address}}));
18
19  await executeTransaction(api, sender, api.tx.unique.createMultipleItemsEx(collectionId, {NFT: Array(8).fill({owner: {Substrate: sender.address}})}));
2031
21  await transferExpectSuccess(collectionId, 8, sender, tokenIdToCross(collectionId, 5));32  await tokens[7].nest(sender, tokens[4]);
22
23  await transferExpectSuccess(collectionId, 7, sender, tokenIdToCross(collectionId, 6));33  await tokens[6].nest(sender, tokens[5]);
24  await transferExpectSuccess(collectionId, 6, sender, tokenIdToCross(collectionId, 5));34  await tokens[5].nest(sender, tokens[4]);
25  await transferExpectSuccess(collectionId, 5, sender, tokenIdToCross(collectionId, 2));35  await tokens[4].nest(sender, tokens[1]);
26
27  await transferExpectSuccess(collectionId, 4, sender, tokenIdToCross(collectionId, 3));36  await tokens[3].nest(sender, tokens[2]);
28  await transferExpectSuccess(collectionId, 3, sender, tokenIdToCross(collectionId, 2));37  await tokens[2].nest(sender, tokens[1]);
29  await transferExpectSuccess(collectionId, 2, sender, tokenIdToCross(collectionId, 1));38  await tokens[1].nest(sender, tokens[0]);
3039
31  return collectionId;40  return tokens;
32}41}
3342
34describe('Graphs', () => {43describe('Graphs', () => {
44  let alice: IKeyringPair;
45
46  before(async () => {
47    await usingPlaygrounds(async (helper, privateKey) => {
48      const donor = privateKey('//Alice');
49      [alice] = await helper.arrange.createAccounts([10n], donor);
50    });
51  });
52
35  it('Ouroboros can\'t be created in a complex graph', async () => {53  itSub('Ouroboros can\'t be created in a complex graph', async ({helper}) => {
36    await usingApi(async (api, privateKeyWrapper) => {54    const tokens = await buildComplexObjectGraph(helper, alice);
37      const alice = privateKeyWrapper('//Alice');
38      const collection = await buildComplexObjectGraph(api, alice);
39      const tokenTwoParent = tokenIdToCross(collection, 1);
4055
41      // to self56    // to self
42      await expect(57    await expect(
43        executeTransaction(api, alice, api.tx.unique.transfer(tokenIdToCross(collection, 1), collection, 1, 1)),58      tokens[0].nest(alice, tokens[0]),
44        'first transaction',  59      'first transaction',  
45      ).to.be.rejectedWith(/structure\.OuroborosDetected/);60    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
46      // to nested part of graph61    // to nested part of graph
47      await expect(62    await expect(
48        executeTransaction(api, alice, api.tx.unique.transfer(tokenIdToCross(collection, 5), collection, 1, 1)),63      tokens[0].nest(alice, tokens[4]),
49        'second transaction',64      'second transaction',
50      ).to.be.rejectedWith(/structure\.OuroborosDetected/);65    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
51      await expect(66    await expect(
52        executeTransaction(api, alice, api.tx.unique.transferFrom(tokenTwoParent, tokenIdToCross(collection, 8), collection, 2, 1)),67      tokens[1].transferFrom(alice, tokens[0].nestingAccount(), tokens[7].nestingAccount()),
53        'third transaction',68      'third transaction',
54      ).to.be.rejectedWith(/structure\.OuroborosDetected/);69    ).to.be.rejectedWith(/structure\.OuroborosDetected/);
55    });
56  });70  });
57});71});
5872

8import find from 'find-process';8import find from 'find-process';
99
10// todo un-skip for migrations10// todo un-skip for migrations
11// todo:playgrounds skipped, this one is outdated. Probably to be deleted/replaced.
11describe.skip('Migration testing', () => {12describe.skip('Migration testing: Properties', () => {
12  let alice: IKeyringPair;13  let alice: IKeyringPair;
1314
14  before(async() => {15  before(async() => {

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