git.delta.rocks / unique-network / refs/commits / 472f7ca19a8e

72    });72    });
73  });73  });
74
75  itSub('Admin (NFT): allows an Admin to nest a token', async ({helper}) => {
76    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true}}});
77    await collection.addAdmin(alice, {Substrate: bob.address});
78    const targetToken = await collection.mintToken(alice, {Substrate: charlie.address});
79
80    // Create an immediately nested token
81    const nestedToken = await collection.mintToken(bob, targetToken.nestingAccount());
82    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
83    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
84
85    // Create a token to be nested and nest
86    const newToken = await collection.mintToken(bob);
87    await newToken.nest(bob, targetToken);
88    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
89    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
90  });
91
92  itSub('Admin (NFT): Admin and Token Owner can operate together', async ({helper}) => {
93    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true}}});
94    await collection.addAdmin(alice, {Substrate: bob.address});
95    const targetToken = await collection.mintToken(alice, {Substrate: charlie.address});
96
97    // Create an immediately nested token by an administrator
98    const nestedToken = await collection.mintToken(bob, targetToken.nestingAccount());
99    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
100    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
101
102    // Create a token to be nested and nest
103    const newToken = await collection.mintToken(alice, {Substrate: charlie.address});
104    await newToken.nest(charlie, targetToken);
105    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
106    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
107  });
108
109  itSub('Admin (NFT): allows an Admin to nest a token (Restricted nesting)', async ({helper}) => {
110    const collectionA = await helper.nft.mintCollection(alice);
111    await collectionA.addAdmin(alice, {Substrate: bob.address});
112    const collectionB = await helper.nft.mintCollection(alice);
113    await collectionB.addAdmin(alice, {Substrate: bob.address});
114    await collectionA.setPermissions(alice, {nesting: {collectionAdmin: true, restricted:[collectionB.collectionId]}});
115    const targetToken = await collectionA.mintToken(alice, {Substrate: charlie.address});
116
117    // Create an immediately nested token
118    const nestedToken = await collectionB.mintToken(bob, targetToken.nestingAccount());
119    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
120    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
121
122    // Create a token to be nested and nest
123    const newToken = await collectionB.mintToken(bob);
124    await newToken.nest(bob, targetToken);
125    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
126    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
127  });
128
129  // ---------- Non-Fungible ----------
130
131  itSub('NFT: allows an Owner to nest/unnest their token', async ({helper}) => {
132    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
133    await collection.addToAllowList(alice, {Substrate: charlie.address});
134    const targetToken = await collection.mintToken(charlie);
135    await collection.addToAllowList(alice, targetToken.nestingAccount());
136
137    // Create an immediately nested token
138    const nestedToken = await collection.mintToken(charlie, targetToken.nestingAccount());
139    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
140    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
141
142    // Create a token to be nested and nest
143    const newToken = await collection.mintToken(charlie);
144    await newToken.nest(charlie, targetToken);
145    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
146    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
147  });
148
149  itSub('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async ({helper}) => {
150    const collectionA = await helper.nft.mintCollection(alice);
151    const collectionB = await helper.nft.mintCollection(alice);
152    //await collectionB.addAdmin(alice, {Substrate: bob.address});
153    const targetToken = await collectionA.mintToken(alice, {Substrate: charlie.address});
154
155    await collectionA.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionB.collectionId]}});
156    await collectionA.addToAllowList(alice, {Substrate: charlie.address});
157    await collectionA.addToAllowList(alice, targetToken.nestingAccount());
158
159    await collectionB.setPermissions(alice, {access: 'AllowList', mintMode: true});
160    await collectionB.addToAllowList(alice, {Substrate: charlie.address});
161    await collectionB.addToAllowList(alice, targetToken.nestingAccount());
162
163    // Create an immediately nested token
164    const nestedToken = await collectionB.mintToken(charlie, targetToken.nestingAccount());
165    expect(await nestedToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
166    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
167
168    // Create a token to be nested and nest
169    const newToken = await collectionB.mintToken(charlie);
170    await newToken.nest(charlie, targetToken);
171    expect(await newToken.getTopmostOwner()).to.be.deep.equal({Substrate: charlie.address});
172    expect(await newToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
173  });
174
175  // ---------- Fungible ----------
176
177  itSub('Fungible: allows an Owner to nest/unnest their token', async ({helper}) => {
178    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}}});
179    const collectionFT = await helper.ft.mintCollection(alice);
180    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
181
182    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
183    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
184
185    await collectionFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
186    await collectionFT.addToAllowList(alice, {Substrate: charlie.address});
187    await collectionFT.addToAllowList(alice, targetToken.nestingAccount());
188
189    // Create an immediately nested token
190    await collectionFT.mint(charlie, 5n, targetToken.nestingAccount());
191    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
192
193    // Create a token to be nested and nest
194    await collectionFT.mint(charlie, 5n);
195    await collectionFT.transfer(charlie, targetToken.nestingAccount(), 2n);
196    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(7n);
197  });
198
199  itSub('Fungible: allows an Owner to nest/unnest their token (Restricted nesting)', async ({helper}) => {
200    const collectionNFT = await helper.nft.mintCollection(alice);
201    const collectionFT = await helper.ft.mintCollection(alice);
202    const targetToken = await collectionNFT.mintToken(alice, {Substrate: charlie.address});
203
204    await collectionNFT.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted:[collectionFT.collectionId]}});
205    await collectionNFT.addToAllowList(alice, {Substrate: charlie.address});
206    await collectionNFT.addToAllowList(alice, targetToken.nestingAccount());
207
208    await collectionFT.setPermissions(alice, {access: 'AllowList', mintMode: true});
209    await collectionFT.addToAllowList(alice, {Substrate: charlie.address});
210    await collectionFT.addToAllowList(alice, targetToken.nestingAccount());
211
212    // Create an immediately nested token
213    await collectionFT.mint(charlie, 5n, targetToken.nestingAccount());
214    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
215
216    // Create a token to be nested and nest
217    await collectionFT.mint(charlie, 5n);
218    await collectionFT.transfer(charlie, targetToken.nestingAccount(), 2n);
219    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(7n);
220  });
22174
222  itSub.ifWithPallets('ReFungible: getTopmostOwner works correctly with Nesting', [Pallets.ReFungible], async({helper}) => {75  itSub.ifWithPallets('ReFungible: getTopmostOwner works correctly with Nesting', [Pallets.ReFungible], async({helper}) => {
223    const collectionNFT = await helper.nft.mintCollection(alice, {76    const collectionNFT = await helper.nft.mintCollection(alice, {
263    });116    });
264  });117  });
265
266  itSub('Disallows excessive token nesting', async ({helper}) => {
267    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
268    let token = await collection.mintToken(alice);
269
270    const maxNestingLevel = 5;
271
272    // Create a nested-token matryoshka
273    for (let i = 0; i < maxNestingLevel; i++) {
274      token = await collection.mintToken(alice, token.nestingAccount());
275    }
276
277    // The nesting depth is limited by `maxNestingLevel`
278    await expect(collection.mintToken(alice, token.nestingAccount()))
279      .to.be.rejectedWith(/structure\.DepthLimit/);
280    expect(await token.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
281    expect(await token.getChildren()).to.be.length(0);
282  });
283
284  // ---------- Admin ------------
285118
286  itSub('Admin (NFT): disallows an Admin to operate nesting when only TokenOwner is allowed', async ({helper}) => {119  itSub('Admin (NFT): disallows an Admin to operate nesting when only TokenOwner is allowed', async ({helper}) => {
287    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});120    const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
302  });135  });
303136
304  itSub('Admin (NFT): disallows a Token Owner to operate nesting when only Admin is allowed', async ({helper}) => {137  itSub('Admin (NFT): disallows a Token Owner to operate nesting when only Admin is allowed', async ({helper}) => {
305    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {collectionAdmin: true}}});138    const collectionAlice = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {collectionAdmin: true}}});
306    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});139    const targetTokenBob = await collectionAlice.mintToken(alice, {Substrate: bob.address});
307    await collection.addToAllowList(alice, {Substrate: bob.address});140    await collectionAlice.addToAllowList(alice, {Substrate: bob.address});
308    await collection.addToAllowList(alice, targetToken.nestingAccount());141    await collectionAlice.addToAllowList(alice, targetTokenBob.nestingAccount());
309142
310    // Try to create a nested token as token owner when it's disallowed143    // Try to create a nested token as token owner when it's disallowed
311    await expect(collection.mintToken(bob, targetToken.nestingAccount()))144    await expect(collectionAlice.mintToken(bob, targetTokenBob.nestingAccount()))
312      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);145      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
313146
314    // Try to create a token to be nested and nest147    // Try to create a token to be nested and nest
315    const newToken = await collection.mintToken(bob);148    const newToken = await collectionAlice.mintToken(bob);
316    await expect(newToken.nest(bob, targetToken))149    await expect(newToken.nest(bob, targetTokenBob))
317      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);150      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
318151
319    expect(await targetToken.getChildren()).to.be.length(0);152    expect(await targetTokenBob.getChildren()).to.be.length(0);
320    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});153    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: bob.address});
321  });154  });
322155
342    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());175    expect(await nestedToken.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
343  });176  });
344
345  itSub('Admin (NFT): disallows an Admin to nest a token from an unlisted collection (Restricted nesting)', async ({helper}) => {
346    const collectionA = await helper.nft.mintCollection(alice);
347    const collectionB = await helper.nft.mintCollection(alice);
348    await collectionA.setPermissions(alice, {nesting: {collectionAdmin: true, restricted: [collectionA.collectionId]}});
349    const targetToken = await collectionA.mintToken(alice);
350
351    // Try to create a nested token from another collection
352    await expect(collectionB.mintToken(alice, targetToken.nestingAccount()))
353      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
354
355    // Create a token in another collection yet to be nested and try to nest
356    const newToken = await collectionB.mintToken(alice);
357    await expect(newToken.nest(alice, targetToken))
358      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
359
360    expect(await targetToken.getChildren()).to.be.length(0);
361    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
362  });
363
364  // ---------- Non-Fungible ----------
365
366  itSub('NFT: disallows to nest token if nesting is disabled', async ({helper}) => {
367    // Collection is implicitly not allowed nesting at creation
368    const collection = await helper.nft.mintCollection(alice);
369    const targetToken = await collection.mintToken(alice);
370
371    // Try to create a nested token as token owner when it's disallowed
372    await expect(collection.mintToken(alice, targetToken.nestingAccount()))
373      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
374
375    // Try to create a token to be nested and nest
376    const newToken = await collection.mintToken(alice);
377    await expect(newToken.nest(alice, targetToken))
378      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
379
380    expect(await targetToken.getChildren()).to.be.length(0);
381    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
382  });
383
384  itSub('NFT: disallows a non-Owner to nest someone else\'s token', async ({helper}) => {
385    const collection = await helper.nft.mintCollection(alice);
386    const targetToken = await collection.mintToken(alice);
387
388    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
389    await collection.addToAllowList(alice, {Substrate: bob.address});
390    await collection.addToAllowList(alice, targetToken.nestingAccount());
391
392    // Try to create a token to be nested and nest
393    const newToken = await collection.mintToken(alice);
394    await expect(newToken.nest(bob, targetToken)).to.be.rejectedWith(/common\.NoPermission/);
395
396    expect(await targetToken.getChildren()).to.be.length(0);
397    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
398  });
399
400  itSub('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async ({helper}) => {
401    const collection = await helper.nft.mintCollection(alice);
402    const targetToken = await collection.mintToken(alice);
403
404    await collection.setPermissions(alice, {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true}});
405    await collection.addToAllowList(alice, {Substrate: bob.address});
406    await collection.addToAllowList(alice, targetToken.nestingAccount());
407
408    const collectionB = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true}});
409    await collectionB.addToAllowList(alice, {Substrate: bob.address});
410    await collectionB.addToAllowList(alice, targetToken.nestingAccount());
411
412    // Try to create a token to be nested and nest
413    const newToken = await collectionB.mintToken(alice);
414    await expect(newToken.nest(bob, targetToken)).to.be.rejectedWith(/common\.NoPermission/);
415
416    expect(await targetToken.getChildren()).to.be.length(0);
417    expect(await newToken.getOwner()).to.be.deep.equal({Substrate: alice.address});
418  });
419
420  itSub('NFT: disallows to nest token in an unlisted collection', async ({helper}) => {
421    // Create collection with restricted nesting -- even self is not allowed
422    const collection = await helper.nft.mintCollection(alice, {permissions: {access: 'AllowList', mintMode: true, nesting: {tokenOwner: true, restricted: []}}});
423    const targetToken = await collection.mintToken(alice, {Substrate: bob.address});
424
425    await collection.addToAllowList(alice, {Substrate: bob.address});
426    await collection.addToAllowList(alice, targetToken.nestingAccount());
427
428    // Try to mint in own collection after allowlisting the accounts
429    await expect(collection.mintToken(bob, targetToken.nestingAccount()))
430      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
431  });
432
433  // ---------- Fungible ----------
434
435  itSub('Fungible: disallows to nest token if nesting is disabled', async ({helper}) => {
436    const collectionNFT = await helper.nft.mintCollection(alice);
437    const collectionFT = await helper.ft.mintCollection(alice);
438    const targetToken = await collectionNFT.mintToken(alice);
439
440    // Try to create an immediately nested token
441    await expect(collectionFT.mint(alice, 5n, targetToken.nestingAccount()))
442      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
443
444    // Try to create a token to be nested and nest
445    await collectionFT.mint(alice, 5n);
446    await expect(collectionFT.transfer(alice, targetToken.nestingAccount(), 2n))
447      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
448    expect(await collectionFT.getBalance({Substrate: alice.address})).to.be.equal(5n);
449  });
450177
451  itSub('Fungible: disallows a non-Owner to unnest someone else\'s token', async ({helper}) => {178  itSub('Fungible: disallows a non-Owner to unnest someone else\'s token', async ({helper}) => {
452    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true}}});179    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true}}});
478    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);205    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(5n);
479  });206  });
480207
481  itSub('Fungible: disallows to nest token in an unlisted collection', async ({helper}) => {
482    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {collectionAdmin: true, tokenOwner: true, restricted: []}}});
483    const collectionFT = await helper.ft.mintCollection(alice);
484    const targetToken = await collectionNFT.mintToken(alice);
485
486    // Try to mint an immediately nested token
487    await expect(collectionFT.mint(alice, 5n, targetToken.nestingAccount()))
488      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
489
490    // Mint a token and try to nest it
491    await collectionFT.mint(alice, 5n);
492    await expect(collectionFT.transfer(alice, targetToken.nestingAccount(), 1n))
493      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
494
495    expect(await collectionFT.getBalance(targetToken.nestingAccount())).to.be.equal(0n);
496    expect(await collectionFT.getBalance({Substrate: alice.address})).to.be.equal(5n);
497  });
498});208});
499209

--- a/tests/src/sub/nesting/common.test.ts
+++ b/tests/src/sub/nesting/common.test.ts
@@ -19,61 +19,77 @@
 import {UniqueNFTCollection, UniqueRFTCollection} from '../../util/playgrounds/unique';
 
 let alice: IKeyringPair;
+let bob: IKeyringPair;
 
 before(async () => {
   await usingPlaygrounds(async (helper, privateKey) => {
     const donor = await privateKey({filename: __filename});
-    [alice] = await helper.arrange.createAccounts([100n], donor);
+    [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
   });
 });
 
 [
-  {mode: 'nft' as const, requiredPallets: []},
-  {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+  {mode: 'nft' as const, restrictedMode: true, requiredPallets: []},
+  {mode: 'nft' as const, restrictedMode: false, requiredPallets: []},
+  {mode: 'rft' as const, restrictedMode: true, requiredPallets: [Pallets.ReFungible]},
+  {mode: 'rft' as const, restrictedMode: false, requiredPallets: [Pallets.ReFungible]},
 ].map(testCase => {
-  itSub.ifWithPallets(`Owner can nest ${testCase.mode.toUpperCase()} in NFT`, testCase.requiredPallets, async ({helper}) => {
-    // Only NFT allows nesting, permissions should be set:
-    const aliceNFTCollection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
-    const targetToken = await aliceNFTCollection.mintToken(alice);
+  itSub.ifWithPallets(`Token owner can nest ${testCase.mode.toUpperCase()} in NFT if "tokenOwner" permission set ${testCase.restrictedMode ? 'in restricted mode': ''}`, testCase.requiredPallets, async ({helper}) => {
+    // Only NFT can be target for nesting in
+    const targetNFTCollection = await helper.nft.mintCollection(alice);
+    const targetTokenBob = await targetNFTCollection.mintToken(alice, {Substrate: bob.address});
 
-    const collectionForNesting = await helper[testCase.mode].mintCollection(alice);
+    const collectionForNesting = await helper[testCase.mode].mintCollection(bob);
+    // permissions should be set:
+    await targetNFTCollection.setPermissions(alice, {
+      nesting: {tokenOwner: true, restricted: testCase.restrictedMode ? [collectionForNesting.collectionId] : null},
+    });
 
-    // 1. Alice can immediately create nested token:
+    // 1. Bob can immediately create nested token:
     const nestedToken1 = testCase.mode === 'nft'
-      ? await (collectionForNesting as UniqueNFTCollection).mintToken(alice, targetToken.nestingAccount())
-      : await (collectionForNesting as UniqueRFTCollection).mintToken(alice, 10n, targetToken.nestingAccount());
-    expect(await nestedToken1.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
-    expect(await nestedToken1.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
+      ? await (collectionForNesting as UniqueNFTCollection).mintToken(bob, targetTokenBob.nestingAccount())
+      : await (collectionForNesting as UniqueRFTCollection).mintToken(bob, 10n, targetTokenBob.nestingAccount());
+    expect(await nestedToken1.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
+    expect(await nestedToken1.getOwner()).to.be.deep.equal(targetTokenBob.nestingAccount().toLowerCase());
 
-    // 2. Alice can mint and nest token:
-    const nestedToken2 = await collectionForNesting.mintToken(alice);
-    await nestedToken2.nest(alice, targetToken);
-    expect(await nestedToken2.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
-    expect(await nestedToken2.getOwner()).to.be.deep.equal(targetToken.nestingAccount().toLowerCase());
+    // 2. Bob can mint and nest token:
+    const nestedToken2 = await collectionForNesting.mintToken(bob);
+    await nestedToken2.nest(bob, targetTokenBob);
+    expect(await nestedToken2.getTopmostOwner()).to.be.deep.equal({Substrate: bob.address});
+    expect(await nestedToken2.getOwner()).to.be.deep.equal(targetTokenBob.nestingAccount().toLowerCase());
   });
 });
 
 
-itSub('Owner can nest FT in NFT', async ({helper}) => {
-  // Only NFT allows nesting, permissions should be set:
-  const aliceNFTCollection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
-  const targetToken = await aliceNFTCollection.mintToken(alice);
+[
+  {restrictedMode: true},
+  {restrictedMode: false},
+].map(testCase => {
+  itSub(`Token owner can nest FT in NFT if "tokenOwner" permission set  ${testCase.restrictedMode ? 'in restricted mode': ''}`, async ({helper}) => {
+    // Only NFT allows nesting, permissions should be set:
+    const targetNFTCollection = await helper.nft.mintCollection(alice);
+    const targetTokenBob = await targetNFTCollection.mintToken(alice, {Substrate: bob.address});
 
-  const collectionForNesting = await helper.ft.mintCollection(alice);
+    const collectionForNesting = await helper.ft.mintCollection(bob);
+    // permissions should be set:
+    await targetNFTCollection.setPermissions(alice, {
+      nesting: {tokenOwner: true, restricted: testCase.restrictedMode ? [collectionForNesting.collectionId] : null},
+    });
 
-  // 1. Alice can immediately create nested tokens:
-  await collectionForNesting.mint(alice, 100n, targetToken.nestingAccount());
-  expect(await collectionForNesting.getTop10Owners()).deep.eq([targetToken.nestingAccount().toLowerCase()]);
-  expect(await collectionForNesting.getBalance(targetToken.nestingAccount())).eq(100n);
+    // 1. Alice can immediately create nested tokens:
+    await collectionForNesting.mint(bob, 100n, targetTokenBob.nestingAccount());
+    expect(await collectionForNesting.getTop10Owners()).deep.eq([targetTokenBob.nestingAccount().toLowerCase()]);
+    expect(await collectionForNesting.getBalance(targetTokenBob.nestingAccount())).eq(100n);
 
-  // 2. Alice can mint and nest token:
-  await collectionForNesting.mint(alice, 100n);
-  await collectionForNesting.transfer(alice, targetToken.nestingAccount(), 50n);
-  expect(await collectionForNesting.getBalance(targetToken.nestingAccount())).eq(150n);
+    // 2. Alice can mint and nest token:
+    await collectionForNesting.mint(bob, 100n);
+    await collectionForNesting.transfer(bob, targetTokenBob.nestingAccount(), 50n);
+    expect(await collectionForNesting.getBalance(targetTokenBob.nestingAccount())).eq(150n);
+  });
 });
 
 
-itSub.ifWithPallets('Owner can transferFrom nested tokens', [Pallets.ReFungible], async ({helper}) => {
+itSub.ifWithPallets('Owner can unnest tokens using transferFrom', [Pallets.ReFungible], async ({helper}) => {
   const collectionToNest = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
   const tokenA = await collectionToNest.mintToken(alice);
   const tokenB = await collectionToNest.mintToken(alice);

--- a/tests/src/sub/nesting/negative.test.ts
+++ b/tests/src/sub/nesting/negative.test.ts
@@ -16,15 +16,16 @@
 
 import {IKeyringPair} from '@polkadot/types/types';
 import {expect, itSub, Pallets, usingPlaygrounds} from '../../util';
-import {UniqueNFTCollection, UniqueRFTCollection} from '../../util/playgrounds/unique';
+import {UniqueFTCollection, UniqueNFTCollection, UniqueNFToken, UniqueRFTCollection, UniqueRFToken} from '../../util/playgrounds/unique';
 import {itEth} from '../../eth/util';
 
 let alice: IKeyringPair;
+let bob: IKeyringPair;
 
 before(async () => {
   await usingPlaygrounds(async (helper, privateKey) => {
     const donor = await privateKey({filename: __filename});
-    [alice] = await helper.arrange.createAccounts([50n], donor);
+    [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
   });
 });
 
@@ -32,7 +33,7 @@
   {mode: 'nft' as const, requiredPallets: []},
   {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
 ].map(testCase => {
-  itSub.ifWithPallets(`Owner cannot nest ${testCase.mode.toUpperCase()} if nesting not allowed`, testCase.requiredPallets, async ({helper}) => {
+  itSub.ifWithPallets(`Owner cannot nest ${testCase.mode.toUpperCase()} if nesting is disabled`, testCase.requiredPallets, async ({helper}) => {
     // Create default collection, permissions are not set:
     const aliceNFTCollection = await helper.nft.mintCollection(alice);
     const targetToken = await aliceNFTCollection.mintToken(alice);
@@ -51,7 +52,7 @@
   });
 });
 
-itSub('Owner cannot nest FT if nesting not allowed', async ({helper}) => {
+itSub('Owner cannot nest FT if nesting is disabled', async ({helper}) => {
   // Create default collection, permissions are not set:
   const aliceNFTCollection = await helper.nft.mintCollection(alice);
   const targetToken = await aliceNFTCollection.mintToken(alice);
@@ -66,6 +67,65 @@
   await expect(collectionForNesting.transfer(alice, targetToken.nestingAccount(), 50n)).to.be.rejectedWith('common.UserIsNotAllowedToNest');
 });
 
+[
+  {mode: 'nft' as const},
+  {mode: 'rft' as const},
+  {mode: 'ft' as const},
+].map(testCase => {
+  itSub(`Non-owner and non-admin cannot nest ${testCase.mode.toUpperCase()} in someone else's tokens`, async ({helper}) => {
+    const targetCollection = await helper.nft.mintCollection(alice, {permissions:
+      {nesting: {tokenOwner: true, collectionAdmin: true}},
+    });
+    const targetToken = await targetCollection.mintToken(alice);
+
+    const nestedCollectionBob = await helper[testCase.mode].mintCollection(bob);
+
+    let nestedTokenBob: UniqueNFToken | UniqueRFToken;
+    switch (testCase.mode) {
+      case 'nft': nestedTokenBob = await (nestedCollectionBob as UniqueNFTCollection).mintToken(bob); break;
+      case 'rft': nestedTokenBob = await (nestedCollectionBob as UniqueRFTCollection).mintToken(bob, 100n); break;
+      case 'ft': await (nestedCollectionBob as UniqueFTCollection).mint(bob, 100n); break;
+    }
+
+    // Bob non-owner of targetToken and non admin of targetCollection, so
+    // 1. cannot mint nested token:
+    switch (testCase.mode) {
+      case 'nft': await expect((nestedCollectionBob as UniqueNFTCollection).mintToken(bob, targetToken.nestingAccount())).to.be.rejectedWith('common.UserIsNotAllowedToNest'); break;
+      case 'rft': await expect((nestedCollectionBob as UniqueRFTCollection).mintToken(bob, 100n, targetToken.nestingAccount())).to.be.rejectedWith('common.UserIsNotAllowedToNest'); break;
+      case 'ft': await expect((nestedCollectionBob as UniqueFTCollection).mint(bob, 100n, targetToken.nestingAccount())).to.be.rejectedWith('common.UserIsNotAllowedToNest'); break;
+    }
+
+    // 2. cannot nest existing token:
+    switch (testCase.mode) {
+      case 'nft':
+      case 'rft': await expect(nestedTokenBob!.transfer(bob, targetToken.nestingAccount())).to.be.rejectedWith('common.UserIsNotAllowedToNest'); break;
+      case 'ft': await expect((nestedCollectionBob as UniqueFTCollection).transfer(bob, targetToken.nestingAccount(), 100n)).to.be.rejectedWith('common.UserIsNotAllowedToNest'); break;
+    }
+  });
+});
+
+[
+  {mode: 'nft' as const, nesting: {tokenOwner: true,  collectionAdmin: false}},
+  {mode: 'nft' as const, nesting: {tokenOwner: false, collectionAdmin: true}},
+].map(testCase => {
+  itSub(`${testCase.nesting.tokenOwner ? 'Admin' : 'Token owner'} cannot nest when only ${testCase.nesting.tokenOwner ? 'tokenOwner' : 'collectionAdmin'} is allowed`, async ({helper}) => {
+    // Create collection with tokenOwner or create collection with collectionAdmin permission:
+    const targetCollection = await helper.nft.mintCollection(alice, {permissions: {nesting: testCase.nesting}});
+    const targetTokenAlice = await targetCollection.mintToken(alice);
+    await targetCollection.addAdmin(alice, {Substrate: bob.address});
+
+    const nestedCollectionAlice = await helper[testCase.mode].mintCollection(alice);
+    const nestedCollectionBob = await helper[testCase.mode].mintCollection(bob);
+    // if nesting permissions restricted for token owner – minter is bob (admin),
+    // if collectionAdmin – alice (owner)
+
+    // FIXME: nesting allowed only for admin but token owner can nest anyway:
+    testCase.nesting.tokenOwner
+      ? await expect(nestedCollectionBob.mintToken(bob, targetTokenAlice.nestingAccount())).to.be.rejectedWith(/common\.UserIsNotAllowedToNest/)
+      : await expect(nestedCollectionAlice.mintToken(alice, targetTokenAlice.nestingAccount())).to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
+  });
+});
+
 itSub.ifWithPallets('Cannot nest in non existing token', [Pallets.ReFungible], async ({helper}) => {
   const collection = await helper.nft.mintCollection(alice);
   // To avoid UserIsNotAllowedToNest error
@@ -104,7 +164,7 @@
   }
 });
 
-itEth.ifWithPallets('Cannot nest to collection address', [Pallets.ReFungible], async({helper}) => {
+itEth.ifWithPallets('Cannot nest in collection address', [Pallets.ReFungible], async({helper}) => {
   const existingCollection = await helper.nft.mintCollection(alice);
   const existingCollectionAddress = helper.ethAddress.fromCollectionId(existingCollection.collectionId);
   const futureCollectionAddress = helper.ethAddress.fromCollectionId(99999999);
@@ -140,3 +200,62 @@
   await expect(nestedToken2.nest(alice, rftToken)).to.be.rejectedWith('refungible.RefungibleDisallowsNesting');
   await expect(ftCollection.transfer(alice, {Ethereum: helper.ethAddress.fromTokenId(ftCollection.collectionId, 0)})).to.be.rejectedWith('fungible.FungibleDisallowsNesting');
 });
+
+itSub('Cannot nest in restricted collection if collection is not in the list', async ({helper}) => {
+  const {collectionId: allowedCollectionId} = await helper.nft.mintCollection(alice);
+  const notAllowedCollectionNFT = await helper.nft.mintCollection(alice);
+  const notAllowedCollectionRFT = await helper.rft.mintCollection(alice);
+  const notAllowedCollectionFT = await helper.ft.mintCollection(alice);
+
+  // Collection restricted to allowedCollectionId
+  const restrictedCollectionA = await helper.nft.mintCollection(alice, {permissions:
+    {nesting: {tokenOwner: true, restricted: [allowedCollectionId]}},
+  });
+  // Create collection with restricted nesting -- even self is not allowed
+  const restrictedCollectionB = await helper.nft.mintCollection(alice, {permissions:
+    {nesting: {tokenOwner: true, restricted: []}},
+  });
+
+  const targetTokenA = await restrictedCollectionA.mintToken(alice);
+  const targetTokenB = await restrictedCollectionB.mintToken(alice);
+
+  // 1. Cannot mint in own collection after allowlisting the accounts:
+  await expect(restrictedCollectionA.mintToken(alice, targetTokenA.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+  await expect(restrictedCollectionB.mintToken(alice, targetTokenB.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+
+  // 2. Cannot mint from notAllowedCollection:
+  await expect(notAllowedCollectionNFT.mintToken(alice, targetTokenA.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+  await expect(notAllowedCollectionNFT.mintToken(alice, targetTokenB.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+  await expect(notAllowedCollectionRFT.mintToken(alice, 100n, targetTokenA.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+  await expect(notAllowedCollectionRFT.mintToken(alice, 100n, targetTokenB.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+  await expect(notAllowedCollectionFT.mint(alice, 100n, targetTokenA.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+  await expect(notAllowedCollectionFT.mint(alice, 100n, targetTokenB.nestingAccount())).to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
+});
+
+itSub('Cannot create nesting chains greater than 5', async ({helper}) => {
+  const collection = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true}}});
+  let token = await collection.mintToken(alice);
+
+  const maxNestingLevel = 5;
+
+  // Create a nested-token matryoshka
+  for (let i = 0; i < maxNestingLevel; i++) {
+    token = await collection.mintToken(alice, token.nestingAccount());
+  }
+
+  // The nesting depth is limited by `maxNestingLevel`
+  // 1. Cannot mint:
+  await expect(collection.mintToken(alice, token.nestingAccount()))
+    .to.be.rejectedWith(/structure\.DepthLimit/);
+  // 2. Cannot transfer:
+  const anotherToken = await collection.mintToken(alice);
+  await expect(anotherToken.transfer(alice, token.nestingAccount()))
+    .to.be.rejectedWith(/structure\.DepthLimit/);
+  // 3. Cannot nest FT pieces:
+  const ftCollection = await helper.ft.mintCollection(alice);
+  await expect(ftCollection.mint(alice, 100n, token.nestingAccount()))
+    .to.be.rejectedWith(/structure\.DepthLimit/);
+
+  expect(await token.getTopmostOwner()).to.be.deep.equal({Substrate: alice.address});
+  expect(await token.getChildren()).to.has.length(0);
+});

--- a/tests/src/sub/refungible/nesting.test.ts
+++ b/tests/src/sub/refungible/nesting.test.ts
@@ -116,22 +116,6 @@
     });
   });
 
-  itSub('cannot nest token if nesting is disabled', async ({helper}) => {
-    const collectionNFT = await helper.nft.mintCollection(alice);
-    const collectionRFT = await helper.rft.mintCollection(alice);
-    const targetToken = await collectionNFT.mintToken(alice);
-
-    // Try to create an immediately nested token
-    await expect(collectionRFT.mintToken(alice, 5n, targetToken.nestingAccount()))
-      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-
-    // Try to create a token to be nested and nest
-    const token = await collectionRFT.mintToken(alice, 5n);
-    await expect(token.transfer(alice, targetToken.nestingAccount(), 2n))
-      .to.be.rejectedWith(/common\.UserIsNotAllowedToNest/);
-    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(5n);
-  });
-
   [
     {restrictedMode: true},
     {restrictedMode: false},
@@ -160,21 +144,5 @@
         .to.be.rejectedWith(/common\.ApprovedValueTooLow/);
       expect(await newToken.getBalance(targetToken.nestingAccount())).to.be.equal(1n);
     });
-  });
-
-  itSub('ReFungible: disallows to nest token to an unlisted collection', async ({helper}) => {
-    const collectionNFT = await helper.nft.mintCollection(alice, {permissions: {nesting: {tokenOwner: true, restricted: []}}});
-    const collectionRFT = await helper.rft.mintCollection(alice);
-    const targetToken = await collectionNFT.mintToken(alice);
-
-    // Try to create an immediately nested token
-    await expect(collectionRFT.mintToken(alice, 5n, targetToken.nestingAccount()))
-      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
-
-    // Try to create a token to be nested and nest
-    const token = await collectionRFT.mintToken(alice, 5n);
-    await expect(token.transfer(alice, targetToken.nestingAccount(), 2n))
-      .to.be.rejectedWith(/common\.SourceCollectionIsNotAllowedToNest/);
-    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(5n);
   });
 });