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

difftreelog

Remove asyncs without awaits

Max Andreev2022-10-25parent: #408e6a1.patch.diff
in: master

23 files changed

modifiedtests/src/addCollectionAdmin.test.tsdiffbeforeafterboth
--- a/tests/src/addCollectionAdmin.test.ts
+++ b/tests/src/addCollectionAdmin.test.ts
@@ -56,8 +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});
+    const changeAdminTxBob = () => helper.collection.addAdmin(bob, collectionId, {Substrate: bob.address});
+    const changeAdminTxCharlie = () => helper.collection.addAdmin(bob, collectionId, {Substrate: charlie.address});
     await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
     await expect(changeAdminTxBob()).to.be.rejectedWith(/common\.NoPermission/);
 
@@ -75,7 +75,7 @@
     const adminListAfterAddAdmin = await collection.getAdmins();
     expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: bob.address});
 
-    const changeAdminTxCharlie = async () => collection.addAdmin(bob, {Substrate: charlie.address});
+    const changeAdminTxCharlie = () => collection.addAdmin(bob, {Substrate: charlie.address});
     await expect(changeAdminTxCharlie()).to.be.rejectedWith(/common\.NoPermission/);
 
     const adminListAfterAddNewAdmin = await collection.getAdmins();
@@ -87,7 +87,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});
+    const addAdminTx = () => helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
     await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
 
     // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
@@ -99,7 +99,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});
+    const addAdminTx = () => collection.addAdmin(alice, {Substrate: bob.address});
     await expect(addAdminTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
 
     // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
@@ -119,7 +119,7 @@
       expect(adminListAfterAddAdmin).to.be.deep.contains({Substrate: accounts[i].address});
     }
 
-    const addExtraAdminTx = async () => collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address});
+    const addExtraAdminTx = () => collection.addAdmin(alice, {Substrate: accounts[chainAdminLimit].address});
     await expect(addExtraAdminTx()).to.be.rejectedWith(/common\.CollectionAdminCountExceeded/);
   });
 });
modifiedtests/src/adminTransferAndBurn.test.tsdiffbeforeafterboth
--- a/tests/src/adminTransferAndBurn.test.ts
+++ b/tests/src/adminTransferAndBurn.test.ts
@@ -36,7 +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});
+    const transferResult = () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
     await expect(transferResult()).to.be.rejected;
 
     await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
@@ -52,7 +52,7 @@
     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);
+    const burnTxFailed = () => helper.nft.burnToken(alice, collectionId, tokenId);
 
     await expect(burnTxFailed()).to.be.rejected;
modifiedtests/src/allowLists.test.tsdiffbeforeafterboth
--- 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);
modifiedtests/src/approve.test.tsdiffbeforeafterboth
--- 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;
   });
 });
modifiedtests/src/change-collection-owner.test.tsdiffbeforeafterboth
--- 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/);
   });
 });
modifiedtests/src/confirmSponsorship.test.tsdiffbeforeafterboth
119    await token.transfer(alice, {Substrate: zeroBalance.address});119    await token.transfer(alice, {Substrate: zeroBalance.address});
120    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);120    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
121121
122    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});122    const transferTx = () => token.transfer(zeroBalance, {Substrate: alice.address});
123    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');123    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
124    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);124    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
125125
137    await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);137    await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
138    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);138    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
139139
140    const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});140    const transferTx = () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
141    await expect(transferTx()).to.be.rejected;141    await expect(transferTx()).to.be.rejected;
142    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);142    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
143143
155    await token.transfer(zeroBalance, {Substrate: alice.address});155    await token.transfer(zeroBalance, {Substrate: alice.address});
156156
157    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);157    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
158    const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});158    const transferTx = () => token.transfer(zeroBalance, {Substrate: alice.address});
159    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');159    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
160    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);160    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
161161
175    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});175    await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
176176
177    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);177    const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
178    const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});178    const mintTx = () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
179    await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');179    await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
180    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);180    const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
181181
199199
200  itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {200  itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {
201    const collectionId = (1 << 32) - 1;201    const collectionId = (1 << 32) - 1;
202    const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);202    const confirmSponsorshipTx = () => helper.collection.confirmSponsorship(bob, collectionId);
203    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);203    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
204  });204  });
205205
206  itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {206  itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {
207    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});207    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
208    await collection.setSponsor(alice, bob.address);208    await collection.setSponsor(alice, bob.address);
209    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);209    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
210    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);210    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
211  });211  });
212212
213  itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {213  itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {
214    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});214    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
215    await collection.setSponsor(alice, bob.address);215    await collection.setSponsor(alice, bob.address);
216    const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);216    const confirmSponsorshipTx = () => collection.confirmSponsorship(alice);
217    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);217    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
218  });218  });
219219
220  itSub('(!negative test!) Confirm sponsorship by collection admin', async ({helper}) => {220  itSub('(!negative test!) Confirm sponsorship by collection admin', async ({helper}) => {
221    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});221    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
222    await collection.setSponsor(alice, bob.address);222    await collection.setSponsor(alice, bob.address);
223    await collection.addAdmin(alice, {Substrate: charlie.address});223    await collection.addAdmin(alice, {Substrate: charlie.address});
224    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);224    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
225    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);225    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
226  });226  });
227227
228  itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {228  itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {
229    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});229    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
230    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);230    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
231    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);231    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
232  });232  });
233233
234  itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {234  itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {
235    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});235    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
236    await collection.burn(alice);236    await collection.burn(alice);
237    const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);237    const confirmSponsorshipTx = () => collection.confirmSponsorship(charlie);
238    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);238    await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
239  });239  });
240240
244    await collection.confirmSponsorship(bob);244    await collection.confirmSponsorship(bob);
245    const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});245    const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
246    const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);246    const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
247    const transferTx = async () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});247    const transferTx = () =>  token.transfer(senderZeroBalance, {Substrate: alice.address});
248    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');248    await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
249    const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);249    const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
250    expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);250    expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
modifiedtests/src/createCollection.test.tsdiffbeforeafterboth
--- 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');
   });
 });
modifiedtests/src/createItem.test.tsdiffbeforeafterboth
--- 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)},
     ]);
modifiedtests/src/createMultipleItems.test.tsdiffbeforeafterboth
--- 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');
   });
 });
modifiedtests/src/eth/base.test.tsdiffbeforeafterboth
--- 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;
modifiedtests/src/eth/nesting/nest.test.tsdiffbeforeafterboth
--- 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);
modifiedtests/src/eth/util/index.tsdiffbeforeafterboth
--- 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});
 }
modifiedtests/src/eth/util/playgrounds/unique.dev.tsdiffbeforeafterboth
--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -367,7 +367,7 @@
     return this.web3;
   }
 
-  async connectWeb3(wsEndpoint: string) {
+  connectWeb3(wsEndpoint: string) {
     if(this.web3 !== null) return;
     this.web3Provider = new Web3.providers.WebsocketProvider(wsEndpoint);
     this.web3 = new Web3(this.web3Provider);
modifiedtests/src/pallet-presence.test.tsdiffbeforeafterboth
--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -83,15 +83,15 @@
     });
   });
 
-  itSub('Required pallets are present', async ({helper}) => {
+  itSub('Required pallets are present', ({helper}) => {
     expect(helper.fetchAllPalletNames()).to.contain.members([...requiredPallets]);
   });
 
-  itSub('Governance and consensus pallets are present', async ({helper}) => {
+  itSub('Governance and consensus pallets are present', ({helper}) => {
     expect(helper.fetchAllPalletNames()).to.contain.members([...consensusPallets]);
   });
 
-  itSub('No extra pallets are included', async ({helper}) => {
+  itSub('No extra pallets are included', ({helper}) => {
     expect(helper.fetchAllPalletNames().sort()).to.be.deep.equal([...requiredPallets, ...consensusPallets].sort());
   });
 });
modifiedtests/src/refungible.test.tsdiffbeforeafterboth
--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -19,7 +19,7 @@
 
 const MAX_REFUNGIBLE_PIECES = 1_000_000_000_000_000_000_000n;
 
-describe('integration test: Refungible functionality:', async () => {
+describe('integration test: Refungible functionality:', () => {
   let donor: IKeyringPair;
   let alice: IKeyringPair;
   let bob: IKeyringPair;
modifiedtests/src/rmrk/addResource.seqtest.tsdiffbeforeafterboth
--- a/tests/src/rmrk/addResource.seqtest.ts
+++ b/tests/src/rmrk/addResource.seqtest.ts
@@ -112,7 +112,7 @@
     const resourcesInfo = [];
     const resourceNum = 4;
 
-    const checkResource = async (resource: ResourceInfo, resType: string, expectedId: number, expected: {
+    const checkResource = (resource: ResourceInfo, resType: string, expectedId: number, expected: {
       src: string,
       metadata: string,
       license: string,
modifiedtests/src/rmrk/equipNft.seqtest.tsdiffbeforeafterboth
--- a/tests/src/rmrk/equipNft.seqtest.ts
+++ b/tests/src/rmrk/equipNft.seqtest.ts
@@ -30,7 +30,7 @@
 
 const slotId = 1;
 
-async function createTestCollection(api: ApiPromise): Promise<number> {
+function createTestCollection(api: ApiPromise): Promise<number> {
   return createCollection(
     api,
     alice,
@@ -60,7 +60,7 @@
   return nftChildId;
 }
 
-async function createTestBase(api: ApiPromise): Promise<number> {
+function createTestBase(api: ApiPromise): Promise<number> {
   return createBase(api, alice, 'test-base', 'DTBase', [
     {
       SlotPart: {
modifiedtests/src/rmrk/rmrkIsolation.seqtest.tsdiffbeforeafterboth
--- a/tests/src/rmrk/rmrkIsolation.seqtest.ts
+++ b/tests/src/rmrk/rmrkIsolation.seqtest.ts
@@ -58,7 +58,7 @@
   return rmrkNftId;
 }
 
-describe('RMRK External Integration Test', async () => {
+describe('RMRK External Integration Test', () => {
   before(async function() {
     await usingPlaygrounds(async (_helper, privateKey) => {
       alice = await privateKey('//Alice');
@@ -78,7 +78,7 @@
   });
 });
 
-describe('Negative Integration Test: External Collections, Internal Ops', async () => {
+describe('Negative Integration Test: External Collections, Internal Ops', () => {
   let uniqueCollectionId: number;
   let rmrkCollectionId: number;
   let rmrkNftId: number;
@@ -196,7 +196,7 @@
   });
 });
 
-describe('Negative Integration Test: Internal Collections, External Ops', async () => {
+describe('Negative Integration Test: Internal Collections, External Ops', () => {
   let collectionId: number;
   let nftId: number;
modifiedtests/src/rmrk/util/fetch.tsdiffbeforeafterboth
--- a/tests/src/rmrk/util/fetch.ts
+++ b/tests/src/rmrk/util/fetch.ts
@@ -20,7 +20,7 @@
   return (await api.rpc.rmrk.lastCollectionIdx()).toNumber();
 }
 
-export async function getCollection(api: ApiPromise, id: number): Promise<Option<Collection>> {
+export function getCollection(api: ApiPromise, id: number): Promise<Option<Collection>> {
   return api.rpc.rmrk.collectionById(id);
 }
 
@@ -36,7 +36,7 @@
     .map((value) => value.toNumber());
 }
 
-export async function getNft(api: ApiPromise, collectionId: number, nftId: number): Promise<Option<Nft>> {
+export function getNft(api: ApiPromise, collectionId: number, nftId: number): Promise<Option<Nft>> {
   return api.rpc.rmrk.nftById(collectionId, nftId);
 }
 
@@ -56,7 +56,7 @@
   return (await api.rpc.rmrk.nftChildren(collectionId, nftId)).toArray();
 }
 
-export async function getBase(api: ApiPromise, baseId: number): Promise<Option<Base>> {
+export function getBase(api: ApiPromise, baseId: number): Promise<Option<Base>> {
   return api.rpc.rmrk.base(baseId);
 }
 
@@ -112,7 +112,7 @@
     .map((name) => name.toUtf8());
 }
 
-export async function getTheme(
+export function getTheme(
   api: ApiPromise,
   baseId: number,
   themeName: string,
modifiedtests/src/tx-version-presence.test.tsdiffbeforeafterboth
--- a/tests/src/tx-version-presence.test.ts
+++ b/tests/src/tx-version-presence.test.ts
@@ -26,7 +26,7 @@
     });
   });
 
-  itSub('Signed extension CheckTxVersion is present', async () => {
+  itSub('Signed extension CheckTxVersion is present', () => {
     expect(metadata.asLatest.extrinsic.signedExtensions.map(se => se.identifier.toString())).to.include('CheckTxVersion');
   });
 });
modifiedtests/src/util/globalSetup.tsdiffbeforeafterboth
--- a/tests/src/util/globalSetup.ts
+++ b/tests/src/util/globalSetup.ts
@@ -90,7 +90,7 @@
   });
 };
 
-const fundFilenamesWithRetries = async (retriesLeft: number): Promise<boolean> => {
+const fundFilenamesWithRetries = (retriesLeft: number): Promise<boolean> => {
   if (retriesLeft <= 0) return Promise.resolve(false);
   return fundFilenames()
     .then(() => Promise.resolve(true))
modifiedtests/src/util/index.tsdiffbeforeafterboth
--- a/tests/src/util/index.ts
+++ b/tests/src/util/index.ts
@@ -59,27 +59,27 @@
   return usingPlaygroundsGeneral<DevUniqueHelper>(DevUniqueHelper, url, code);
 };
 
-export const usingWestmintPlaygrounds = async (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
+export const usingWestmintPlaygrounds = (url: string, code: (helper: DevWestmintHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
   return usingPlaygroundsGeneral<DevWestmintHelper>(DevWestmintHelper, url, code);
 };
 
-export const usingRelayPlaygrounds = async (url: string, code: (helper: DevRelayHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
+export const usingRelayPlaygrounds = (url: string, code: (helper: DevRelayHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
   return usingPlaygroundsGeneral<DevRelayHelper>(DevRelayHelper, url, code);
 };
 
-export const usingAcalaPlaygrounds = async (url: string, code: (helper: DevAcalaHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
+export const usingAcalaPlaygrounds = (url: string, code: (helper: DevAcalaHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
   return usingPlaygroundsGeneral<DevAcalaHelper>(DevAcalaHelper, url, code);
 };
 
-export const usingKaruraPlaygrounds = async (url: string, code: (helper: DevKaruraHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
+export const usingKaruraPlaygrounds = (url: string, code: (helper: DevKaruraHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
   return usingPlaygroundsGeneral<DevKaruraHelper>(DevAcalaHelper, url, code);
 };
 
-export const usingMoonbeamPlaygrounds = async (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
+export const usingMoonbeamPlaygrounds = (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
   return usingPlaygroundsGeneral<DevMoonbeamHelper>(DevMoonbeamHelper, url, code);
 };
 
-export const usingMoonriverPlaygrounds = async (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
+export const usingMoonriverPlaygrounds = (url: string, code: (helper: DevMoonbeamHelper, privateKey: (seed: string) => Promise<IKeyringPair>) => Promise<void>) => {
   return usingPlaygroundsGeneral<DevMoonriverHelper>(DevMoonriverHelper, url, code);
 };
 
@@ -107,7 +107,7 @@
   }
 }
 
-export async function itSub(name: string, cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
+export function itSub(name: string, cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
   (opts.only ? it.only : 
     opts.skip ? it.skip : it)(name, async function () {
     await usingPlaygrounds(async (helper, privateKey) => {
@@ -119,7 +119,7 @@
     });
   });
 }
-export async function itSubIfWithPallet(name: string, required: string[], cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
+export function itSubIfWithPallet(name: string, required: string[], cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any, opts: { only?: boolean, skip?: boolean, requiredPallets?: string[] } = {}) {
   return itSub(name, cb, {requiredPallets: required, ...opts});
 }
 itSub.only = (name: string, cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any) => itSub(name, cb, {only: true});
@@ -129,7 +129,7 @@
 itSubIfWithPallet.skip = (name: string, required: string[], cb: (apis: { helper: DevUniqueHelper, privateKey: (seed: string) => Promise<IKeyringPair> }) => any) => itSubIfWithPallet(name, required, cb, {skip: true});
 itSub.ifWithPallets = itSubIfWithPallet;
 
-export async function describeXCM(title: string, fn: (this: Mocha.Suite) => void, opts: {skip?: boolean} = {}) {
+export function describeXCM(title: string, fn: (this: Mocha.Suite) => void, opts: {skip?: boolean} = {}) {
   (process.env.RUN_XCM_TESTS && !opts.skip
     ? describe
     : describe.skip)(title, fn);
modifiedtests/src/util/playgrounds/unique.dev.tsdiffbeforeafterboth
--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -267,7 +267,7 @@
     }
     const block2 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber])]);
     const block1 = await this.helper.callRpc('api.rpc.chain.getBlock', [await this.helper.callRpc('api.rpc.chain.getBlockHash', [blockNumber - 1])]);
-    const findCreationDate = async (block: any) => {
+    const findCreationDate = (block: any) => {
       const humanBlock = block.toHuman();
       let date;
       humanBlock.block.extrinsics.forEach((ext: any) => {
@@ -349,7 +349,7 @@
    * @param blocksCount number of blocks to wait
    * @returns 
    */
-  async newBlocks(blocksCount = 1): Promise<void> {
+  newBlocks(blocksCount = 1): Promise<void> {
     // eslint-disable-next-line no-async-promise-executor
     const promise = new Promise<void>(async (resolve) => {
       const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(() => {
@@ -364,10 +364,10 @@
     return promise;
   }
 
-  async forParachainBlockNumber(blockNumber: bigint) {
+  forParachainBlockNumber(blockNumber: bigint) {
     // eslint-disable-next-line no-async-promise-executor
     return new Promise<void>(async (resolve) => {
-      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async (data: any) => {
+      const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads((data: any) => {
         if (data.number.toNumber() >= blockNumber) {
           unsubscribe();
           resolve();
@@ -376,10 +376,10 @@
     });
   }
   
-  async forRelayBlockNumber(blockNumber: bigint) {
+  forRelayBlockNumber(blockNumber: bigint) {
     // eslint-disable-next-line no-async-promise-executor
     return new Promise<void>(async (resolve) => {
-      const unsubscribe = await this.helper.getApi().query.parachainSystem.validationData(async (data: any) => {
+      const unsubscribe = await this.helper.getApi().query.parachainSystem.validationData((data: any) => {
         if (data.value.relayParentNumber.toNumber() >= blockNumber) {
           // @ts-ignore
           unsubscribe();
@@ -389,7 +389,7 @@
     });
   }
 
-  async event(maxBlocksToWait: number, eventSection: string, eventMethod: string) {
+  event(maxBlocksToWait: number, eventSection: string, eventMethod: string) {
     // eslint-disable-next-line no-async-promise-executor
     const promise = new Promise<EventRecord | null>(async (resolve) => {
       const unsubscribe = await this.helper.getApi().rpc.chain.subscribeNewHeads(async header => {