@cardano-sdk/e2e 0.24.0 → 0.26.0

package/test/providers/StakePoolProvider.test.ts

@@ -388,6 +388,7 @@ describe('StakePoolProvider', () => {
 
           filters = { identifier: { values: poolsId.map((id) => ({ id })) } };
         });
+
         it('ascending sort by live saturation', async () => {
           if (poolsId.length < 2)
             return console.log(
@@ -403,6 +404,7 @@ describe('StakePoolProvider', () => {
               .map((p) => p.metrics?.saturation)
           );
         });
+
         it('descending sort by live saturation', async () => {
           if (poolsId.length < 2)
             return console.log(
@@ -420,42 +422,45 @@ describe('StakePoolProvider', () => {
         });
       });
 
-      describe('sort by apy', () => {
+      describe.each(['lastRos', 'ros'] as const)('sort by %s', (field) => {
         let filters: QueryStakePoolsArgs['filters'] = {};
         const poolsId: Cardano.PoolId[] = [];
 
         beforeAll(() => {
-          for (const pool of pools) {
-            if (poolsId.length < 20 && pool.metrics?.apy !== undefined && pool.metrics?.apy > 0) {
+          for (const pool of pools)
+            if (poolsId.length < 20 && pool.metrics?.[field] !== undefined && pool.metrics?.[field] > 0)
               poolsId.push(pool.id);
-            }
-          }
+
           filters = { identifier: { values: poolsId.map((id) => ({ id })) } };
         });
-        it('ascending sort by apy', async () => {
+
+        it(`ascending sort by ${field}`, async () => {
           if (poolsId.length < 2)
-            return console.log("test 'ascending sort by apy' can't run because no suitable pools were found");
-          const { pageResults, totalResultCount } = await query(filters, { field: 'apy', order: 'asc' });
+            return console.log(`test 'ascending sort by ${field}' can't run because no suitable pools were found`);
+
+          const { pageResults, totalResultCount } = await query(filters, { field, order: 'asc' });
 
           expect(totalResultCount).toBe(poolsId.length);
-          expect(pageResults.map((p) => p.metrics?.apy)).toStrictEqual(
+          expect(pageResults.map((p) => p.metrics?.[field])).toStrictEqual(
             pools
               .filter(({ id }) => poolsId.includes(id))
-              .sort((a, b) => (a.metrics!.apy! < b.metrics!.apy! ? -1 : 1))
-              .map((p) => p.metrics?.apy)
+              .sort((a, b) => (a.metrics![field]! < b.metrics![field]! ? -1 : 1))
+              .map((p) => p.metrics![field])
           );
         });
-        it('descending sort by apy', async () => {
+
+        it(`descending sort by ${field}`, async () => {
           if (poolsId.length < 2)
-            return console.log("test 'descending sort by apy' can't run because no suitable pools were found");
-          const { pageResults, totalResultCount } = await query(filters, { field: 'apy', order: 'desc' });
+            return console.log(`test 'descending sort by ${field}' can't run because no suitable pools were found`);
+
+          const { pageResults, totalResultCount } = await query(filters, { field, order: 'desc' });
 
           expect(totalResultCount).toBe(poolsId.length);
-          expect(pageResults.map((p) => p.metrics?.apy)).toStrictEqual(
+          expect(pageResults.map((p) => p.metrics?.[field])).toStrictEqual(
             pools
               .filter(({ id }) => poolsId.includes(id))
-              .sort((a, b) => (a.metrics!.apy! > b.metrics!.apy! ? -1 : 1))
-              .map((p) => p.metrics?.apy)
+              .sort((a, b) => (a.metrics![field]! > b.metrics![field]! ? -1 : 1))
+              .map((p) => p.metrics![field])
           );
         });
       });

package/test/tsconfig.json

@@ -26,6 +26,9 @@
     {
       "path": "../../util-dev/src"
     },
+    {
+      "path": "../../util-rxjs/src"
+    },
     {
       "path": "../../wallet/src"
     },

package/test/wallet/PersonalWallet/delegation.test.ts

@@ -1,10 +1,12 @@
 /* eslint-disable max-statements */
+import * as Crypto from '@cardano-sdk/crypto';
 import { BigIntMath } from '@cardano-sdk/util';
 import { Cardano } from '@cardano-sdk/core';
 import { ObservableWallet, PersonalWallet } from '@cardano-sdk/wallet';
 import {
   TX_TIMEOUT_DEFAULT,
   TestWallet,
+  bip32Ed25519Factory,
   firstValueFromTimed,
   getEnv,
   getWallet,
@@ -27,6 +29,7 @@ const getWalletStateSnapshot = async (wallet: ObservableWallet) => {
   const utxoTotal = await firstValueFrom(wallet.utxo.total$);
   const utxoAvailable = await firstValueFrom(wallet.utxo.available$);
   const rewardsBalance = await firstValueFrom(wallet.balance.rewardAccounts.rewards$);
+
   return {
     balance: { available: balanceAvailable, deposit, total: balanceTotal },
     epoch: epoch.epochNo,
@@ -54,6 +57,7 @@ const waitForTx = async (wallet: ObservableWallet, hash: Cardano.TransactionId)
 describe('PersonalWallet/delegation', () => {
   let wallet1: TestWallet;
   let wallet2: TestWallet;
+  let bip32Ed25519: Crypto.Bip32Ed25519;
 
   beforeAll(async () => {
     jest.setTimeout(180_000);
@@ -61,6 +65,7 @@ describe('PersonalWallet/delegation', () => {
     wallet2 = await getWallet({ env, idx: 1, logger, name: 'Test Wallet 2', polling: { interval: 500 } });
 
     await Promise.all([waitForWalletStateSettle(wallet1.wallet), waitForWalletStateSettle(wallet2.wallet)]);
+    bip32Ed25519 = await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger);
   });
 
   afterAll(() => {
@@ -164,9 +169,7 @@ describe('PersonalWallet/delegation', () => {
       expect(tx1ConfirmedState.rewardAccount.delegatee?.currentEpoch?.id).toEqual(poolId);
     }
 
-    const stakeKeyHash = await (
-      await sourceWallet.keyAgent.getBip32Ed25519()
-    ).getPubKeyHash(tx1ConfirmedState.publicStakeKey.publicStakeKey);
+    const stakeKeyHash = await bip32Ed25519.getPubKeyHash(tx1ConfirmedState.publicStakeKey.publicStakeKey);
     expect(stakeKeyHash).toEqual(Cardano.RewardAccount.toHash(tx1ConfirmedState.rewardAccount.address));
     expect(tx1ConfirmedState.publicStakeKey.keyStatus).toBe(Cardano.StakeKeyStatus.Registered);
 

package/test/wallet/PersonalWallet/handle.test.ts

@@ -3,6 +3,7 @@ import { Cardano, metadatum } from '@cardano-sdk/core';
 import { KeyAgent, TransactionSigner } from '@cardano-sdk/key-management';
 import { PersonalWallet } from '@cardano-sdk/wallet';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   coinsRequiredByHandleMint,
   createHandleMetadata,
@@ -49,7 +50,7 @@ describe('Ada handle', () => {
     keyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       await firstValueFrom(wallet.genesisParameters$),
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
     ({ policyScript, policySigner, policyId } = await createHandlePolicy(keyAgent));
     const handleProviderPolicyId = await getHandlePolicyId(

package/test/wallet/PersonalWallet/mint.test.ts

@@ -3,6 +3,7 @@ import { FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, util } from '@cardano-sdk/key-management';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   createStandaloneKeyAgent,
   getEnv,
@@ -36,7 +37,7 @@ describe('PersonalWallet/mint', () => {
     const aliceKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
 
     const derivationPath = {

package/test/wallet/PersonalWallet/multiAddress.test.ts

@@ -3,6 +3,7 @@ import { AddressType, GroupedAddress, util } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
 import {
   KeyAgentFactoryProps,
+  bip32Ed25519Factory,
   createStandaloneKeyAgent,
   firstValueFromTimed,
   getWallet,
@@ -42,7 +43,7 @@ describe('PersonalWallet/multiAddress', () => {
     const multiAddressKeyAgent = await createStandaloneKeyAgent(
       mnemonics,
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
 
     let txBuilder = wallet.createTxBuilder();

package/test/wallet/PersonalWallet/multisignature.test.ts

@@ -4,6 +4,7 @@ import { FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, util } from '@cardano-sdk/key-management';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   createStandaloneKeyAgent,
   getEnv,
@@ -34,15 +35,16 @@ describe('PersonalWallet/multisignature', () => {
 
     const genesis = await firstValueFrom(wallet.genesisParameters$);
 
+    const bip32Ed25519 = await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger);
     const aliceKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      bip32Ed25519
     );
     const bobKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      bip32Ed25519
     );
 
     const aliceDerivationPath = {

package/test/wallet/PersonalWallet/nft.test.ts

@@ -4,6 +4,7 @@ import { Assets, FinalizeTxProps, PersonalWallet } from '@cardano-sdk/wallet';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
 import { KeyRole, TransactionSigner, util } from '@cardano-sdk/key-management';
 import {
+  bip32Ed25519Factory,
   burnTokens,
   createStandaloneKeyAgent,
   firstValueFromTimed,
@@ -60,7 +61,7 @@ describe('PersonalWallet.assets/nft', () => {
     const keyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      await wallet.keyAgent.getBip32Ed25519()
+      await bip32Ed25519Factory.create(env.KEY_MANAGEMENT_PARAMS.bip32Ed25519, null, logger)
     );
 
     const derivationPath = {

package/test/web-extension/extension/ui.ts

@@ -165,10 +165,7 @@ const deactivateWallet = async (): Promise<void> => {
   clearWalletValues();
 };
 
-/**
- * Wallet does not have any active delegations.
- * Show a `<p class="noDelegation">No delegation found</p>`
- */
+/** Wallet does not have any active delegations. Show a `<p class="noDelegation">No delegation found</p>` */
 const createEmptyDelegationEl = () => {
   const emptyDistribution = document.createElement('p');
   emptyDistribution.classList.add('noDelegation');
@@ -176,10 +173,7 @@ const createEmptyDelegationEl = () => {
   return emptyDistribution;
 };
 
-/**
- * Create a list item for a delegation
- * `<li> <span class="poolId">thePoolId</span> <span class="percent">50</span> </li>`
- */
+/** Create a list item for a delegation `<li> <span class="poolId">thePoolId</span> <span class="percent">50</span> </li>` */
 const createDelegationLi = (poolId: string, percent: string) => {
   const delegationLi = document.createElement('li');
   const poolIdSpan = document.createElement('span');

package/test/load-testing/tx-submit-load.test.ts

@@ -1,341 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Cardano } from '@cardano-sdk/core';
-import { ChildProcess, fork } from 'child_process';
-import { InitializeTxResult } from '@cardano-sdk/tx-construction';
-import { ObservableWallet } from '@cardano-sdk/wallet';
-import { RabbitMQContainer } from '../../../cardano-services/test/TxSubmit/rabbitmq/docker';
-import { ServiceNames } from '@cardano-sdk/cardano-services';
-import { createLogger } from '@cardano-sdk/util-dev';
-import { filter, firstValueFrom } from 'rxjs';
-import { getEnv, submitAndConfirm, walletVariables } from '../../src';
-import { getWallet } from '../../src/factories';
-import JSONBig from 'json-bigint';
-import path from 'path';
-
-// Verify environment.
-const env = getEnv([
-  ...walletVariables,
-  'OGMIOS_URL',
-  'START_LOCAL_HTTP_SERVER',
-  'TRANSACTIONS_NUMBER',
-  'TX_SUBMIT_HTTP_URL',
-  'WORKER_PARALLEL_TRANSACTION'
-]);
-
-interface TestOptions {
-  directlyToOgmios?: boolean;
-  parallel?: boolean;
-  withRunningWorker?: boolean;
-}
-
-interface TestReport extends TestOptions {
-  timeBeforeSubmitTxs: number;
-  timeAfterWorkerStarted: number;
-  timeAfterTxsInMempool: number;
-  timeAfterTxsInBlockchain: number;
-}
-
-interface TestWallet {
-  address: Cardano.PaymentAddress;
-  coins: bigint;
-  wallet: ObservableWallet;
-}
-
-const logger = createLogger({ env: process.env.TL_LEVEL ? process.env : { ...process.env, TL_LEVEL: 'info' } });
-
-let commonArgs: string[];
-
-const runCli = (args: string[], startedString: string) =>
-  new Promise<ChildProcess>((resolve, reject) => {
-    const proc = fork(path.join(__dirname, '..', '..', '..', 'cardano-services', 'dist', 'cjs', 'cli.js'), args, {
-      stdio: 'pipe'
-    });
-
-    const logChunk = (method: typeof logger.info, chunk: string) => {
-      for (const line of chunk.split('\n')) {
-        if (line) {
-          let msg = line;
-
-          try {
-            ({ msg } = JSON.parse(line));
-            // eslint-disable-next-line no-empty
-          } catch {}
-
-          if (!msg.includes('\u001B[')) method(`${args[0]}: ${msg}`);
-        }
-      }
-    };
-
-    proc.stderr!.once('data', (data) => reject(new Error(data.toString())));
-    proc.stderr!.on('data', (data) => logChunk(logger.error.bind(logger), data.toString()));
-    proc.stdout!.on('data', (data) => {
-      const chunk = data.toString();
-
-      logChunk(logger.info.bind(logger), chunk);
-      if (chunk.includes(startedString)) resolve(proc);
-    });
-    proc.once('error', reject);
-  });
-
-const stopProc = (proc: ChildProcess) =>
-  new Promise<void>((resolve) => (proc?.kill() ? proc.on('close', resolve) : resolve()));
-
-let rabbitmqUrl: URL;
-let serverProc: ChildProcess;
-let workerProc: ChildProcess;
-
-const startServer = async (options: TestOptions = {}) => {
-  if (env.START_LOCAL_HTTP_SERVER)
-    serverProc = await runCli(
-      [
-        'start-provider-server',
-        '--api-url',
-        env.TX_SUBMIT_HTTP_URL,
-        ...(options.directlyToOgmios ? [] : ['--use-queue', 'true']),
-        ...commonArgs,
-        ServiceNames.TxSubmit
-      ],
-      '[HttpServer] Started'
-    );
-};
-
-const startWorker = async (options: TestOptions = {}) => {
-  workerProc = await runCli(
-    [
-      'start-worker',
-      ...commonArgs,
-      ...(options.parallel ? ['--parallel', 'true', '--parallel-txs', env.WORKER_PARALLEL_TRANSACTION.toString()] : [])
-    ],
-    '"msg":"TxSubmitWorker: starting'
-  );
-};
-
-const stopServer = () => stopProc(serverProc);
-const stopWorker = () => stopProc(workerProc);
-
-const grace = (time: number) => `${time.toString().padStart(5, ' ')}ms`;
-
-const waitForTxInBlockchain = async (wallet: ObservableWallet, txId: Cardano.TransactionId) => {
-  logger.info(`Waiting for tx ${txId} in blockchain...`);
-  await firstValueFrom(
-    wallet.transactions.history$.pipe(filter((txs) => txs.filter((tx) => tx.id === txId).length === 1))
-  );
-  logger.info(`Tx ${txId} in blockchain`);
-};
-
-describe('load', () => {
-  const container = new RabbitMQContainer('rabbitmq-load-test');
-  const testReports: TestReport[] = [];
-  const testWallets: TestWallet[] = [];
-
-  const prepareWallet = async (idx: number) => {
-    const walletEnv = getEnv(walletVariables, {
-      override: { TX_SUBMIT_PROVIDER_PARAMS: JSON.stringify({ baseUrl: env.TX_SUBMIT_HTTP_URL }) }
-    });
-    const { wallet } = await getWallet({ env: walletEnv, idx, logger, name: `Test Wallet ${idx}` });
-    const { address } = (await firstValueFrom(wallet.addresses$))[0];
-    logger.info(`Got wallet idx: ${idx} - address: ${address}`);
-
-    logger.debug(`Waiting to settle wallet ${idx} status`);
-    await firstValueFrom(wallet.syncStatus.isSettled$.pipe(filter((isSettled) => isSettled)));
-    logger.debug(`Wallet ${idx} status settled`);
-
-    testWallets.push({ address, coins: 0n, wallet });
-  };
-
-  const prepareWallets = async () => {
-    const promises: Promise<void>[] = [];
-
-    logger.info('Preparing wallets...');
-
-    for (let i = 0; i < env.TRANSACTIONS_NUMBER; ++i) promises.push(prepareWallet(i));
-
-    await Promise.all(promises);
-
-    logger.info('Wallets prepared');
-  };
-
-  const refreshWallets = async () => {
-    for (const testWallet of testWallets)
-      testWallet.coins = (await firstValueFrom(testWallet.wallet.balance.utxo.available$)).coins;
-
-    // Sort wallets from the one with the highest coins to the one with the lower
-    testWallets.sort((a, b) => Number(b.coins - a.coins));
-  };
-
-  const fragmentWhenRequired = async (options: TestOptions) => {
-    await refreshWallets();
-
-    const toRefill: Cardano.PaymentAddress[] = [];
-    const { wallet } = testWallets[0];
-
-    for (let i = 0; i < env.TRANSACTIONS_NUMBER; ++i)
-      if (testWallets[i].coins < 2_000_000n) toRefill.push(testWallets[i].address);
-
-    if (toRefill.length === 0) {
-      logger.info('Fragmentation tx not required');
-
-      return;
-    }
-
-    const coins = testWallets[0].coins / BigInt(toRefill.length + 1);
-
-    if (coins < 2_000_000n) throw new Error('Not enough coins to perform the test');
-
-    const fragment = async () => {
-      const tx = await wallet.initializeTx({
-        outputs: new Set(toRefill.map((address) => ({ address, value: { coins } })))
-      });
-
-      logger.info(`Fragmentation tx: ${tx.hash}`);
-      await submitAndConfirm(wallet, await wallet.finalizeTx({ tx }));
-      logger.info('Fragmentation completed');
-    };
-
-    if (options.directlyToOgmios) await fragment();
-    else {
-      await Promise.all([startWorker(), fragment()]);
-      await stopWorker();
-    }
-  };
-
-  beforeAll(async () => {
-    jest.setTimeout(180_000);
-
-    ({ rabbitmqUrl } = await container.start());
-
-    commonArgs = [
-      '--logger-min-severity',
-      'debug',
-      '--ogmios-url',
-      env.OGMIOS_URL,
-      '--rabbitmq-url',
-      rabbitmqUrl.toString()
-    ];
-
-    await startServer({ directlyToOgmios: true });
-    await prepareWallets();
-  });
-
-  afterAll(async () => {
-    logger.info('    Test result');
-
-    for (const report of testReports) {
-      const {
-        directlyToOgmios,
-        parallel,
-        withRunningWorker,
-        timeAfterTxsInBlockchain,
-        timeAfterTxsInMempool,
-        timeAfterWorkerStarted,
-        timeBeforeSubmitTxs
-      } = report;
-
-      const timeReport =
-        directlyToOgmios || withRunningWorker
-          ? `submission   -> mempool: ${grace(timeAfterTxsInMempool - timeBeforeSubmitTxs)}`
-          : `start worker -> mempool: ${grace(timeAfterTxsInMempool - timeAfterWorkerStarted)}`;
-
-      const workerDescription = `with${withRunningWorker ? '   ' : 'out'} running ${
-        parallel ? 'parallel' : 'serial  '
-      } worker`;
-
-      logger.info(
-        `  ${
-          directlyToOgmios ? 'directly to ogmios             ' : workerDescription
-        } - ${timeReport} - mempool -> blockchain: ${grace(
-          timeAfterTxsInBlockchain - timeAfterTxsInMempool
-        )} - total: ${grace(timeAfterTxsInBlockchain - timeBeforeSubmitTxs)}`
-      );
-    }
-
-    for (const { wallet } of testWallets) wallet.shutdown();
-
-    // Dependencies teardown parallelization
-    await Promise.all([container.stop(), stopServer()]);
-  });
-
-  afterEach(stopWorker);
-
-  const performTest = async (options: TestOptions) => {
-    const { directlyToOgmios, parallel, withRunningWorker } = options;
-    const submitPromises: Promise<void>[] = [];
-    const txIds: Cardano.TransactionId[] = [];
-    let timeAfterWorkerStarted = 0;
-    let timeBeforeSubmitTxs = 0;
-
-    logger.info(`Starting test with options: ${JSON.stringify({ directlyToOgmios, parallel, withRunningWorker })}`);
-
-    await fragmentWhenRequired(options);
-
-    const startWorkerForTest = async () => {
-      if (!directlyToOgmios) await startWorker(options);
-      timeAfterWorkerStarted = Date.now();
-    };
-
-    const finalizeAndSubmit = async (wallet: ObservableWallet, tx: InitializeTxResult) => {
-      try {
-        await wallet.submitTx(await wallet.finalizeTx({ tx }));
-        logger.info(`Submitted tx: ${tx.hash}`);
-      } catch (error) {
-        logger.error(JSONBig.stringify(tx), error);
-        throw error;
-      }
-    };
-
-    const submitTransactions = async () => {
-      timeBeforeSubmitTxs = Date.now();
-
-      for (let i = 0; i < env.TRANSACTIONS_NUMBER; ++i) {
-        const { address, wallet } = testWallets[i];
-        const coins = 1_000_000n + BigInt(i);
-        const tx = await wallet.initializeTx({ outputs: new Set([{ address, value: { coins } }]) });
-        logger.info(`Initializing tx idx ${i}: ${tx.hash}`);
-
-        submitPromises.push(finalizeAndSubmit(wallet, tx));
-        txIds.push(tx.hash);
-      }
-    };
-
-    if (withRunningWorker) {
-      await startWorkerForTest();
-      await submitTransactions();
-    } else {
-      await submitTransactions();
-      await startWorkerForTest();
-    }
-
-    await expect(Promise.all(submitPromises)).resolves.not.toThrow();
-    const timeAfterTxsInMempool = Date.now();
-
-    await Promise.all(txIds.map((txId, i) => waitForTxInBlockchain(testWallets[i].wallet, txId)));
-
-    testReports.push({
-      ...options,
-      timeAfterTxsInBlockchain: Date.now(),
-      timeAfterTxsInMempool,
-      timeAfterWorkerStarted,
-      timeBeforeSubmitTxs
-    });
-
-    logger.info(`Completed test with options: ${JSON.stringify({ directlyToOgmios, parallel, withRunningWorker })}`);
-  };
-
-  describe('directly to ogmios', () => {
-    afterAll(stopServer);
-
-    it('without queue', async () => {
-      if (env.TRANSACTIONS_NUMBER < 30) await performTest({ directlyToOgmios: true });
-      else logger.info('Skipping directly to ogmios test due to transaction number > 30');
-    });
-  });
-
-  describe('using queue', () => {
-    beforeAll(() => startServer({}));
-
-    it('without running serial worker', async () => await performTest({}));
-    it('with running serial worker', async () => await performTest({ withRunningWorker: true }));
-    it('without running parallel worker', async () => await performTest({ parallel: true }));
-    it('with running parallel worker', async () => await performTest({ parallel: true, withRunningWorker: true }));
-  });
-});