git.delta.rocks / unique-network / refs/commits / 5ea65b7821a4

--- a/tests/src/xcm/xcmQuartz.test.ts
+++ b/tests/src/xcm/xcmQuartz.test.ts
@@ -14,23 +14,16 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-
-import {WsProvider, Keyring} from '@polkadot/api';
-import {ApiOptions} from '@polkadot/api/types';
+import {Keyring} from '@polkadot/api';
 import {IKeyringPair} from '@polkadot/types/types';
-import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';
-import {getGenericResult, generateKeyringPair, waitEvent, describe_xcm, bigIntToDecimals} from '../deprecated-helpers/helpers';
+import {submitTransactionAsync} from '../substrate/substrate-api';
+import {getGenericResult, generateKeyringPair, waitEvent, bigIntToDecimals} from '../deprecated-helpers/helpers';
 import {MultiLocation} from '@polkadot/types/interfaces';
 import {blake2AsHex} from '@polkadot/util-crypto';
-import waitNewBlocks from '../substrate/wait-new-blocks';
 import getBalance from '../substrate/get-balance';
 import {XcmV2TraitsOutcome, XcmV2TraitsError} from '../interfaces';
+import {itSub, expect, describeXcm, usingPlaygrounds} from '../util/playgrounds';
 
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
 const QUARTZ_CHAIN = 2095;
 const KARURA_CHAIN = 2000;
 const MOONRIVER_CHAIN = 2023;
@@ -39,29 +32,15 @@
 const KARURA_PORT = 9946;
 const MOONRIVER_PORT = 9947;
 
+const relayUrl = 'ws://127.0.0.1:' + RELAY_PORT;
+const karuraUrl = 'ws://127.0.0.1:' + KARURA_PORT;
+const moonriverUrl = 'ws://127.0.0.1:' + MOONRIVER_PORT;
+
 const KARURA_DECIMALS = 12;
 
 const TRANSFER_AMOUNT = 2000000000000000000000000n;
 
-function parachainApiOptions(port: number): ApiOptions {
-  return {
-    provider: new WsProvider('ws://127.0.0.1:' + port.toString()),
-  };
-}
-
-function karuraOptions(): ApiOptions {
-  return parachainApiOptions(KARURA_PORT);
-}
-
-function moonriverOptions(): ApiOptions {
-  return parachainApiOptions(MOONRIVER_PORT);
-}
-
-function relayOptions(): ApiOptions {
-  return parachainApiOptions(RELAY_PORT);
-}
-
-describe_xcm('[XCM] Integration test: Exchanging tokens with Karura', () => {
+describeXcm('[XCM] Integration test: Exchanging tokens with Karura', () => {
   let alice: IKeyringPair;
   let randomAccount: IKeyringPair;
 
@@ -76,233 +55,234 @@
   let balanceQuartzForeignTokenFinal: bigint;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
       const keyringSr25519 = new Keyring({type: 'sr25519'});
 
-      alice = privateKeyWrapper('//Alice');
+      alice = privateKey('//Alice');
       randomAccount = generateKeyringPair(keyringSr25519);
     });
 
     // Karura side
-    await usingApi(
-      async (api) => {
-        const destination = {
-          V0: {
-            X2: [
-              'Parent',
-              {
-                Parachain: QUARTZ_CHAIN,
-              },
-            ],
-          },
-        };
+    await usingPlaygrounds.atUrl(karuraUrl, async (helper) => {
+      const api = helper.getApi();
+
+      const destination = {
+        V0: {
+          X2: [
+            'Parent',
+            {
+              Parachain: QUARTZ_CHAIN,
+            },
+          ],
+        },
+      };
 
-        const metadata = {
-          name: 'QTZ',
-          symbol: 'QTZ',
-          decimals: 18,
-          minimalBalance: 1,
-        };
+      const metadata = {
+        name: 'QTZ',
+        symbol: 'QTZ',
+        decimals: 18,
+        minimalBalance: 1,
+      };
 
-        const tx = api.tx.assetRegistry.registerForeignAsset(destination, metadata);
-        const sudoTx = api.tx.sudo.sudo(tx as any);
-        const events = await submitTransactionAsync(alice, sudoTx);
-        const result = getGenericResult(events);
-        expect(result.success).to.be.true;
+      const tx = api.tx.assetRegistry.registerForeignAsset(destination, metadata);
+      const sudoTx = api.tx.sudo.sudo(tx as any);
+      const events = await submitTransactionAsync(alice, sudoTx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
 
-        const tx1 = api.tx.balances.transfer(randomAccount.address, 10000000000000n);
-        const events1 = await submitTransactionAsync(alice, tx1);
-        const result1 = getGenericResult(events1);
-        expect(result1.success).to.be.true;
+      const tx1 = api.tx.balances.transfer(randomAccount.address, 10000000000000n);
+      const events1 = await submitTransactionAsync(alice, tx1);
+      const result1 = getGenericResult(events1);
+      expect(result1.success).to.be.true;
 
-        [balanceKaruraTokenInit] = await getBalance(api, [randomAccount.address]);
-        {
-          const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
-          balanceQuartzForeignTokenInit = BigInt(free);
-        }
-      },
-      karuraOptions(),
-    );
+      [balanceKaruraTokenInit] = await getBalance(api, [randomAccount.address]);
+      {
+        const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+        balanceQuartzForeignTokenInit = BigInt(free);
+      }
+    });
 
     // Quartz side
-    await usingApi(async (api) => {
-      const tx0 = api.tx.balances.transfer(randomAccount.address, 10n * TRANSFER_AMOUNT);
-      const events0 = await submitTransactionAsync(alice, tx0);
-      const result0 = getGenericResult(events0);
-      expect(result0.success).to.be.true;
+    await usingPlaygrounds(async (helper) => {
+      // const tx0 = api.tx.balances.transfer(randomAccount.address, 10n * TRANSFER_AMOUNT);
+      // const events0 = await submitTransactionAsync(alice, tx0);
+      // const result0 = getGenericResult(events0);
+      // expect(result0.success).to.be.true;
+      await helper.balance.transferToSubstrate(alice, randomAccount.address, 10n * TRANSFER_AMOUNT);
 
-      [balanceQuartzTokenInit] = await getBalance(api, [randomAccount.address]);
+      // [balanceQuartzTokenInit] = await getBalance(api, [randomAccount.address]);
+      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccount.address);
     });
   });
 
-  it('Should connect and send QTZ to Karura', async () => {
+  itSub('Should connect and send QTZ to Karura', async ({helper}) => {
 
     // Quartz side
-    await usingApi(async (api) => {
+    const destination = {
+      V0: {
+        X2: [
+          'Parent',
+          {
+            Parachain: KARURA_CHAIN,
+          },
+        ],
+      },
+    };
 
-      const destination = {
-        V0: {
-          X2: [
-            'Parent',
-            {
-              Parachain: KARURA_CHAIN,
-            },
-          ],
+    const beneficiary = {
+      V0: {
+        X1: {
+          AccountId32: {
+            network: 'Any',
+            id: randomAccount.addressRaw,
+          },
         },
-      };
+      },
+    };
 
-      const beneficiary = {
-        V0: {
-          X1: {
-            AccountId32: {
-              network: 'Any',
-              id: randomAccount.addressRaw,
+    const assets = {
+      V1: [
+        {
+          id: {
+            Concrete: {
+              parents: 0,
+              interior: 'Here',
             },
           },
+          fun: {
+            Fungible: TRANSFER_AMOUNT,
+          },
         },
-      };
+      ],
+    };
 
-      const assets = {
-        V1: [
-          {
-            id: {
-              Concrete: {
-                parents: 0,
-                interior: 'Here',
-              },
-            },
-            fun: {
-              Fungible: TRANSFER_AMOUNT,
-            },
-          },
-        ],
-      };
+    const feeAssetItem = 0;
 
-      const feeAssetItem = 0;
-
-      const weightLimit = {
-        Limited: 5000000000,
-      };
+    const weightLimit = {
+      Limited: 5000000000,
+    };
 
-      const tx = api.tx.polkadotXcm.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit);
-      const events = await submitTransactionAsync(randomAccount, tx);
-      const result = getGenericResult(events);
-      expect(result.success).to.be.true;
+    // TODO
+    const tx = helper.getApi().tx.polkadotXcm.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit);
+    const events = await submitTransactionAsync(randomAccount, tx);
+    const result = getGenericResult(events);
+    expect(result.success).to.be.true;
 
-      [balanceQuartzTokenMiddle] = await getBalance(api, [randomAccount.address]);
+    // [balanceQuartzTokenMiddle] = await getBalance(api, [randomAccount.address]);
+    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);
 
-      const qtzFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;
-      console.log('[Quartz -> Karura] transaction fees on Quartz: %s QTZ', bigIntToDecimals(qtzFees));
-      expect(qtzFees > 0n).to.be.true;
-    });
+    const qtzFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;
+    console.log('[Quartz -> Karura] transaction fees on Quartz: %s QTZ', bigIntToDecimals(qtzFees));
+    expect(qtzFees > 0n).to.be.true;
 
     // Karura side
-    await usingApi(
-      async (api) => {
-        await waitNewBlocks(api, 3);
-        const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
-        balanceQuartzForeignTokenMiddle = BigInt(free);
+    await usingPlaygrounds.atUrl(karuraUrl, async (helper) => {
+      // await waitNewBlocks(api, 3);
+      await helper.wait.newBlocks(3);
+
+      // TODO
+      const {free} = (await helper.getApi().query.tokens.accounts(randomAccount.addressRaw, {ForeignAsset: 0})).toJSON() as any;
+      balanceQuartzForeignTokenMiddle = BigInt(free);
 
-        [balanceKaruraTokenMiddle] = await getBalance(api, [randomAccount.address]);
+      // [balanceKaruraTokenMiddle] = await getBalance(api, [randomAccount.address]);
+      balanceKaruraTokenMiddle = await helper.balance.getSubstrate(randomAccount.address);
 
-        const karFees = balanceKaruraTokenInit - balanceKaruraTokenMiddle;
-        const qtzIncomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenInit;
+      const karFees = balanceKaruraTokenInit - balanceKaruraTokenMiddle;
+      const qtzIncomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenInit;
 
-        console.log(
-          '[Quartz -> Karura] transaction fees on Karura: %s KAR',
-          bigIntToDecimals(karFees, KARURA_DECIMALS),
-        );
-        console.log('[Quartz -> Karura] income %s QTZ', bigIntToDecimals(qtzIncomeTransfer));
-        expect(karFees == 0n).to.be.true;
-        expect(qtzIncomeTransfer == TRANSFER_AMOUNT).to.be.true;
-      },
-      karuraOptions(),
-    );
+      console.log(
+        '[Quartz -> Karura] transaction fees on Karura: %s KAR',
+        bigIntToDecimals(karFees, KARURA_DECIMALS),
+      );
+      console.log('[Quartz -> Karura] income %s QTZ', bigIntToDecimals(qtzIncomeTransfer));
+      expect(karFees == 0n).to.be.true;
+      expect(qtzIncomeTransfer == TRANSFER_AMOUNT).to.be.true;
+    });
   });
 
-  it('Should connect to Karura and send QTZ back', async () => {
+  itSub('Should connect to Karura and send QTZ back', async ({helper}) => {
 
     // Karura side
-    await usingApi(
-      async (api) => {
-        const destination = {
-          V1: {
-            parents: 1,
-            interior: {
-              X2: [
-                {Parachain: QUARTZ_CHAIN},
-                {
-                  AccountId32: {
-                    network: 'Any',
-                    id: randomAccount.addressRaw,
-                  },
+    await usingPlaygrounds.atUrl(karuraUrl, async (helper) => {
+      const destination = {
+        V1: {
+          parents: 1,
+          interior: {
+            X2: [
+              {Parachain: QUARTZ_CHAIN},
+              {
+                AccountId32: {
+                  network: 'Any',
+                  id: randomAccount.addressRaw,
                 },
-              ],
-            },
+              },
+            ],
           },
-        };
+        },
+      };
 
-        const id = {
-          ForeignAsset: 0,
-        };
+      const id = {
+        ForeignAsset: 0,
+      };
 
-        const destWeight = 50000000;
+      const destWeight = 50000000;
 
-        const tx = api.tx.xTokens.transfer(id as any, TRANSFER_AMOUNT, destination, destWeight);
-        const events = await submitTransactionAsync(randomAccount, tx);
-        const result = getGenericResult(events);
-        expect(result.success).to.be.true;
+      // TODO
+      const tx = helper.getApi().tx.xTokens.transfer(id as any, TRANSFER_AMOUNT, destination, destWeight);
+      const events = await submitTransactionAsync(randomAccount, tx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
 
-        [balanceKaruraTokenFinal] = await getBalance(api, [randomAccount.address]);
-        {
-          const {free} = (await api.query.tokens.accounts(randomAccount.addressRaw, id)).toJSON() as any;
-          balanceQuartzForeignTokenFinal = BigInt(free);
-        }
+      // [balanceKaruraTokenFinal] = await getBalance(api, [randomAccount.address]);
+      balanceKaruraTokenFinal = await helper.balance.getSubstrate(randomAccount.address);
+      {
+        // TODO
+        const {free} = (await helper.getApi().query.tokens.accounts(randomAccount.addressRaw, id)).toJSON() as any;
+        balanceQuartzForeignTokenFinal = BigInt(free);
+      }
 
-        const karFees = balanceKaruraTokenMiddle - balanceKaruraTokenFinal;
-        const qtzOutcomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenFinal;
+      const karFees = balanceKaruraTokenMiddle - balanceKaruraTokenFinal;
+      const qtzOutcomeTransfer = balanceQuartzForeignTokenMiddle - balanceQuartzForeignTokenFinal;
 
-        console.log(
-          '[Karura -> Quartz] transaction fees on Karura: %s KAR',
-          bigIntToDecimals(karFees, KARURA_DECIMALS),
-        );
-        console.log('[Karura -> Quartz] outcome %s QTZ', bigIntToDecimals(qtzOutcomeTransfer));
+      console.log(
+        '[Karura -> Quartz] transaction fees on Karura: %s KAR',
+        bigIntToDecimals(karFees, KARURA_DECIMALS),
+      );
+      console.log('[Karura -> Quartz] outcome %s QTZ', bigIntToDecimals(qtzOutcomeTransfer));
 
-        expect(karFees > 0).to.be.true;
-        expect(qtzOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;
-      },
-      karuraOptions(),
-    );
+      expect(karFees > 0).to.be.true;
+      expect(qtzOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;
+    });
 
     // Quartz side
-    await usingApi(async (api) => {
-      await waitNewBlocks(api, 3);
+    // await waitNewBlocks(api, 3);
+    await helper.wait.newBlocks(3);
 
-      [balanceQuartzTokenFinal] = await getBalance(api, [randomAccount.address]);
-      const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;
-      expect(actuallyDelivered > 0).to.be.true;
+    // [balanceQuartzTokenFinal] = await getBalance(api, [randomAccount.address]);
+    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccount.address);
+    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;
+    expect(actuallyDelivered > 0).to.be.true;
 
-      console.log('[Karura -> Quartz] actually delivered %s QTZ', bigIntToDecimals(actuallyDelivered));
+    console.log('[Karura -> Quartz] actually delivered %s QTZ', bigIntToDecimals(actuallyDelivered));
 
-      const qtzFees = TRANSFER_AMOUNT - actuallyDelivered;
-      console.log('[Karura -> Quartz] transaction fees on Quartz: %s QTZ', bigIntToDecimals(qtzFees));
-      expect(qtzFees == 0n).to.be.true;
-    });
+    const qtzFees = TRANSFER_AMOUNT - actuallyDelivered;
+    console.log('[Karura -> Quartz] transaction fees on Quartz: %s QTZ', bigIntToDecimals(qtzFees));
+    expect(qtzFees == 0n).to.be.true;
   });
 });
 
 // These tests are relevant only when the foreign asset pallet is disabled
-describe_xcm('[XCM] Integration test: Quartz rejects non-native tokens', () => {
+describeXcm('[XCM] Integration test: Quartz rejects non-native tokens', () => {
   let alice: IKeyringPair;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
-      alice = privateKeyWrapper('//Alice');
+    await usingPlaygrounds(async (_helper, privateKey) => {
+      alice = privateKey('//Alice');
     });
   });
 
-  it('Quartz rejects tokens from the Relay', async () => {
-    await usingApi(async (api) => {
+  itSub('Quartz rejects tokens from the Relay', async ({helper}) => {
+    await usingPlaygrounds.atUrl(relayUrl, async (helper) => {
       const destination = {
         V1: {
           parents: 0,
@@ -346,44 +326,45 @@
         Limited: 5_000_000_000,
       };
 
-      const tx = api.tx.xcmPallet.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit);
+      // TODO
+      const tx = helper.getApi().tx.xcmPallet.limitedReserveTransferAssets(destination, beneficiary, assets, feeAssetItem, weightLimit);
       const events = await submitTransactionAsync(alice, tx);
       const result = getGenericResult(events);
       expect(result.success).to.be.true;
-    }, relayOptions());
+    });
 
-    await usingApi(async api => {
-      const maxWaitBlocks = 3;
-      const dmpQueueExecutedDownward = await waitEvent(
-        api,
-        maxWaitBlocks,
-        'dmpQueue',
-        'ExecutedDownward',
-      );
+    const maxWaitBlocks = 3;
 
-      expect(
-        dmpQueueExecutedDownward != null,
-        '[Relay] dmpQueue.ExecutedDownward event is expected',
-      ).to.be.true;
+    // TODO
+    const dmpQueueExecutedDownward = await waitEvent(
+      helper.getApi(),
+      maxWaitBlocks,
+      'dmpQueue',
+      'ExecutedDownward',
+    );
 
-      const event = dmpQueueExecutedDownward!.event;
-      const outcome = event.data[1] as XcmV2TraitsOutcome;
+    expect(
+      dmpQueueExecutedDownward != null,
+      '[Relay] dmpQueue.ExecutedDownward event is expected',
+    ).to.be.true;
 
-      expect(
-        outcome.isIncomplete,
-        '[Relay] The outcome of the XCM should be `Incomplete`',
-      ).to.be.true;
+    const event = dmpQueueExecutedDownward!.event;
+    const outcome = event.data[1] as XcmV2TraitsOutcome;
+
+    expect(
+      outcome.isIncomplete,
+      '[Relay] The outcome of the XCM should be `Incomplete`',
+    ).to.be.true;
 
-      const incomplete = outcome.asIncomplete;
-      expect(
-        incomplete[1].toString() == 'AssetNotFound',
-        '[Relay] The XCM error should be `AssetNotFound`',
-      ).to.be.true;
-    });
+    const incomplete = outcome.asIncomplete;
+    expect(
+      incomplete[1].toString() == 'AssetNotFound',
+      '[Relay] The XCM error should be `AssetNotFound`',
+    ).to.be.true;
   });
 
-  it('Quartz rejects KAR tokens from Karura', async () => {
-    await usingApi(async (api) => {
+  itSub('Quartz rejects KAR tokens from Karura', async ({helper}) => {
+    await usingPlaygrounds.atUrl(karuraUrl, async (helper) => {
       const destination = {
         V1: {
           parents: 1,
@@ -407,33 +388,34 @@
 
       const destWeight = 50000000;
 
-      const tx = api.tx.xTokens.transfer(id as any, 100_000_000_000, destination, destWeight);
+      // TODO
+      const tx = helper.getApi().tx.xTokens.transfer(id as any, 100_000_000_000, destination, destWeight);
       const events = await submitTransactionAsync(alice, tx);
       const result = getGenericResult(events);
       expect(result.success).to.be.true;
-    }, karuraOptions());
+    });
 
-    await usingApi(async api => {
-      const maxWaitBlocks = 3;
-      const xcmpQueueFailEvent = await waitEvent(api, maxWaitBlocks, 'xcmpQueue', 'Fail');
+    const maxWaitBlocks = 3;
 
-      expect(
-        xcmpQueueFailEvent != null,
-        '[Karura] xcmpQueue.FailEvent event is expected',
-      ).to.be.true;
+    // TODO
+    const xcmpQueueFailEvent = await waitEvent(helper.getApi(), maxWaitBlocks, 'xcmpQueue', 'Fail');
 
-      const event = xcmpQueueFailEvent!.event;
-      const outcome = event.data[1] as XcmV2TraitsError;
+    expect(
+      xcmpQueueFailEvent != null,
+      '[Karura] xcmpQueue.FailEvent event is expected',
+    ).to.be.true;
 
-      expect(
-        outcome.isUntrustedReserveLocation,
-        '[Karura] The XCM error should be `UntrustedReserveLocation`',
-      ).to.be.true;
-    });
+    const event = xcmpQueueFailEvent!.event;
+    const outcome = event.data[1] as XcmV2TraitsError;
+
+    expect(
+      outcome.isUntrustedReserveLocation,
+      '[Karura] The XCM error should be `UntrustedReserveLocation`',
+    ).to.be.true;
   });
 });
 
-describe_xcm('[XCM] Integration test: Exchanging QTZ with Moonriver', () => {
+describeXcm('[XCM] Integration test: Exchanging QTZ with Moonriver', () => {
 
   // Quartz constants
   let quartzAlice: IKeyringPair;
@@ -478,322 +460,327 @@
   let balanceMovrTokenFinal: bigint;
 
   before(async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
+    await usingPlaygrounds(async (_helper, privateKey) => {
       const keyringEth = new Keyring({type: 'ethereum'});
       const keyringSr25519 = new Keyring({type: 'sr25519'});
 
-      quartzAlice = privateKeyWrapper('//Alice');
+      quartzAlice = privateKey('//Alice');
       randomAccountQuartz = generateKeyringPair(keyringSr25519);
       randomAccountMoonriver = generateKeyringPair(keyringEth);
 
       balanceForeignQtzTokenInit = 0n;
     });
 
-    await usingApi(
-      async (api) => {
+    await usingPlaygrounds.atUrl(moonriverUrl, async (helper) => {
+      // TODO
 
-        // >>> Sponsoring Dorothy >>>
-        console.log('Sponsoring Dorothy.......');
-        const tx0 = api.tx.balances.transfer(dorothyAccount.address, 11_000_000_000_000_000_000n);
-        const events0 = await submitTransactionAsync(alithAccount, tx0);
-        const result0 = getGenericResult(events0);
-        expect(result0.success).to.be.true;
-        console.log('Sponsoring Dorothy.......DONE');
-        // <<< Sponsoring Dorothy <<<
+      const api = helper.getApi();
 
-        const sourceLocation: MultiLocation = api.createType(
-          'MultiLocation',
-          {
-            parents: 1,
-            interior: {X1: {Parachain: QUARTZ_CHAIN}},
-          },
-        );
+      // >>> Sponsoring Dorothy >>>
+      console.log('Sponsoring Dorothy.......');
+      // const tx0 = api.tx.balances.transfer(dorothyAccount.address, 11_000_000_000_000_000_000n);
+      // const events0 = await submitTransactionAsync(alithAccount, tx0);
+      // const result0 = getGenericResult(events0);
+      // expect(result0.success).to.be.true;
+      await helper.balance.transferToSubstrate(alithAccount, dorothyAccount.address, 11_000_000_000_000_000_000n);
+      console.log('Sponsoring Dorothy.......DONE');
+      // <<< Sponsoring Dorothy <<<
 
-        quartzAssetLocation = {XCM: sourceLocation};
-        const existentialDeposit = 1;
-        const isSufficient = true;
-        const unitsPerSecond = '1';
-        const numAssetsWeightHint = 0;
+      const sourceLocation: MultiLocation = api.createType(
+        'MultiLocation',
+        {
+          parents: 1,
+          interior: {X1: {Parachain: QUARTZ_CHAIN}},
+        },
+      );
 
-        const registerTx = api.tx.assetManager.registerForeignAsset(
-          quartzAssetLocation,
-          quartzAssetMetadata,
-          existentialDeposit,
-          isSufficient,
-        );
-        console.log('Encoded proposal for registerAsset is %s', registerTx.method.toHex() || '');
+      quartzAssetLocation = {XCM: sourceLocation};
+      const existentialDeposit = 1;
+      const isSufficient = true;
+      const unitsPerSecond = '1';
+      const numAssetsWeightHint = 0;
 
-        const setUnitsTx = api.tx.assetManager.setAssetUnitsPerSecond(
-          quartzAssetLocation,
-          unitsPerSecond,
-          numAssetsWeightHint,
-        );
-        console.log('Encoded proposal for setAssetUnitsPerSecond is %s', setUnitsTx.method.toHex() || '');
+      const registerTx = api.tx.assetManager.registerForeignAsset(
+        quartzAssetLocation,
+        quartzAssetMetadata,
+        existentialDeposit,
+        isSufficient,
+      );
+      console.log('Encoded proposal for registerAsset is %s', registerTx.method.toHex() || '');
 
-        const batchCall = api.tx.utility.batchAll([registerTx, setUnitsTx]);
-        console.log('Encoded proposal for batchCall is %s', batchCall.method.toHex() || '');
+      const setUnitsTx = api.tx.assetManager.setAssetUnitsPerSecond(
+        quartzAssetLocation,
+        unitsPerSecond,
+        numAssetsWeightHint,
+      );
+      console.log('Encoded proposal for setAssetUnitsPerSecond is %s', setUnitsTx.method.toHex() || '');
 
-        // >>> Note motion preimage >>>
-        console.log('Note motion preimage.......');
-        const encodedProposal = batchCall?.method.toHex() || '';
-        const proposalHash = blake2AsHex(encodedProposal);
-        console.log('Encoded proposal for batch utility after schedule is %s', encodedProposal);
-        console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);
-        console.log('Encoded length %d', encodedProposal.length);
+      const batchCall = api.tx.utility.batchAll([registerTx, setUnitsTx]);
+      console.log('Encoded proposal for batchCall is %s', batchCall.method.toHex() || '');
 
-        const tx1 = api.tx.democracy.notePreimage(encodedProposal);
-        const events1 = await submitTransactionAsync(baltatharAccount, tx1);
-        const result1 = getGenericResult(events1);
-        expect(result1.success).to.be.true;
-        console.log('Note motion preimage.......DONE');
-        // <<< Note motion preimage <<<
+      // >>> Note motion preimage >>>
+      console.log('Note motion preimage.......');
+      const encodedProposal = batchCall?.method.toHex() || '';
+      const proposalHash = blake2AsHex(encodedProposal);
+      console.log('Encoded proposal for batch utility after schedule is %s', encodedProposal);
+      console.log('Encoded proposal hash for batch utility after schedule is %s', proposalHash);
+      console.log('Encoded length %d', encodedProposal.length);
 
-        // >>> Propose external motion through council >>>
-        console.log('Propose external motion through council.......');
-        const externalMotion = api.tx.democracy.externalProposeMajority(proposalHash);
-        const tx2 = api.tx.councilCollective.propose(
-          councilVotingThreshold,
-          externalMotion,
-          externalMotion.encodedLength,
-        );
-        const events2 = await submitTransactionAsync(baltatharAccount, tx2);
-        const result2 = getGenericResult(events2);
-        expect(result2.success).to.be.true;
+      const tx1 = api.tx.democracy.notePreimage(encodedProposal);
+      const events1 = await submitTransactionAsync(baltatharAccount, tx1);
+      const result1 = getGenericResult(events1);
+      expect(result1.success).to.be.true;
+      console.log('Note motion preimage.......DONE');
+      // <<< Note motion preimage <<<
 
-        const encodedMotion = externalMotion?.method.toHex() || '';
-        const motionHash = blake2AsHex(encodedMotion);
-        console.log('Motion hash is %s', motionHash);
+      // >>> Propose external motion through council >>>
+      console.log('Propose external motion through council.......');
+      const externalMotion = api.tx.democracy.externalProposeMajority(proposalHash);
+      const tx2 = api.tx.councilCollective.propose(
+        councilVotingThreshold,
+        externalMotion,
+        externalMotion.encodedLength,
+      );
+      const events2 = await submitTransactionAsync(baltatharAccount, tx2);
+      const result2 = getGenericResult(events2);
+      expect(result2.success).to.be.true;
 
-        const tx3 = api.tx.councilCollective.vote(motionHash, 0, true);
-        {
-          const events3 = await submitTransactionAsync(dorothyAccount, tx3);
-          const result3 = getGenericResult(events3);
-          expect(result3.success).to.be.true;
-        }
-        {
-          const events3 = await submitTransactionAsync(baltatharAccount, tx3);
-          const result3 = getGenericResult(events3);
-          expect(result3.success).to.be.true;
-        }
+      const encodedMotion = externalMotion?.method.toHex() || '';
+      const motionHash = blake2AsHex(encodedMotion);
+      console.log('Motion hash is %s', motionHash);
 
-        const tx4 = api.tx.councilCollective.close(motionHash, 0, 1_000_000_000, externalMotion.encodedLength);
-        const events4 = await submitTransactionAsync(dorothyAccount, tx4);
-        const result4 = getGenericResult(events4);
-        expect(result4.success).to.be.true;
-        console.log('Propose external motion through council.......DONE');
-        // <<< Propose external motion through council <<<
+      const tx3 = api.tx.councilCollective.vote(motionHash, 0, true);
+      {
+        const events3 = await submitTransactionAsync(dorothyAccount, tx3);
+        const result3 = getGenericResult(events3);
+        expect(result3.success).to.be.true;
+      }
+      {
+        const events3 = await submitTransactionAsync(baltatharAccount, tx3);
+        const result3 = getGenericResult(events3);
+        expect(result3.success).to.be.true;
+      }
 
-        // >>> Fast track proposal through technical committee >>>
-        console.log('Fast track proposal through technical committee.......');
-        const fastTrack = api.tx.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);
-        const tx5 = api.tx.techCommitteeCollective.propose(
-          technicalCommitteeThreshold,
-          fastTrack,
-          fastTrack.encodedLength,
-        );
-        const events5 = await submitTransactionAsync(alithAccount, tx5);
-        const result5 = getGenericResult(events5);
-        expect(result5.success).to.be.true;
+      const tx4 = api.tx.councilCollective.close(motionHash, 0, 1_000_000_000, externalMotion.encodedLength);
+      const events4 = await submitTransactionAsync(dorothyAccount, tx4);
+      const result4 = getGenericResult(events4);
+      expect(result4.success).to.be.true;
+      console.log('Propose external motion through council.......DONE');
+      // <<< Propose external motion through council <<<
 
-        const encodedFastTrack = fastTrack?.method.toHex() || '';
-        const fastTrackHash = blake2AsHex(encodedFastTrack);
-        console.log('FastTrack hash is %s', fastTrackHash);
+      // >>> Fast track proposal through technical committee >>>
+      console.log('Fast track proposal through technical committee.......');
+      const fastTrack = api.tx.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod);
+      const tx5 = api.tx.techCommitteeCollective.propose(
+        technicalCommitteeThreshold,
+        fastTrack,
+        fastTrack.encodedLength,
+      );
+      const events5 = await submitTransactionAsync(alithAccount, tx5);
+      const result5 = getGenericResult(events5);
+      expect(result5.success).to.be.true;
 
-        const proposalIdx = Number(await api.query.techCommitteeCollective.proposalCount()) - 1;
-        const tx6 = api.tx.techCommitteeCollective.vote(fastTrackHash, proposalIdx, true);
-        {
-          const events6 = await submitTransactionAsync(baltatharAccount, tx6);
-          const result6 = getGenericResult(events6);
-          expect(result6.success).to.be.true;
-        }
-        {
-          const events6 = await submitTransactionAsync(alithAccount, tx6);
-          const result6 = getGenericResult(events6);
-          expect(result6.success).to.be.true;
-        }
+      const encodedFastTrack = fastTrack?.method.toHex() || '';
+      const fastTrackHash = blake2AsHex(encodedFastTrack);
+      console.log('FastTrack hash is %s', fastTrackHash);
 
-        const tx7 = api.tx.techCommitteeCollective
-          .close(fastTrackHash, proposalIdx, 1_000_000_000, fastTrack.encodedLength);
-        const events7 = await submitTransactionAsync(baltatharAccount, tx7);
-        const result7 = getGenericResult(events7);
-        expect(result7.success).to.be.true;
-        console.log('Fast track proposal through technical committee.......DONE');
-        // <<< Fast track proposal through technical committee <<<
+      const proposalIdx = Number(await api.query.techCommitteeCollective.proposalCount()) - 1;
+      const tx6 = api.tx.techCommitteeCollective.vote(fastTrackHash, proposalIdx, true);
+      {
+        const events6 = await submitTransactionAsync(baltatharAccount, tx6);
+        const result6 = getGenericResult(events6);
+        expect(result6.success).to.be.true;
+      }
+      {
+        const events6 = await submitTransactionAsync(alithAccount, tx6);
+        const result6 = getGenericResult(events6);
+        expect(result6.success).to.be.true;
+      }
 
-        // >>> Referendum voting >>>
-        console.log('Referendum voting.......');
-        const tx8 = api.tx.democracy.vote(
-          0,
-          {Standard: {balance: 10_000_000_000_000_000_000n, vote: {aye: true, conviction: 1}}},
-        );
-        const events8 = await submitTransactionAsync(dorothyAccount, tx8);
-        const result8 = getGenericResult(events8);
-        expect(result8.success).to.be.true;
-        console.log('Referendum voting.......DONE');
-        // <<< Referendum voting <<<
+      const tx7 = api.tx.techCommitteeCollective
+        .close(fastTrackHash, proposalIdx, 1_000_000_000, fastTrack.encodedLength);
+      const events7 = await submitTransactionAsync(baltatharAccount, tx7);
+      const result7 = getGenericResult(events7);
+      expect(result7.success).to.be.true;
+      console.log('Fast track proposal through technical committee.......DONE');
+      // <<< Fast track proposal through technical committee <<<
 
-        // >>> Acquire Quartz AssetId Info on Moonriver >>>
-        console.log('Acquire Quartz AssetId Info on Moonriver.......');
+      // >>> Referendum voting >>>
+      console.log('Referendum voting.......');
+      const tx8 = api.tx.democracy.vote(
+        0,
+        {Standard: {balance: 10_000_000_000_000_000_000n, vote: {aye: true, conviction: 1}}},
+      );
+      const events8 = await submitTransactionAsync(dorothyAccount, tx8);
+      const result8 = getGenericResult(events8);
+      expect(result8.success).to.be.true;
+      console.log('Referendum voting.......DONE');
+      // <<< Referendum voting <<<
 
-        // Wait for the democracy execute
-        await waitNewBlocks(api, 5);
+      // >>> Acquire Quartz AssetId Info on Moonriver >>>
+      console.log('Acquire Quartz AssetId Info on Moonriver.......');
 
-        assetId = (await api.query.assetManager.assetTypeId({
-          XCM: sourceLocation,
-        })).toString();
+      // Wait for the democracy execute
+      // await waitNewBlocks(api, 5);
+      await helper.wait.newBlocks(5);
 
-        console.log('QTZ asset ID is %s', assetId);
-        console.log('Acquire Quartz AssetId Info on Moonriver.......DONE');
-        // >>> Acquire Quartz AssetId Info on Moonriver >>>
+      assetId = (await api.query.assetManager.assetTypeId({
+        XCM: sourceLocation,
+      })).toString();
 
-        // >>> Sponsoring random Account >>>
-        console.log('Sponsoring random Account.......');
-        const tx10 = api.tx.balances.transfer(randomAccountMoonriver.address, 11_000_000_000_000_000_000n);
-        const events10 = await submitTransactionAsync(baltatharAccount, tx10);
-        const result10 = getGenericResult(events10);
-        expect(result10.success).to.be.true;
-        console.log('Sponsoring random Account.......DONE');
-        // <<< Sponsoring random Account <<<
+      console.log('QTZ asset ID is %s', assetId);
+      console.log('Acquire Quartz AssetId Info on Moonriver.......DONE');
+      // >>> Acquire Quartz AssetId Info on Moonriver >>>
 
-        [balanceMovrTokenInit] = await getBalance(api, [randomAccountMoonriver.address]);
-      },
-      moonriverOptions(),
-    );
+      // >>> Sponsoring random Account >>>
+      console.log('Sponsoring random Account.......');
+      // const tx10 = api.tx.balances.transfer(randomAccountMoonriver.address, 11_000_000_000_000_000_000n);
+      // const events10 = await submitTransactionAsync(baltatharAccount, tx10);
+      // const result10 = getGenericResult(events10);
+      // expect(result10.success).to.be.true;
+      await helper.balance.transferToSubstrate(baltatharAccount, randomAccountMoonriver.address, 11_000_000_000_000_000_000n);
+      console.log('Sponsoring random Account.......DONE');
+      // <<< Sponsoring random Account <<<
 
-    await usingApi(async (api) => {
-      const tx0 = api.tx.balances.transfer(randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);
-      const events0 = await submitTransactionAsync(quartzAlice, tx0);
-      const result0 = getGenericResult(events0);
-      expect(result0.success).to.be.true;
+      // [balanceMovrTokenInit] = await getBalance(api, [randomAccountMoonriver.address]);
+      balanceMovrTokenInit = await helper.balance.getSubstrate(randomAccountMoonriver.address);
+    });
 
-      [balanceQuartzTokenInit] = await getBalance(api, [randomAccountQuartz.address]);
+    await usingPlaygrounds(async (helper) => {
+      // const tx0 = api.tx.balances.transfer(randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);
+      // const events0 = await submitTransactionAsync(quartzAlice, tx0);
+      // const result0 = getGenericResult(events0);
+      // expect(result0.success).to.be.true;
+      await helper.balance.transferToSubstrate(quartzAlice, randomAccountQuartz.address, 10n * TRANSFER_AMOUNT);
+
+      // [balanceQuartzTokenInit] = await getBalance(api, [randomAccountQuartz.address]);
+      balanceQuartzTokenInit = await helper.balance.getSubstrate(randomAccountQuartz.address);
     });
   });
 
-  it('Should connect and send QTZ to Moonriver', async () => {
-    await usingApi(async (api) => {
-      const currencyId = {
-        NativeAssetId: 'Here',
-      };
-      const dest = {
-        V1: {
-          parents: 1,
-          interior: {
-            X2: [
-              {Parachain: MOONRIVER_CHAIN},
-              {AccountKey20: {network: 'Any', key: randomAccountMoonriver.address}},
-            ],
-          },
+  itSub('Should connect and send QTZ to Moonriver', async ({helper}) => {
+    const currencyId = {
+      NativeAssetId: 'Here',
+    };
+    const dest = {
+      V1: {
+        parents: 1,
+        interior: {
+          X2: [
+            {Parachain: MOONRIVER_CHAIN},
+            {AccountKey20: {network: 'Any', key: randomAccountMoonriver.address}},
+          ],
         },
-      };
-      const amount = TRANSFER_AMOUNT;
-      const destWeight = 850000000;
+      },
+    };
+    const amount = TRANSFER_AMOUNT;
+    const destWeight = 850000000;
 
-      const tx = api.tx.xTokens.transfer(currencyId, amount, dest, destWeight);
-      const events = await submitTransactionAsync(randomAccountQuartz, tx);
-      const result = getGenericResult(events);
-      expect(result.success).to.be.true;
+    // TODO
+    const tx = helper.getApi().tx.xTokens.transfer(currencyId, amount, dest, destWeight);
+    const events = await submitTransactionAsync(randomAccountQuartz, tx);
+    const result = getGenericResult(events);
+    expect(result.success).to.be.true;
 
-      [balanceQuartzTokenMiddle] = await getBalance(api, [randomAccountQuartz.address]);
-      expect(balanceQuartzTokenMiddle < balanceQuartzTokenInit).to.be.true;
+    // [balanceQuartzTokenMiddle] = await getBalance(api, [randomAccountQuartz.address]);
+    balanceQuartzTokenMiddle = await helper.balance.getSubstrate(randomAccountQuartz.address);
+    expect(balanceQuartzTokenMiddle < balanceQuartzTokenInit).to.be.true;
 
-      const transactionFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;
-      console.log('[Quartz -> Moonriver] transaction fees on Quartz: %s QTZ', bigIntToDecimals(transactionFees));
-      expect(transactionFees > 0).to.be.true;
-    });
+    const transactionFees = balanceQuartzTokenInit - balanceQuartzTokenMiddle - TRANSFER_AMOUNT;
+    console.log('[Quartz -> Moonriver] transaction fees on Quartz: %s QTZ', bigIntToDecimals(transactionFees));
+    expect(transactionFees > 0).to.be.true;
 
-    await usingApi(
-      async (api) => {
-        await waitNewBlocks(api, 3);
+    await usingPlaygrounds.atUrl(moonriverUrl, async (helper) => {
+      // await waitNewBlocks(api, 3);
+      await helper.wait.newBlocks(3);
 
-        [balanceMovrTokenMiddle] = await getBalance(api, [randomAccountMoonriver.address]);
+      // [balanceMovrTokenMiddle] = await getBalance(api, [randomAccountMoonriver.address]);
+      balanceMovrTokenMiddle = await helper.balance.getSubstrate(randomAccountMoonriver.address);
 
-        const movrFees = balanceMovrTokenInit - balanceMovrTokenMiddle;
-        console.log('[Quartz -> Moonriver] transaction fees on Moonriver: %s MOVR',bigIntToDecimals(movrFees));
-        expect(movrFees == 0n).to.be.true;
+      const movrFees = balanceMovrTokenInit - balanceMovrTokenMiddle;
+      console.log('[Quartz -> Moonriver] transaction fees on Moonriver: %s MOVR',bigIntToDecimals(movrFees));
+      expect(movrFees == 0n).to.be.true;
 
-        const qtzRandomAccountAsset = (
-          await api.query.assets.account(assetId, randomAccountMoonriver.address)
-        ).toJSON()! as any;
+      // TODO
+      const qtzRandomAccountAsset = (
+        await helper.getApi().query.assets.account(assetId, randomAccountMoonriver.address)
+      ).toJSON()! as any;
 
-        balanceForeignQtzTokenMiddle = BigInt(qtzRandomAccountAsset['balance']);
-        const qtzIncomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenInit;
-        console.log('[Quartz -> Moonriver] income %s QTZ', bigIntToDecimals(qtzIncomeTransfer));
-        expect(qtzIncomeTransfer == TRANSFER_AMOUNT).to.be.true;
-      },
-      moonriverOptions(),
-    );
+      balanceForeignQtzTokenMiddle = BigInt(qtzRandomAccountAsset['balance']);
+      const qtzIncomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenInit;
+      console.log('[Quartz -> Moonriver] income %s QTZ', bigIntToDecimals(qtzIncomeTransfer));
+      expect(qtzIncomeTransfer == TRANSFER_AMOUNT).to.be.true;
+    });
   });
 
-  it('Should connect to Moonriver and send QTZ back', async () => {
-    await usingApi(
-      async (api) => {
-        const asset = {
-          V1: {
-            id: {
-              Concrete: {
-                parents: 1,
-                interior: {
-                  X1: {Parachain: QUARTZ_CHAIN},
-                },
+  itSub('Should connect to Moonriver and send QTZ back', async ({helper}) => {
+    await usingPlaygrounds.atUrl(moonriverUrl, async (helper) => {
+      const asset = {
+        V1: {
+          id: {
+            Concrete: {
+              parents: 1,
+              interior: {
+                X1: {Parachain: QUARTZ_CHAIN},
               },
             },
-            fun: {
-              Fungible: TRANSFER_AMOUNT,
-            },
           },
-        };
-        const destination = {
-          V1: {
-            parents: 1,
-            interior: {
-              X2: [
-                {Parachain: QUARTZ_CHAIN},
-                {AccountId32: {network: 'Any', id: randomAccountQuartz.addressRaw}},
-              ],
-            },
+          fun: {
+            Fungible: TRANSFER_AMOUNT,
+          },
+        },
+      };
+      const destination = {
+        V1: {
+          parents: 1,
+          interior: {
+            X2: [
+              {Parachain: QUARTZ_CHAIN},
+              {AccountId32: {network: 'Any', id: randomAccountQuartz.addressRaw}},
+            ],
           },
-        };
-        const destWeight = 50000000;
+        },
+      };
+      const destWeight = 50000000;
 
-        const tx = api.tx.xTokens.transferMultiasset(asset, destination, destWeight);
-        const events = await submitTransactionAsync(randomAccountMoonriver, tx);
-        const result = getGenericResult(events);
-        expect(result.success).to.be.true;
+      // TODO
+      const tx = helper.getApi().tx.xTokens.transferMultiasset(asset, destination, destWeight);
+      const events = await submitTransactionAsync(randomAccountMoonriver, tx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
 
-        [balanceMovrTokenFinal] = await getBalance(api, [randomAccountMoonriver.address]);
+      // [balanceMovrTokenFinal] = await getBalance(api, [randomAccountMoonriver.address]);
+      balanceMovrTokenFinal = await helper.balance.getSubstrate(randomAccountMoonriver.address);
 
-        const movrFees = balanceMovrTokenMiddle - balanceMovrTokenFinal;
-        console.log('[Moonriver -> Quartz] transaction fees on Moonriver: %s MOVR', bigIntToDecimals(movrFees));
-        expect(movrFees > 0).to.be.true;
+      const movrFees = balanceMovrTokenMiddle - balanceMovrTokenFinal;
+      console.log('[Moonriver -> Quartz] transaction fees on Moonriver: %s MOVR', bigIntToDecimals(movrFees));
+      expect(movrFees > 0).to.be.true;
 
-        const qtzRandomAccountAsset = (
-          await api.query.assets.account(assetId, randomAccountMoonriver.address)
-        ).toJSON()! as any;
+      const qtzRandomAccountAsset = (
+        await helper.getApi().query.assets.account(assetId, randomAccountMoonriver.address)
+      ).toJSON()! as any;
 
-        expect(qtzRandomAccountAsset).to.be.null;
+      expect(qtzRandomAccountAsset).to.be.null;
 
-        balanceForeignQtzTokenFinal = 0n;
+      balanceForeignQtzTokenFinal = 0n;
 
-        const qtzOutcomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenFinal;
-        console.log('[Quartz -> Moonriver] outcome %s QTZ', bigIntToDecimals(qtzOutcomeTransfer));
-        expect(qtzOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;
-      },
-      moonriverOptions(),
-    );
+      const qtzOutcomeTransfer = balanceForeignQtzTokenMiddle - balanceForeignQtzTokenFinal;
+      console.log('[Quartz -> Moonriver] outcome %s QTZ', bigIntToDecimals(qtzOutcomeTransfer));
+      expect(qtzOutcomeTransfer == TRANSFER_AMOUNT).to.be.true;
+    });
 
-    await usingApi(async (api) => {
-      await waitNewBlocks(api, 3);
+    // await waitNewBlocks(api, 3);
+    await helper.wait.newBlocks(3);
 
-      [balanceQuartzTokenFinal] = await getBalance(api, [randomAccountQuartz.address]);
-      const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;
-      expect(actuallyDelivered > 0).to.be.true;
+    // [balanceQuartzTokenFinal] = await getBalance(api, [randomAccountQuartz.address]);
+    balanceQuartzTokenFinal = await helper.balance.getSubstrate(randomAccountQuartz.address);
+    const actuallyDelivered = balanceQuartzTokenFinal - balanceQuartzTokenMiddle;
+    expect(actuallyDelivered > 0).to.be.true;
 
-      console.log('[Moonriver -> Quartz] actually delivered %s QTZ', bigIntToDecimals(actuallyDelivered));
+    console.log('[Moonriver -> Quartz] actually delivered %s QTZ', bigIntToDecimals(actuallyDelivered));
 
-      const qtzFees = TRANSFER_AMOUNT - actuallyDelivered;
-      console.log('[Moonriver -> Quartz] transaction fees on Quartz: %s QTZ', bigIntToDecimals(qtzFees));
-      expect(qtzFees == 0n).to.be.true;
-    });
+    const qtzFees = TRANSFER_AMOUNT - actuallyDelivered;
+    console.log('[Moonriver -> Quartz] transaction fees on Quartz: %s QTZ', bigIntToDecimals(qtzFees));
+    expect(qtzFees == 0n).to.be.true;
   });
 });