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

--- a/tests/.eslintrc.json
+++ b/tests/.eslintrc.json
@@ -42,6 +42,7 @@
                 "avoidEscape": true
             }
         ],
+        "require-await": 2,
         "semi": [
             "error",
             "always"

--- a/tests/src/addCollectionAdmin.test.ts
+++ b/tests/src/addCollectionAdmin.test.ts
@@ -56,10 +56,8 @@
     const collection = await helper.collection.getData(collectionId);
     expect(collection?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
 
-    const changeAdminTxBob = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: bob.address});
-    const changeAdminTxCharlie = async () => helper.collection.addAdmin(bob, collectionId, {Substrate: charlie.address});
-    await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
-    await expect(changeAdminTxBob()).to.be.rejectedWith(/common\.NoPermission/);
+    await expect(helper.collection.addAdmin(bob, collectionId, {Substrate: charlie.address})).to.be.rejectedWith(/common\.NoPermission/);
+    await expect(helper.collection.addAdmin(bob, collectionId, {Substrate: bob.address})).to.be.rejectedWith(/common\.NoPermission/);
 
     const adminListAfterAddAdmin = await helper.collection.getAdmins(collectionId);
     expect(adminListAfterAddAdmin).to.be.not.deep.contains({Substrate: charlie.address});
@@ -75,8 +73,7 @@
     const adminListAfterAddAdmin = await collection.getAdmins();
     expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
 
-    const changeAdminTxCharlie = async () => collection.addAdmin(bob, {Substrate: charlie.address});
-    await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
+    await expect(collection.addAdmin(bob, {Substrate: charlie.address})).to.be.rejectedWith(/common\.NoPermission/);
 
     const adminListAfterAddNewAdmin = await collection.getAdmins();
     expect(adminListAfterAddNewAdmin).to.be.deep.contains({Substrate: bob.address});
@@ -87,8 +84,7 @@
     const [alice, bob] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
     const collectionId = (1 << 32) - 1;
 
-    const addAdminTx = async () => helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
-    await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
+    await expect(helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address})).to.be.rejectedWith(/common\.CollectionNotFound/);
 
     // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
     await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
@@ -99,8 +95,7 @@
     const collection = await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
 
     await collection.burn(alice);
-    const addAdminTx = async () => collection.addAdmin(alice, {Substrate: bob.address});
-    await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
+    await expect(collection.addAdmin(alice, {Substrate: bob.address})).to.be.rejectedWith(/common\.CollectionNotFound/);
 
     // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
     await helper.nft.mintCollection(alice, {name: 'Collection Name', description: 'Collection Description', tokenPrefix: 'COL'});
@@ -119,7 +114,6 @@
       expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: accounts[i].address});
     }
 
-    const addExtraAdminTx = async () => collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address});
-    await expect(addExtraAdminTx()).to.be.rejectedWith(/common\.CollectionAdminCountExceeded/);
+    await expect(collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address})).to.be.rejectedWith(/common\.CollectionAdminCountExceeded/);
   });
 });

--- a/tests/src/adminTransferAndBurn.test.ts
+++ b/tests/src/adminTransferAndBurn.test.ts
@@ -36,8 +36,7 @@
     expect(limits.ownerCanTransfer).to.be.true;
 
     const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-    const transferResult = async () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
-    await expect(transferResult()).to.be.rejected;
+    await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address})).to.be.rejected;
 
     await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
     const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
@@ -52,9 +51,8 @@
     expect(limits.ownerCanTransfer).to.be.true;
 
     const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-    const burnTxFailed = async () => helper.nft.burnToken(alice, collectionId, tokenId);
 
-    await expect(burnTxFailed()).to.be.rejected;
+    await expect(helper.nft.burnToken(alice, collectionId, tokenId)).to.be.rejected;
 
     await helper.nft.burnToken(bob, collectionId, tokenId);
     const token = await helper.nft.getToken(collectionId, tokenId);

--- a/tests/src/allowLists.test.ts
+++ b/tests/src/allowLists.test.ts
@@ -30,7 +30,7 @@
     });
   });
 
-  describe('Positive', async () => {
+  describe('Positive', () => {
     itSub('Owner can add address to allow list', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       // allow list does not need to be enabled to add someone in advance
@@ -58,7 +58,7 @@
     });
   });
 
-  describe('Negative', async () => {
+  describe('Negative', () => {
     itSub('Nobody can add address to allow list of non-existing collection', async ({helper}) => {
       const collectionId = (1<<32) - 1;
       await expect(helper.nft.addToAllowList(bob, collectionId, {Substrate: charlie.address}))
@@ -92,7 +92,7 @@
     });
   });
 
-  describe('Positive', async () => {
+  describe('Positive', () => {
     itSub('Owner can remove address from allow list', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: bob.address});
@@ -128,7 +128,7 @@
     });
   });
 
-  describe('Negative', async () => {
+  describe('Negative', () => {
     itSub('Non-privileged user cannot remove address from allow list', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
@@ -168,7 +168,7 @@
     });
   });
 
-  describe('Positive', async () => {
+  describe('Positive', () => {
     itSub('If Public Access mode is set to AllowList, tokens can be transferred to a allowlisted address with transfer.', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -219,7 +219,7 @@
     });
   });
 
-  describe('Negative', async () => {
+  describe('Negative', () => {
     itSub('If Public Access mode is set to AllowList, tokens can\'t be transferred from a non-allowlisted address with transfer or transferFrom. Test1', async ({helper}) => {
       const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
       const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -303,7 +303,7 @@
     {access: 'AllowList', mintMode: true},
   ];
 
-  const testPermissionSuite = async (permissions: ICollectionPermissions) => {
+  const testPermissionSuite = (permissions: ICollectionPermissions) => {
     const allowlistedMintingShouldFail = !permissions.mintMode!;
 
     const appropriateRejectionMessage = permissions.mintMode! ? /common\.AddressNotInAllowlist/ : /common\.PublicMintingNotAllowed/;
@@ -323,8 +323,8 @@
     );
 
 
-    describe(`Public Access Mode = ${permissions.access}, Mint Mode = ${permissions.mintMode}`, async () => {
-      describe('Positive', async () => {
+    describe(`Public Access Mode = ${permissions.access}, Mint Mode = ${permissions.mintMode}`, () => {
+      describe('Positive', () => {
         itSub('With the condtions above, tokens can be created by owner', async ({helper}) => {
           const collection = await helper.nft.mintCollection(alice, {});
           await collection.setPermissions(alice, permissions);
@@ -341,7 +341,7 @@
         if (!allowlistedMintingShouldFail) allowlistedMintingTest();
       });
 
-      describe('Negative', async () => {
+      describe('Negative', () => {
         itSub('With the condtions above, tokens can\'t be created by non-priviliged non-allow-listed address', async ({helper}) => {
           const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
           await collection.setPermissions(alice, permissions);

--- a/tests/src/approve.test.ts
+++ b/tests/src/approve.test.ts
@@ -92,7 +92,7 @@
   itSub('can`t be called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => {
     const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-    const approveTokenTx = async () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
+    const approveTokenTx = () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
     await expect(approveTokenTx()).to.be.rejected;
   });
 });
@@ -196,7 +196,7 @@
     await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});
     const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
     expect(owner.Substrate).to.be.equal(alice.address);
-    const transferTokenFromTx = async () => helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});
+    const transferTokenFromTx = () => helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});
     await expect(transferTokenFromTx()).to.be.rejected;
   });
 
@@ -210,7 +210,7 @@
     const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address});
     expect(after - before).to.be.equal(BigInt(1));
 
-    const transferTokenFromTx = async () => helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n);
+    const transferTokenFromTx = () => helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n);
     await expect(transferTokenFromTx()).to.be.rejected;
   });
 
@@ -222,7 +222,7 @@
     await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 100n);
     const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});
     expect(after - before).to.be.equal(BigInt(100));
-    const transferTokenFromTx = async () => helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 100n);
+    const transferTokenFromTx = () => helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 100n);
     await expect(transferTokenFromTx()).to.be.rejected;
   });
 });
@@ -277,7 +277,7 @@
     expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;
     await helper.signTransaction(alice, helper.constructApiCall('api.tx.unique.approve', [{Substrate: bob.address}, collectionId, tokenId, 0]));
     expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;
-    const transferTokenFromTx = async () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address});
+    const transferTokenFromTx = () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address});
     await expect(transferTokenFromTx()).to.be.rejected;
   });
 
@@ -293,7 +293,7 @@
     const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});
     expect(amountAfter).to.be.equal(BigInt(0));
 
-    const transferTokenFromTx = async () => helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 1n);
+    const transferTokenFromTx = () => helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 1n);
     await expect(transferTokenFromTx()).to.be.rejected;
   });
 
@@ -308,7 +308,7 @@
     const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});
     expect(amountAfter).to.be.equal(BigInt(0));
 
-    const transferTokenFromTx = async () => helper.rft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 100n);
+    const transferTokenFromTx = () => helper.rft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 100n);
     await expect(transferTokenFromTx()).to.be.rejected;
   });
 });
@@ -328,7 +328,7 @@
   itSub('1 for NFT', async ({helper}) => {
     const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
-    const approveTx = async () => helper.signTransaction(bob, helper.constructApiCall('api.tx.unique.approve', [{Substrate: charlie.address}, collectionId, tokenId, 2]));
+    const approveTx = () => helper.signTransaction(bob, helper.constructApiCall('api.tx.unique.approve', [{Substrate: charlie.address}, collectionId, tokenId, 2]));
     await expect(approveTx()).to.be.rejected;
     expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.false;
   });
@@ -337,14 +337,14 @@
     const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
     await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);
     const tokenId = await helper.ft.getLastTokenId(collectionId);
-    const approveTx = async () => helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 11n);
+    const approveTx = () => helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 11n);
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => {
     const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});
-    const approveTx = async () => helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 101n);
+    const approveTx = () => helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 101n);
     await expect(approveTx()).to.be.rejected;
   });
 });
@@ -483,7 +483,7 @@
     const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
     await helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
-    const approveTx = async () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});
+    const approveTx = () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});
     await expect(approveTx()).to.be.rejected;
   });
 });
@@ -502,59 +502,59 @@
 
   itSub('[nft] Approve for a collection that does not exist', async ({helper}) => {
     const collectionId = 1 << 32 - 1;
-    const approveTx = async () => helper.nft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
+    const approveTx = () => helper.nft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub('[fungible] Approve for a collection that does not exist', async ({helper}) => {
     const collectionId = 1 << 32 - 1;
-    const approveTx = async () => helper.ft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
+    const approveTx = () => helper.ft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub.ifWithPallets('[refungible] Approve for a collection that does not exist', [Pallets.ReFungible], async ({helper}) => {
     const collectionId = 1 << 32 - 1;
-    const approveTx = async () => helper.rft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
+    const approveTx = () => helper.rft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub('[nft] Approve for a collection that was destroyed', async ({helper}) => {
     const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await helper.nft.burn(alice, collectionId);
-    const approveTx = async () => helper.nft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
+    const approveTx = () => helper.nft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub('[fungible] Approve for a collection that was destroyed', async ({helper}) => {
     const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await helper.ft.burn(alice, collectionId);
-    const approveTx = async () => helper.ft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
+    const approveTx = () => helper.ft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub.ifWithPallets('[refungible] Approve for a collection that was destroyed', [Pallets.ReFungible], async ({helper}) => {
     const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await helper.rft.burn(alice, collectionId);
-    const approveTx = async () => helper.rft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
+    const approveTx = () => helper.rft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
     await expect(approveTx()).to.be.rejected;
   });
   
   itSub('[nft] Approve transfer of a token that does not exist', async ({helper}) => {
     const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const approveTx = async () => helper.nft.approveToken(alice, collectionId, 2, {Substrate: bob.address});
+    const approveTx = () => helper.nft.approveToken(alice, collectionId, 2, {Substrate: bob.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub.ifWithPallets('[refungible] Approve transfer of a token that does not exist', [Pallets.ReFungible], async ({helper}) => {
     const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const approveTx = async () => helper.rft.approveToken(alice, collectionId, 2, {Substrate: bob.address});
+    const approveTx = () => helper.rft.approveToken(alice, collectionId, 2, {Substrate: bob.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub('[nft] Approve using the address that does not own the approved token', async ({helper}) => {
     const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
-    const approveTx = async () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
+    const approveTx = () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
     await expect(approveTx()).to.be.rejected;
   });
 
@@ -562,14 +562,14 @@
     const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);
     const tokenId = await helper.ft.getLastTokenId(collectionId);
-    const approveTx = async () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
+    const approveTx = () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
     await expect(approveTx()).to.be.rejected;
   });
 
   itSub.ifWithPallets('[refungible] Approve using the address that does not own the approved token', [Pallets.ReFungible], async ({helper}) => {
     const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});
-    const approveTx = async () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
+    const approveTx = () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
     await expect(approveTx()).to.be.rejected;
   });
 
@@ -579,7 +579,7 @@
     await helper.rft.transferToken(alice, collectionId, tokenId, {Substrate: bob.address}, 100n);
     await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 100n);
 
-    const approveTx = async () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 101n);
+    const approveTx = () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 101n);
     await expect(approveTx()).to.be.rejected;
   });
 
@@ -590,7 +590,7 @@
 
     await helper.ft.transferToken(alice, collectionId, tokenId, {Substrate: bob.address}, 10n);
     await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 10n);
-    const approveTx = async () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 11n);
+    const approveTx = () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 11n);
     await expect(approveTx()).to.be.rejected;
   });
 
@@ -599,7 +599,7 @@
     const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
     await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: false});
 
-    const approveTx = async () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
+    const approveTx = () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
     await expect(approveTx()).to.be.rejected;
   });
 });

--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -56,7 +56,7 @@
 
     await collection.changeOwner(alice, bob.address);
 
-    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    const changeOwnerTx = () => collection.changeOwner(alice, alice.address);
     await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
     const afterChanging = await helper.collection.getData(collection.collectionId);
@@ -115,20 +115,20 @@
 
   itSub('Not owner can\'t change owner.', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    const changeOwnerTx = () => collection.changeOwner(bob, bob.address);
     await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
   itSub('Collection admin can\'t change owner.', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await collection.addAdmin(alice, {Substrate: bob.address});
-    const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+    const changeOwnerTx = () => collection.changeOwner(bob, bob.address);
     await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
   itSub('Can\'t change owner of a non-existing collection.', async ({helper}) => {
     const collectionId = (1 << 32) - 1;
-    const changeOwnerTx = async () => helper.collection.changeOwner(bob, collectionId, bob.address);
+    const changeOwnerTx = () => helper.collection.changeOwner(bob, collectionId, bob.address);
     await expect(changeOwnerTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
@@ -136,15 +136,15 @@
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await collection.changeOwner(alice, bob.address);
 
-    const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+    const changeOwnerTx = () => collection.changeOwner(alice, alice.address);
     await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
 
     const afterChanging = await helper.collection.getData(collection.collectionId);
     expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
 
-    const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
-    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
-    const removeSponsorTx = async () => collection.removeSponsor(alice);
+    const setSponsorTx = () => collection.setSponsor(alice, charlie.address);
+    const confirmSponsorshipTx = () => collection.confirmSponsorship(alice);
+    const removeSponsorTx = () => collection.removeSponsor(alice);
     await expect(setSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
     await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
     await expect(removeSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
@@ -157,13 +157,13 @@
       ownerCanTransfer: true,
     };
 
-    const setLimitsTx = async () => collection.setLimits(alice, limits);
+    const setLimitsTx = () => collection.setLimits(alice, limits);
     await expect(setLimitsTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-    const setPermissionTx = async () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+    const setPermissionTx = () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
     await expect(setPermissionTx()).to.be.rejectedWith(/common\.NoPermission/);
 
-    const burnTx = async () => collection.burn(alice);
+    const burnTx = () => collection.burn(alice);
     await expect(burnTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 });

--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -119,7 +119,7 @@
     await token.transfer(alice, {Substrate: zeroBalance.address});
     const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    const transferTx = () => token.transfer(zeroBalance, {Substrate: alice.address});
     await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
     const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
@@ -137,7 +137,7 @@
     await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
     const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
 
-    const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
+    const transferTx = () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
     await expect(transferTx()).to.be.rejected;
     const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
@@ -155,7 +155,7 @@
     await token.transfer(zeroBalance, {Substrate: alice.address});
 
     const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+    const transferTx = () => token.transfer(zeroBalance, {Substrate: alice.address});
     await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
     const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
@@ -175,7 +175,7 @@
     await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
 
     const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
-    const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+    const mintTx = () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
     await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
     const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
 
@@ -199,21 +199,21 @@
 
   itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {
     const collectionId = (1 << 32) - 1;
-    const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
+    const confirmSponsorshipTx = () => helper.collection.confirmSponsorship(bob, collectionId);
     await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
   itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await collection.setSponsor(alice, bob.address);
-    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
     await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
   itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await collection.setSponsor(alice, bob.address);
-    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+    const confirmSponsorshipTx = () => collection.confirmSponsorship(alice);
     await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
@@ -221,20 +221,20 @@
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await collection.setSponsor(alice, bob.address);
     await collection.addAdmin(alice, {Substrate: charlie.address});
-    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
     await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
   itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
     await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
   });
 
   itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
     await collection.burn(alice);
-    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
     await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
@@ -244,7 +244,7 @@
     await collection.confirmSponsorship(bob);
     const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
     const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
-    const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
+    const transferTx = () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
     await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
     const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
     expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);

--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -116,20 +116,20 @@
   });
 
   itSub('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async ({helper}) => {
-    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
+    const mintCollectionTx = () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
     await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
   itSub('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async ({helper}) => {
-    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
+    const mintCollectionTx = () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
     await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
   itSub('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async ({helper}) => {
-    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
+    const mintCollectionTx = () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
     await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
   
   itSub('(!negative test!) fails when bad limits are set', async ({helper}) => {
-    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
+    const mintCollectionTx = () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
     await expect(mintCollectionTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
 
@@ -139,7 +139,7 @@
     for (let i = 0; i < 65; i++) {
       props.push({key: `key${i}`, value: `value${i}`});
     }
-    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    const mintCollectionTx = () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
     await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 
@@ -150,7 +150,7 @@
       props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)});
     }
 
-    const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+    const mintCollectionTx = () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
     await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
   });
 });

--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -186,17 +186,17 @@
 
   itSub('Regular user cannot create new item in NFT collection', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
+    const mintTx = () => collection.mintToken(bob, {Substrate: bob.address});
     await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
   itSub('Regular user cannot create new item in Fungible collection', async ({helper}) => {
     const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
-    const mintTx = async () => collection.mint(bob, 10n, {Substrate: bob.address});
+    const mintTx = () => collection.mint(bob, 10n, {Substrate: bob.address});
     await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
   itSub.ifWithPallets('Regular user cannot create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
     const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const mintTx = async () => collection.mintToken(bob, 100n, {Substrate: bob.address});
+    const mintTx = () => collection.mintToken(bob, 100n, {Substrate: bob.address});
     await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
@@ -204,7 +204,7 @@
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
       tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
     });
-    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    const mintTx = () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
     await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
@@ -212,13 +212,13 @@
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
       tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
     });
-    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    const mintTx = () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
     await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
   itSub('Adding property without access rights', async ({helper}) => {
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+    const mintTx = () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
     await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
@@ -231,7 +231,7 @@
 
 
     const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
-    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
+    const mintTx = () => collection.mintToken(alice, {Substrate: bob.address}, props);
     await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
@@ -242,7 +242,7 @@
         {key: 'k2', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
       ],
     });
-    const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [
+    const mintTx = () => collection.mintToken(alice, {Substrate: bob.address}, [
       {key: 'k1', value: 'vvvvvv'.repeat(5000)},
       {key: 'k2', value: 'vvv'.repeat(5000)},
     ]);

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -183,7 +183,7 @@
       {},
       {},
     ];
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
@@ -198,7 +198,7 @@
       {value: 2n},
       {value: 3n},
     ];
-    const mintTx = async () => helper.ft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, args, {Substrate: alice.address});
+    const mintTx = () => helper.ft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, args, {Substrate: alice.address});
     await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
@@ -213,7 +213,7 @@
       {pieces: 1n},
       {pieces: 1n},
     ];
-    const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.rft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
   });
 
@@ -223,7 +223,7 @@
       {},
       {},
     ];
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(bob, collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
   });
 
@@ -241,7 +241,7 @@
       {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
       {properties: [{key: 'data', value: 'C'.repeat(32769)}]},
     ];
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
@@ -259,7 +259,7 @@
       {pieces: 10n, properties: [{key: 'data', value: 'B'.repeat(32769)}]},
       {pieces: 10n, properties: [{key: 'data', value: 'C'.repeat(32769)}]},
     ];
-    const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
@@ -291,7 +291,7 @@
       {properties: [{key: 'data', value: 'A'}]},
       {properties: [{key: 'data', value: 'B'.repeat(32769)}]},
     ];
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 
@@ -311,7 +311,7 @@
       {},
       {},
     ];
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
   });
 
@@ -327,7 +327,7 @@
     const args = [
       {properties: [{key: 'data', value: 'A'}]},
     ];
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
@@ -346,7 +346,7 @@
     const args = [
       {properties: [{key: 'data', value: 'A'}]},
     ];
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
   });
 
@@ -368,7 +368,7 @@
       {properties: prps},
     ];
 
-    const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
+    const mintTx = () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);
     await expect(mintTx()).to.be.rejectedWith('Verification Error');
   });
 });

--- a/tests/src/eth/base.test.ts
+++ b/tests/src/eth/base.test.ts
@@ -69,7 +69,7 @@
   });
 });
 
-describe('ERC165 tests', async () => {
+describe('ERC165 tests', () => {
   // https://eips.ethereum.org/EIPS/eip-165
 
   let erc721MetadataCompatibleNftCollectionId: number;

--- a/tests/src/eth/nesting/nest.test.ts
+++ b/tests/src/eth/nesting/nest.test.ts
@@ -81,7 +81,7 @@
     });
   });
 
-  describe('Negative Test: EVM Nesting', async() => {
+  describe('Negative Test: EVM Nesting', () => {
     itEth('NFT: disallows to nest token if nesting is disabled', async ({helper}) => {
       const owner = await helper.eth.createAccountWithBalance(donor);
 

--- a/tests/src/eth/util/index.ts
+++ b/tests/src/eth/util/index.ts
@@ -58,7 +58,7 @@
   }
 };
   
-export async function itEth(name: string, cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
+export function itEth(name: string, cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
   (opts.only ? it.only : 
     opts.skip ? it.skip : it)(name, async function() {
     await usingEthPlaygrounds(async (helper, privateKey) => {
@@ -71,7 +71,7 @@
   });
 }
 
-export async function itEthIfWithPallet(name: string, required: string[], cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
+export function itEthIfWithPallet(name: string, required: string[], cb: (apis: { helper: EthUniqueHelper, privateKey: (seed: string | {filename: string}) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
   return itEth(name, cb, {requiredPallets: required, ...opts});
 }