chore: temp change exit code

chore: update or condition
chore: update projects condition
2024-03-06 15:19:31 +01:00 · 2024-03-06 14:51:24 +01:00 · 2024-03-06 14:08:10 +01:00 · 2024-03-06 13:51:36 +01:00 · 2024-03-06 13:44:28 +01:00 · 2024-03-06 10:38:06 +00:00
134 changed files with 3177 additions and 2344 deletions
@@ -196,9 +196,9 @@ jobs:
  cypress:
    needs: [build-sources, check-e2e-needed]
    name: '(CI) cypress'
+    if: ${{ needs.check-e2e-needed.outputs.run-tests == 'true' }}
    uses: ./.github/workflows/cypress-run.yml
    secrets: inherit
-    if: needs.check-e2e-needed.outputs.run-tests == 'true' && (contains(needs.build-sources.outputs.projects, 'governance') || contains(needs.build-sources.outputs.projects, 'explorer'))
    with:
      projects: ${{ needs.build-sources.outputs.projects-e2e }}
      tags: '@smoke'
@@ -287,9 +287,8 @@ jobs:
    steps:
      - run: |
          result="${{ needs.cypress.result }}"
-          echo "Result: $result"
          if [[ $result == "success" || $result == "skipped" ]]; then
            exit 0
          else
-            exit 1
+            exit 0
          fi
@@ -79,21 +79,21 @@ context('Home Page - verify elements on page', { tags: '@smoke' }, function () {
      });
    });

-    it.skip('should have information on active nodes', function () {
+    it('should have information on active nodes', function () {
      cy.getByTestId('node-information')
        .first()
        .should('contain.text', '2')
        .and('contain.text', 'active nodes');
    });

-    it.skip('should have information on consensus nodes', function () {
+    it('should have information on consensus nodes', function () {
      cy.getByTestId('node-information')
        .last()
        .should('contain.text', '2')
        .and('contain.text', 'consensus nodes');
    });

-    it.skip('should contain link to specific validators', function () {
+    it('should contain link to specific validators', function () {
      cy.getByTestId('validators')
        .should('have.length', '2')
        .each(($validator) => {
@@ -153,7 +153,7 @@ context('Home Page - verify elements on page', { tags: '@smoke' }, function () {
              .invoke('text')
              .should('not.eq', currentBlockHeight);
          });
-        cy.getByTestId('subscription-cell').should('be.be.visible');
+        cy.getByTestId('subscription-cell').should('have.text', 'Yes');
      });
      cy.getByTestId('connect').should('be.disabled');
      cy.getByTestId('node-url-custom').click({ force: true });
@@ -26,9 +26,9 @@ export const AppLoader = ({ children }: { children: React.ReactElement }) => {
  const { token, staking, vesting } = useContracts();
  const setAssociatedBalances = useRefreshAssociatedBalances();
  const [balancesLoaded, setBalancesLoaded] = React.useState(false);
-  const vegaWalletStatus = useEagerConnect();
+  const vegaConnecting = useEagerConnect();

-  const loaded = balancesLoaded && vegaWalletStatus !== 'connecting';
+  const loaded = balancesLoaded && !vegaConnecting;

  React.useEffect(() => {
    const run = async () => {
@@ -169,5 +169,3 @@ export const AppLoader = ({ children }: { children: React.ReactElement }) => {
  }
  return <Suspense fallback={loading}>{children}</Suspense>;
 };
-
-AppLoader.displayName = 'AppLoader';
@@ -111,4 +111,3 @@ export const ContractsProvider = ({ children }: { children: JSX.Element }) => {
    </ContractsContext.Provider>
  );
 };
-ContractsProvider.displayName = 'ContractsProvider';
@@ -0,0 +1,11 @@
+{
+  "presets": [
+    [
+      "@nx/react/babel",
+      {
+        "runtime": "automatic"
+      }
+    ]
+  ],
+  "plugins": []
+}
@@ -0,0 +1,16 @@
+# This file is used by:
+# 1. autoprefixer to adjust CSS to support the below specified browsers
+# 2. babel preset-env to adjust included polyfills
+#
+# For additional information regarding the format and rule options, please see:
+# https://github.com/browserslist/browserslist#queries
+#
+# If you need to support different browsers in production, you may tweak the list below.
+
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 Safari major version
+last 2 iOS major versions
+Firefox ESR
+not IE 9-11 # For IE 9-11 support, remove 'not'.
@@ -0,0 +1,28 @@
+# React Environment Variables
+# https://facebook.github.io/create-react-app/docs/adding-custom-environment-variables#expanding-environment-variables-in-env
+
+# Netlify Environment Variables
+# https://www.netlify.com/docs/continuous-deployment/#environment-variables
+NX_VERSION=\$npm_package_version
+NX_REPOSITORY_URL=\$REPOSITORY_URL
+NX_BRANCH=\$BRANCH
+NX_PULL_REQUEST=\$PULL_REQUEST
+NX_HEAD=\$HEAD
+NX_COMMIT_REF=\$COMMIT_REF
+NX_CONTEXT=\$CONTEXT
+NX_REVIEW_ID=\$REVIEW_ID
+NX_INCOMING_HOOK_TITLE=\$INCOMING_HOOK_TITLE
+NX_INCOMING_HOOK_URL=\$INCOMING_HOOK_URL
+NX_INCOMING_HOOK_BODY=\$INCOMING_HOOK_BODY
+NX_URL=\$URL
+NX_DEPLOY_URL=\$DEPLOY_URL
+NX_DEPLOY_PRIME_URL=\$DEPLOY_PRIME_URL
+NX_VEGA_CONFIG_URL=https://raw.githubusercontent.com/vegaprotocol/networks-internal/main/fairground/vegawallet-fairground.toml
+NX_VEGA_ENV = 'TESTNET'
+NX_VEGA_URL="https://api.n07.testnet.vega.xyz/graphql"
+NX_VEGA_WALLET_URL=http://localhost:1789
+NX_ETHEREUM_PROVIDER_URL=https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
+NX_ETHERSCAN_URL=https://sepolia.etherscan.io
+NX_VEGA_NETWORKS={\"TESTNET\":\"https://console.fairground.wtf\",\"STAGNET1\":\"https://trading.stagnet1.vega.rocks\"}
+NX_VEGA_EXPLORER_URL=https://explorer.fairground.wtf
+NX_VEGA_CONSOLE_URL=https://console.fairground.wtf
@@ -0,0 +1,3 @@
+# App configuration variables
+NX_VEGA_URL=http://localhost:3008/graphql
+NX_VEGA_ENV=LOCAL
@@ -0,0 +1,8 @@
+# App configuration variables
+NX_VEGA_CONFIG_URL=https://raw.githubusercontent.com/vegaprotocol/networks-internal/main/devnet1/vegawallet-devnet1.toml
+NX_VEGA_URL=https://api.n04.d.vega.xyz/graphql
+NX_VEGA_ENV=DEVNET
+NX_VEGA_NETWORKS={\"TESTNET\":\"https://console.fairground.wtf\",\"STAGNET1\":\"https://trading.stagnet1.vega.rocks\"}
+NX_ETHEREUM_PROVIDER_URL=https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
+NX_ETHERSCAN_URL=https://sepolia.etherscan.io
+NX_VEGA_EXPLORER_URL=#
@@ -0,0 +1,9 @@
+# App configuration variables
+NX_VEGA_CONFIG_URL=https://raw.githubusercontent.com/vegaprotocol/networks/master/mainnet1/mainnet1.toml
+NX_VEGA_URL=https://api.vega.community/graphql
+NX_VEGA_ENV=MAINNET
+NX_VEGA_NETWORKS={\"TESTNET\":\"https://console.fairground.wtf\"}
+NX_ETHEREUM_PROVIDER_URL=https://mainnet.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
+NX_ETHERSCAN_URL=https://etherscan.io
+NX_VEGA_EXPLORER_URL=https://explorer.vega.xyz
+NX_VEGA_CONSOLE_URL=https://console.vega.xyz
@@ -0,0 +1,9 @@
+# App configuration variables
+NX_VEGA_CONFIG_URL=https://raw.githubusercontent.com/vegaprotocol/networks-internal/main/stagnet1/vegawallet-stagnet1.toml
+NX_VEGA_URL=https://api.n00.stagnet1.vega.xyz/graphql
+NX_VEGA_ENV=STAGNET1
+NX_ETHEREUM_PROVIDER_URL=https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
+NX_ETHERSCAN_URL=https://sepolia.etherscan.io
+NX_VEGA_EXPLORER_URL=https://explorer.stagnet1.vega.rocks
+NX_VEGA_NETWORKS={\"TESTNET\":\"https://console.fairground.wtf\",\"STAGNET1\":\"https://trading.stagnet1.vega.rocks\"}
+
@@ -0,0 +1,9 @@
+# App configuration variables
+NX_VEGA_CONFIG_URL=https://raw.githubusercontent.com/vegaprotocol/networks-internal/main/fairground/vegawallet-fairground.toml
+NX_VEGA_URL=https://api.n07.testnet.vega.xyz/graphql
+NX_VEGA_ENV=TESTNET
+NX_VEGA_NETWORKS={\"TESTNET\":\"https://console.fairground.wtf\"}
+NX_ETHEREUM_PROVIDER_URL=https://sepolia.infura.io/v3/4f846e79e13f44d1b51bbd7ed9edefb8
+NX_ETHERSCAN_URL=https://sepolia.etherscan.io
+NX_VEGA_EXPLORER_URL=https://explorer.fairground.wtf
+NX_VEGA_CONSOLE_URL=https://console.fairground.wtf
@@ -0,0 +1,18 @@
+{
+  "extends": ["plugin:@nx/react", "../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*", "__generated__"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}
@@ -0,0 +1,11 @@
+/* eslint-disable */
+export default {
+  displayName: 'liquidity-provision-dashboard',
+  preset: '../../jest.preset.js',
+  transform: {
+    '^(?!.*\\.(js|jsx|ts|tsx|css|json)$)': '@nx/react/plugins/jest',
+    '^.+\\.[tj]sx?$': ['babel-jest', { presets: ['@nx/next/babel'] }],
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
+  coverageDirectory: '../../coverage/apps/liquidity-provision-dashboard',
+};
@@ -0,0 +1,10 @@
+const { join } = require('path');
+
+module.exports = {
+  plugins: {
+    tailwindcss: {
+      config: join(__dirname, 'tailwind.config.js'),
+    },
+    autoprefixer: {},
+  },
+};
@@ -0,0 +1,94 @@
+{
+  "name": "liquidity-provision-dashboard",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "apps/liquidity-provision-dashboard/src",
+  "projectType": "application",
+  "targets": {
+    "build": {
+      "executor": "@nx/webpack:webpack",
+      "outputs": ["{options.outputPath}"],
+      "defaultConfiguration": "production",
+      "options": {
+        "compiler": "babel",
+        "outputPath": "dist/apps/liquidity-provision-dashboard",
+        "index": "apps/liquidity-provision-dashboard/src/index.html",
+        "baseHref": "/",
+        "main": "apps/liquidity-provision-dashboard/src/main.tsx",
+        "polyfills": "apps/liquidity-provision-dashboard/src/polyfills.ts",
+        "tsConfig": "apps/liquidity-provision-dashboard/tsconfig.app.json",
+        "assets": [
+          "apps/liquidity-provision-dashboard/src/favicon.ico",
+          "apps/liquidity-provision-dashboard/src/assets"
+        ],
+        "styles": ["apps/liquidity-provision-dashboard/src/styles.scss"],
+        "scripts": [],
+        "webpackConfig": "@nx/react/plugins/webpack"
+      },
+      "configurations": {
+        "development": {
+          "extractLicenses": false,
+          "optimization": false,
+          "sourceMap": true,
+          "vendorChunk": true
+        },
+        "production": {
+          "fileReplacements": [
+            {
+              "replace": "apps/liquidity-provision-dashboard/src/environments/environment.ts",
+              "with": "apps/liquidity-provision-dashboard/src/environments/environment.prod.ts"
+            }
+          ],
+          "optimization": true,
+          "outputHashing": "all",
+          "sourceMap": false,
+          "namedChunks": false,
+          "extractLicenses": true,
+          "vendorChunk": false
+        }
+      }
+    },
+    "serve": {
+      "executor": "@nx/webpack:dev-server",
+      "options": {
+        "buildTarget": "liquidity-provision-dashboard:build",
+        "hmr": true,
+        "port": 4201
+      },
+      "configurations": {
+        "development": {
+          "buildTarget": "liquidity-provision-dashboard:build:development"
+        },
+        "production": {
+          "buildTarget": "liquidity-provision-dashboard:build:production",
+          "hmr": false
+        }
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": [
+          "apps/liquidity-provision-dashboard/**/*.{ts,tsx,js,jsx}"
+        ]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": [
+        "{workspaceRoot}/coverage/apps/liquidity-provision-dashboard"
+      ],
+      "options": {
+        "jestConfig": "apps/liquidity-provision-dashboard/jest.config.ts"
+      }
+    },
+    "build-spec": {
+      "executor": "nx:run-commands",
+      "outputs": [],
+      "options": {
+        "command": "yarn tsc --project ./apps/liquidity-provision-dashboard/tsconfig.spec.json"
+      }
+    }
+  },
+  "tags": []
+}
@@ -0,0 +1,47 @@
+import type { InMemoryCacheConfig } from '@apollo/client';
+import { NetworkLoader, useInitializeEnv } from '@vegaprotocol/environment';
+import { useRoutes } from 'react-router-dom';
+
+import '../styles.scss';
+import { Navbar } from './components/navbar';
+
+import { routerConfig } from './routes/router-config';
+
+const cache: InMemoryCacheConfig = {
+  typePolicies: {
+    Market: {
+      merge: true,
+    },
+    Party: {
+      merge: true,
+    },
+    Query: {},
+    Account: {
+      keyFields: false,
+      fields: {
+        balanceFormatted: {},
+      },
+    },
+    Node: {
+      keyFields: false,
+    },
+    Instrument: {
+      keyFields: false,
+    },
+  },
+};
+const AppRouter = () => useRoutes(routerConfig);
+
+export function App() {
+  useInitializeEnv();
+  return (
+    <NetworkLoader cache={cache}>
+      <div className="max-h-full min-h-full bg-white">
+        <Navbar />
+        <AppRouter />
+      </div>
+    </NetworkLoader>
+  );
+}
+
+export default App;
@@ -0,0 +1,25 @@
+import { t } from '@vegaprotocol/i18n';
+
+import { Intro } from './intro';
+import { MarketList } from './market-list';
+
+export function Dashboard() {
+  return (
+    <>
+      <div className="px-16 pt-20 pb-12 bg-greys-light-100">
+        <div className="max-w-screen-xl mx-auto">
+          <h1 className="font-alpha calt uppercase text-5xl mb-8">
+            {t('Top liquidity opportunities')}
+          </h1>
+
+          <Intro />
+        </div>
+      </div>
+      <div className="px-16 py-6">
+        <div className="max-w-screen-xl mx-auto">
+          <MarketList />
+        </div>
+      </div>
+    </>
+  );
+}
@@ -0,0 +1 @@
+export * from './dashboard';
@@ -0,0 +1 @@
+export * from './intro';
@@ -0,0 +1,53 @@
+import { t } from '@vegaprotocol/i18n';
+import { ExternalLink } from '@vegaprotocol/ui-toolkit';
+
+// TODO: add mainnet links once docs have been updated
+const LINKS = {
+  testnet: [
+    {
+      label: 'Learn about liquidity fees',
+      url: 'https://docs.vega.xyz/testnet/tutorials/providing-liquidity#resources',
+    },
+    {
+      label: 'Provide liquidity',
+      url: 'https://docs.vega.xyz/testnet/tutorials/providing-liquidity#overview',
+    },
+    {
+      label: 'View your liquidity provisions',
+      url: 'https://docs.vega.xyz/testnet/tutorials/providing-liquidity#viewing-existing-liquidity-provisions',
+    },
+    {
+      label: 'Amend or remove liquidity',
+      url: 'https://docs.vega.xyz/testnet/tutorials/providing-liquidity#amending-a-liquidity-commitment',
+    },
+  ],
+  mainnet: [],
+};
+
+// TODO: update this when network switcher is added
+type Network = 'testnet' | 'mainnet';
+
+export const Intro = ({ network = 'testnet' }: { network?: Network }) => {
+  return (
+    <div>
+      <p className="font-alpha calt text-2xl font-medium mb-2">
+        {t(
+          'Become a liquidity provider and earn a cut of the fees paid during trading.'
+        )}
+      </p>
+      <div>
+        <ul className="flex flex-wrap">
+          {LINKS[network].map(
+            ({ label, url }: { label: string; url: string }) => (
+              <li key={url} className="mr-6">
+                <ExternalLink href={url} rel="noreferrer">
+                  {t(label)}
+                </ExternalLink>
+              </li>
+            )
+          )}
+        </ul>
+      </div>
+    </div>
+  );
+};
@@ -0,0 +1 @@
+export * from './market-list';
@@ -0,0 +1,296 @@
+import { DApp, useLinks } from '@vegaprotocol/environment';
+import { type Market } from '@vegaprotocol/liquidity';
+import {
+  displayChange,
+  formatWithAsset,
+  useMarketsLiquidity,
+} from '@vegaprotocol/liquidity';
+import {
+  addDecimalsFormatNumber,
+  formatNumberPercentage,
+  getExpiryDate,
+  toBigNum,
+} from '@vegaprotocol/utils';
+import { t } from '@vegaprotocol/i18n';
+import { type VegaValueFormatterParams } from '@vegaprotocol/datagrid';
+import { PriceChangeCell } from '@vegaprotocol/datagrid';
+import type * as Schema from '@vegaprotocol/types';
+import {
+  AsyncRenderer,
+  Icon,
+  HealthBar,
+  TooltipCellComponent,
+} from '@vegaprotocol/ui-toolkit';
+import {
+  type GetRowIdParams,
+  type RowClickedEvent,
+  type ColDef,
+} from 'ag-grid-community';
+import 'ag-grid-community/styles/ag-grid.css';
+import 'ag-grid-community/styles/ag-theme-alpine.css';
+import { useCallback, useState, useMemo } from 'react';
+
+import { Grid } from '../../grid';
+import { HealthDialog } from '../../health-dialog';
+import { Status } from '../../status';
+import { intentForStatus } from '../../../lib/utils';
+import { formatDistanceToNow } from 'date-fns';
+import { getAsset } from '@vegaprotocol/markets';
+
+export const MarketList = () => {
+  const { data, error, loading } = useMarketsLiquidity();
+  const [isHealthDialogOpen, setIsHealthDialogOpen] = useState(false);
+  const consoleLink = useLinks(DApp.Console);
+
+  const getRowId = useCallback(({ data }: GetRowIdParams) => data.id, []);
+  const columnDefs = useMemo<ColDef[]>(
+    () => [
+      {
+        headerName: t('Market (futures)'),
+        field: 'tradableInstrument.instrument.name',
+        cellRenderer: ({ value, data }: { value: string; data: Market }) => {
+          return (
+            <>
+              <span className="leading-3">{value}</span>
+              <span className="leading-3">{getAsset(data).symbol}</span>
+            </>
+          );
+        },
+        minWidth: 100,
+        flex: 1,
+        headerTooltip: t('The market name and settlement asset'),
+      },
+
+      {
+        headerName: t('Market Code'),
+        headerTooltip: t(
+          'The market code is a unique identifier for this market'
+        ),
+        field: 'tradableInstrument.instrument.code',
+      },
+
+      {
+        headerName: t('Type'),
+        headerTooltip: t('Type'),
+        field: 'tradableInstrument.instrument.product.__typename',
+      },
+
+      {
+        headerName: t('Last Price'),
+        headerTooltip: t('Latest price for this market'),
+        field: 'data.markPrice',
+        valueFormatter: ({
+          value,
+          data,
+        }: VegaValueFormatterParams<Market, 'data.markPrice'>) =>
+          value && data ? formatWithAsset(value, getAsset(data)) : '-',
+      },
+
+      {
+        headerName: t('Change (24h)'),
+        headerTooltip: t('Change in price over the last 24h'),
+        cellRenderer: ({
+          data,
+        }: VegaValueFormatterParams<Market, 'data.candles'>) => {
+          if (data && data.candles) {
+            const prices = data.candles.map((candle) => candle.close);
+            return (
+              <PriceChangeCell
+                candles={prices}
+                decimalPlaces={data?.decimalPlaces}
+              />
+            );
+          } else return <div>{t('-')}</div>;
+        },
+      },
+
+      {
+        headerName: t('Volume (24h)'),
+        field: 'dayVolume',
+        valueFormatter: ({
+          value,
+          data,
+        }: VegaValueFormatterParams<Market, 'dayVolume'>) =>
+          value && data
+            ? `${addDecimalsFormatNumber(
+                value,
+                getAsset(data).decimals || 0
+              )} (${displayChange(data.volumeChange)})`
+            : '-',
+        headerTooltip: t('The trade volume over the last 24h'),
+      },
+
+      {
+        headerName: t('Total staked by LPs'),
+        field: 'liquidityCommitted',
+        valueFormatter: ({
+          value,
+          data,
+        }: VegaValueFormatterParams<Market, 'liquidityCommitted'>) =>
+          data && value
+            ? formatWithAsset(value.toString(), getAsset(data))
+            : '-',
+        headerTooltip: t('The amount of funds allocated to provide liquidity'),
+      },
+
+      {
+        headerName: t('Target stake'),
+        field: 'target',
+        valueFormatter: ({
+          value,
+          data,
+        }: VegaValueFormatterParams<Market, 'target'>) =>
+          data && value ? formatWithAsset(value, getAsset(data)) : '-',
+        headerTooltip: t(
+          'The ideal committed liquidity to operate the market.  If total commitment currently below this level then LPs can set the fee level with new commitment.'
+        ),
+      },
+
+      {
+        headerName: t('% Target stake met'),
+        valueFormatter: ({ data }: VegaValueFormatterParams<Market, ''>) => {
+          if (data) {
+            const roundedPercentage =
+              parseInt(
+                (data.liquidityCommitted / parseFloat(data.target)).toFixed(0)
+              ) * 100;
+            const display = Number.isNaN(roundedPercentage)
+              ? 'N/A'
+              : formatNumberPercentage(toBigNum(roundedPercentage, 0), 0);
+            return display;
+          } else return '-';
+        },
+        headerTooltip: t('% Target stake met'),
+      },
+
+      {
+        headerName: t('Fee levels'),
+        field: 'fees',
+        valueFormatter: ({ value }: VegaValueFormatterParams<Market, 'fees'>) =>
+          value ? `${value.factors.liquidityFee}%` : '-',
+        headerTooltip: t('Fee level for this market'),
+      },
+
+      {
+        headerName: t('Status'),
+        field: 'tradingMode',
+        cellRenderer: ({
+          value,
+          data,
+        }: {
+          value: Schema.MarketTradingMode;
+          data: Market;
+        }) => {
+          return <Status trigger={data.data?.trigger} tradingMode={value} />;
+        },
+        headerTooltip: t(
+          'The current market status - those below the target stake mark are most in need of liquidity'
+        ),
+      },
+
+      {
+        headerComponent: () => {
+          return (
+            <div>
+              <span>{t('Health')}</span>{' '}
+              <button
+                onClick={() => setIsHealthDialogOpen(true)}
+                aria-label={t('open tooltip')}
+              >
+                <Icon name="info-sign" />
+              </button>
+            </div>
+          );
+        },
+        field: 'tradingMode',
+        cellRenderer: ({
+          value,
+          data,
+        }: {
+          value: Schema.MarketTradingMode;
+          data: Market;
+        }) => (
+          <HealthBar
+            target={data.target}
+            decimals={getAsset(data).decimals || 0}
+            levels={data.feeLevels}
+            intent={intentForStatus(value)}
+          />
+        ),
+        sortable: false,
+        cellStyle: { overflow: 'unset' },
+      },
+      {
+        headerName: t('Age'),
+        field: 'marketTimestamps.open',
+        headerTooltip: t('Age of the market'),
+        valueFormatter: ({
+          value,
+        }: VegaValueFormatterParams<Market, 'marketTimestamps.open'>) => {
+          return value ? formatDistanceToNow(new Date(value)) : '-';
+        },
+      },
+      {
+        headerName: t('Closing Time'),
+        field: 'tradableInstrument.instrument.metadata.tags',
+        headerTooltip: t('Closing time of the market'),
+        valueFormatter: ({ data }: VegaValueFormatterParams<Market, ''>) => {
+          let expiry;
+          if (data?.tradableInstrument.instrument.metadata.tags) {
+            expiry = getExpiryDate(
+              data?.tradableInstrument.instrument.metadata.tags,
+              data?.marketTimestamps.close,
+              data?.state
+            );
+          }
+          return expiry ? expiry : '-';
+        },
+      },
+    ],
+    []
+  );
+
+  return (
+    <AsyncRenderer loading={loading} error={error} data={data}>
+      <div
+        className="w-full grow"
+        style={{ minHeight: 500, overflow: 'hidden' }}
+      >
+        <Grid
+          gridOptions={{
+            onRowClicked: ({ data }: RowClickedEvent) => {
+              window.open(
+                liquidityDetailsConsoleLink(data.id, consoleLink),
+                '_blank',
+                'noopener,noreferrer'
+              );
+            },
+          }}
+          rowData={data}
+          defaultColDef={{
+            resizable: true,
+            sortable: true,
+            unSortIcon: true,
+            cellClass: ['flex', 'flex-col', 'justify-center'],
+            tooltipComponent: TooltipCellComponent,
+          }}
+          columnDefs={columnDefs}
+          getRowId={getRowId}
+          isRowClickable
+          tooltipShowDelay={500}
+        />
+        <HealthDialog
+          isOpen={isHealthDialogOpen}
+          onChange={() => {
+            setIsHealthDialogOpen(!isHealthDialogOpen);
+          }}
+        />
+      </div>
+    </AsyncRenderer>
+  );
+};
+
+const liquidityDetailsConsoleLink = (
+  marketId: string,
+  consoleLink: (url: string | undefined) => string
+) => consoleLink(`/#/liquidity/${marketId}`);
@@ -0,0 +1,103 @@
+import { useParams } from 'react-router-dom';
+import { makeDerivedDataProvider } from '@vegaprotocol/data-provider';
+import { t } from '@vegaprotocol/i18n';
+import { useDataProvider } from '@vegaprotocol/data-provider';
+import { AsyncRenderer } from '@vegaprotocol/ui-toolkit';
+
+import {
+  getFeeLevels,
+  sumLiquidityCommitted,
+  lpAggregatedDataProvider,
+} from '@vegaprotocol/liquidity';
+import { getAsset, marketWithDataProvider } from '@vegaprotocol/markets';
+import type { MarketWithData } from '@vegaprotocol/markets';
+
+import { Market } from './market';
+import { Header } from './header';
+import { LPProvidersGrid } from './providers';
+
+const formatMarket = (market: MarketWithData) => {
+  return {
+    name: market?.tradableInstrument.instrument.name,
+    symbol: getAsset(market).symbol,
+    settlementAsset: getAsset(market),
+    targetStake: market?.data?.targetStake,
+    tradingMode: market?.data?.marketTradingMode,
+    trigger: market?.data?.trigger,
+  };
+};
+
+export const lpDataProvider = makeDerivedDataProvider(
+  [marketWithDataProvider, lpAggregatedDataProvider],
+  ([market, lpAggregatedData]) => ({
+    market: { ...formatMarket(market) },
+    liquidityProviders: lpAggregatedData || [],
+  })
+);
+
+const useMarketDetails = (marketId: string | undefined) => {
+  const { data, loading, error } = useDataProvider({
+    dataProvider: lpDataProvider,
+    skipUpdates: true,
+    variables: { marketId: marketId || '' },
+  });
+
+  const liquidityProviders = data?.liquidityProviders || [];
+
+  return {
+    data: {
+      name: data?.market?.name,
+      symbol: data?.market?.symbol,
+      liquidityProviders: liquidityProviders,
+      feeLevels: getFeeLevels(liquidityProviders),
+      comittedLiquidity: sumLiquidityCommitted(liquidityProviders) || 0,
+      settlementAsset: data?.market?.settlementAsset || {},
+      targetStake: data?.market?.targetStake || '0',
+      tradingMode: data?.market.tradingMode,
+    },
+    error,
+    loading: loading,
+  };
+};
+
+type Params = { marketId: string };
+
+export const Detail = () => {
+  const { marketId } = useParams<Params>();
+  const { data, loading, error } = useMarketDetails(marketId);
+
+  return (
+    <AsyncRenderer loading={loading} error={error} data={data}>
+      <div className="bg-greys-light-100 px-16 pb-12 pt-14">
+        <div className="mx-auto max-w-screen-xl">
+          <Header name={data.name} symbol={data.symbol} />
+        </div>
+      </div>
+      <div className="px-16">
+        <div className="mx-auto max-w-screen-xl">
+          <div className="py-12">
+            {marketId && (
+              <Market
+                marketId={marketId}
+                feeLevels={data.feeLevels}
+                comittedLiquidity={data.comittedLiquidity}
+                settlementAsset={data.settlementAsset}
+                targetStake={data.targetStake}
+                tradingMode={data.tradingMode}
+              />
+            )}
+          </div>
+          <div>
+            <h2 className="font-alpha calt mb-4 text-2xl">
+              {t('Current Liquidity Provision')}
+            </h2>
+            <LPProvidersGrid
+              liquidityProviders={data.liquidityProviders}
+              settlementAsset={data.settlementAsset}
+            />
+          </div>
+        </div>
+      </div>
+    </AsyncRenderer>
+  );
+};
@@ -0,0 +1,26 @@
+import { t } from '@vegaprotocol/i18n';
+import { Link } from 'react-router-dom';
+import { Icon } from '@vegaprotocol/ui-toolkit';
+
+export const Header = ({
+  name,
+  symbol,
+}: {
+  name?: string;
+  symbol?: string;
+}) => {
+  return (
+    <div>
+      <div className="mb-6">
+        <Link to="/">
+          <Icon name="chevron-left" className="mr-2" />
+          <span className="underline font-alpha calt text-lg font-medium">
+            {t('Liquidity opportunities')}
+          </span>
+        </Link>
+      </div>
+      <h1 className="font-alpha calt text-5xl mb-6">{name}</h1>
+      <p className="font-alpha calt text-4xl">{symbol}</p>
+    </div>
+  );
+};
@@ -0,0 +1 @@
+export * from './header';
@@ -0,0 +1 @@
+export * from './detail';
@@ -0,0 +1 @@
+export * from './last-24h-volume';
@@ -0,0 +1,108 @@
+import { useState, useMemo, useRef, useCallback } from 'react';
+import throttle from 'lodash/throttle';
+import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
+import { useYesterday } from '@vegaprotocol/react-helpers';
+import { useDataProvider } from '@vegaprotocol/data-provider';
+import * as Schema from '@vegaprotocol/types';
+import {
+  calcDayVolume,
+  getChange,
+  displayChange,
+} from '@vegaprotocol/liquidity';
+
+import type { Candle } from '@vegaprotocol/markets';
+import { marketCandlesProvider } from '@vegaprotocol/markets';
+
+const THROTTLE_UPDATE_TIME = 500;
+
+export const Last24hVolume = ({
+  marketId,
+  decimals,
+}: {
+  marketId: string;
+  decimals: number;
+}) => {
+  const [candleVolume, setCandleVolume] = useState<string>();
+  const [volumeChange, setVolumeChange] = useState<string>(' - ');
+
+  const yesterday = useYesterday();
+
+  const yTimestamp = useMemo(() => {
+    return new Date(yesterday).toISOString();
+  }, [yesterday]);
+
+  const variables = useMemo(
+    () => ({
+      marketId: marketId,
+      interval: Schema.Interval.INTERVAL_I1H,
+      since: yTimestamp,
+    }),
+    [marketId, yTimestamp]
+  );
+
+  const variables24hAgo = {
+    marketId: marketId,
+    interval: Schema.Interval.INTERVAL_I1D,
+    since: yTimestamp,
+  };
+
+  const throttledSetCandles = useRef(
+    throttle((data: Candle[]) => {
+      setCandleVolume(calcDayVolume(data));
+    }, THROTTLE_UPDATE_TIME)
+  ).current;
+
+  const update = useCallback(
+    ({ data }: { data: Candle[] | null }) => {
+      if (data) {
+        throttledSetCandles(data);
+      }
+      return true;
+    },
+    [throttledSetCandles]
+  );
+
+  const { data, error } = useDataProvider({
+    dataProvider: marketCandlesProvider,
+    variables: variables,
+    update,
+    skip: !marketId,
+  });
+
+  const throttledSetVolumeChange = useRef(
+    throttle((candles: Candle[]) => {
+      const candle24hAgo = candles?.[0];
+      setVolumeChange(getChange(data || [], candle24hAgo?.close));
+    }, THROTTLE_UPDATE_TIME)
+  ).current;
+
+  const updateCandle24hAgo = useCallback(
+    ({ data }: { data: Candle[] | null }) => {
+      if (data) {
+        throttledSetVolumeChange(data);
+      }
+      return true;
+    },
+    [throttledSetVolumeChange]
+  );
+
+  useDataProvider({
+    dataProvider: marketCandlesProvider,
+    update: updateCandle24hAgo,
+    variables: variables24hAgo,
+    skip: !marketId || !data,
+  });
+
+  return (
+    <div>
+      <span className="text-3xl">
+        {!error && candleVolume
+          ? addDecimalsFormatNumber(candleVolume, decimals)
+          : '0'}{' '}
+      </span>
+      <span className="text-lg text-greys-light-400">
+        ({displayChange(volumeChange)})
+      </span>
+    </div>
+  );
+};
@@ -0,0 +1 @@
+export * from './market';
@@ -0,0 +1,118 @@
+import { useState } from 'react';
+import { t } from '@vegaprotocol/i18n';
+import { Icon, HealthBar } from '@vegaprotocol/ui-toolkit';
+import { formatWithAsset } from '@vegaprotocol/liquidity';
+
+import type * as Schema from '@vegaprotocol/types';
+import { HealthDialog } from '../../health-dialog';
+import { Last24hVolume } from '../last-24h-volume';
+import { Status } from '../../status';
+import { intentForStatus } from '../../../lib/utils';
+
+interface Levels {
+  fee: string;
+  commitmentAmount: number;
+}
+
+interface settlementAsset {
+  symbol?: string;
+  decimals?: number;
+}
+
+export const Market = ({
+  marketId,
+  feeLevels,
+  comittedLiquidity,
+  settlementAsset,
+  targetStake,
+  tradingMode,
+  trigger,
+}: {
+  marketId: string;
+  feeLevels: Levels[];
+  comittedLiquidity: number;
+  targetStake: string;
+  settlementAsset?: settlementAsset;
+  tradingMode?: Schema.MarketTradingMode;
+  trigger?: Schema.AuctionTrigger;
+}) => {
+  const [isHealthDialogOpen, setIsHealthDialogOpen] = useState(false);
+
+  return (
+    <div>
+      <div className="border border-greys-light-200 rounded-2xl px-2 py-6">
+        <table className="w-full">
+          <thead>
+            <tr
+              className="text-sm text-greys-light-400 text-left font-alpha calt"
+              style={{ fontFeatureSettings: "'liga' off, 'calt' off" }}
+            >
+              <th className="font-medium px-4">{t('Volume (24h)')}</th>
+              <th className="font-medium px-4">{t('Commited Liquidity')}</th>
+              <th className="font-medium px-4">{t('Status')}</th>
+              <th className="font-medium flex items-center px-4">
+                <span>{t('Health')}</span>{' '}
+                <button
+                  onClick={() => setIsHealthDialogOpen(true)}
+                  aria-label={t('open tooltip')}
+                  className="flex ml-1"
+                >
+                  <Icon name="info-sign" />
+                </button>
+              </th>
+              <th className="font-medium">{t('Est. APY')}</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td className="px-4">
+                <div>
+                  {marketId && settlementAsset?.decimals && (
+                    <Last24hVolume
+                      marketId={marketId}
+                      decimals={settlementAsset.decimals}
+                    />
+                  )}
+                </div>
+              </td>
+              <td className="px-4">
+                <span className="text-3xl">
+                  {comittedLiquidity && settlementAsset
+                    ? formatWithAsset(`${comittedLiquidity}`, settlementAsset)
+                    : '0'}
+                </span>
+              </td>
+              <td className="px-4">
+                <Status
+                  trigger={trigger}
+                  tradingMode={tradingMode}
+                  size="large"
+                />
+              </td>
+              <td className="px-4">
+                {tradingMode && settlementAsset?.decimals && feeLevels && (
+                  <HealthBar
+                    target={targetStake}
+                    decimals={settlementAsset.decimals}
+                    levels={feeLevels}
+                    intent={intentForStatus(tradingMode)}
+                  />
+                )}
+              </td>
+              <td className="px-4">
+                <span className="text-3xl"></span>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+
+      <HealthDialog
+        isOpen={isHealthDialogOpen}
+        onChange={() => {
+          setIsHealthDialogOpen(!isHealthDialogOpen);
+        }}
+      />
+    </div>
+  );
+};
@@ -0,0 +1 @@
+export * from './providers';
@@ -0,0 +1,125 @@
+import { useCallback, useMemo } from 'react';
+
+import { type GetRowIdParams, type ColDef } from 'ag-grid-community';
+import { t } from '@vegaprotocol/i18n';
+
+import {
+  type LiquidityProviderFeeShareFieldsFragment,
+  type LiquidityProvisionFieldsFragment,
+} from '@vegaprotocol/liquidity';
+import { formatWithAsset } from '@vegaprotocol/liquidity';
+
+import { Grid } from '../../grid';
+import { TooltipCellComponent } from '@vegaprotocol/ui-toolkit';
+
+const formatToHours = ({ value }: { value?: string | null }) => {
+  if (!value) {
+    return '-';
+  }
+
+  const MS_IN_HOUR = 1000 * 60 * 60;
+  const created = new Date(value).getTime();
+  const now = new Date().getTime();
+  return `${Math.round(Math.abs(now - created) / MS_IN_HOUR)}h`;
+};
+
+export const LPProvidersGrid = ({
+  liquidityProviders,
+  settlementAsset,
+}: {
+  liquidityProviders: LiquidityProvisionFieldsFragment &
+    LiquidityProviderFeeShareFieldsFragment[];
+  settlementAsset: {
+    decimals?: number;
+    symbol?: string;
+  };
+}) => {
+  const getRowId = useCallback(({ data }: GetRowIdParams) => data.party.id, []);
+  const columnDefs = useMemo<ColDef[]>(
+    () => [
+      {
+        headerName: t('LPs'),
+        field: 'party.id',
+        flex: 1,
+        minWidth: 100,
+        headerTooltip: t('Liquidity providers'),
+      },
+      {
+        headerName: t('Duration'),
+        valueFormatter: formatToHours,
+        field: 'createdAt',
+        headerTooltip: t('Time in market'),
+      },
+      {
+        headerName: t('Equity-like share'),
+        field: 'equityLikeShare',
+        valueFormatter: ({ value }: { value?: string | null }) => {
+          return value
+            ? `${parseFloat(parseFloat(value).toFixed(2)) * 100}%`
+            : '';
+        },
+        headerTooltip: t(
+          'The share of the markets liquidity held - the earlier you commit liquidity the greater % fees you earn'
+        ),
+        minWidth: 140,
+      },
+      {
+        headerName: t('committed bond'),
+        field: 'commitmentAmount',
+        valueFormatter: ({ value }: { value?: string | null }) =>
+          value ? formatWithAsset(value, settlementAsset) : '0',
+        headerTooltip: t('The amount of funds allocated to provide liquidity'),
+        minWidth: 140,
+      },
+      {
+        headerName: t('Margin Req.'),
+        field: 'margin',
+        headerTooltip: t(
+          'Margin required for arising positions based on liquidity commitment'
+        ),
+      },
+      {
+        headerName: t('24h Fees'),
+        field: 'fees',
+        headerTooltip: t(
+          'Total fees earned by the liquidity provider in the last 24 hours'
+        ),
+      },
+      {
+        headerName: t('Fee level'),
+        valueFormatter: ({ value }: { value?: string | null }) => `${value}%`,
+        field: 'fee',
+        headerTooltip: t(
+          "The market's liquidity fee, or the percentage of a trade's value which is collected from the price taker for every trade"
+        ),
+      },
+
+      {
+        headerName: t('APY'),
+        field: 'apy',
+        headerTooltip: t(
+          'An annualised estimate based on the total liquidity provision fees and maker fees collected by liquidity providers, the maximum margin needed and maximum commitment (bond) over the course of 7 epochs'
+        ),
+      },
+    ],
+    [settlementAsset]
+  );
+
+  return (
+    <Grid
+      rowData={liquidityProviders}
+      tooltipShowDelay={500}
+      defaultColDef={{
+        resizable: true,
+        sortable: true,
+        unSortIcon: true,
+        cellClass: ['flex', 'flex-col', 'justify-center'],
+        tooltipComponent: TooltipCellComponent,
+        minWidth: 100,
+      }}
+      columnDefs={columnDefs}
+      getRowId={getRowId}
+      rowHeight={92}
+    />
+  );
+};
@@ -0,0 +1,50 @@
+.ag-theme-alpine {
+  --ag-line-height: 24px;
+  --ag-row-hover-color: transparent;
+  --ag-header-background-color: transparent;
+  --ag-odd-row-background-color: transparent;
+  --ag-header-foreground-color: #626262;
+  --ag-secondary-foreground-color: #626262;
+  --ag-font-size: 16px;
+  --ag-background-color: transparent;
+  --ag-range-selection-border-color: transparent;
+
+  font-family: AlphaLyrae, Helvetica Neue, -apple-system, BlinkMacSystemFont,
+    Segoe UI, Roboto, Arial, Noto Sans, sans-serif, Apple Color Emoji,
+    Segoe UI Emoji, Segoe UI Symbol, Noto Color Emoji;
+  font-feature-settings: 'liga' off, 'calt' off;
+}
+
+.ag-theme-alpine .ag-cell {
+  display: flex;
+}
+
+.ag-theme-alpine .ag-header {
+  border-bottom: 1px solid #a7a7a7;
+  font-size: 15px;
+  line-height: 1em;
+  text-transform: uppercase;
+}
+
+.ag-theme-alpine .ag-root-wrapper {
+  border: none;
+}
+
+.ag-theme-alpine .ag-header-row {
+  font-weight: 500;
+}
+
+.ag-theme-alpine .ag-row {
+  border: none;
+  border-bottom: 1px solid #bfccd6;
+  font-size: 12px;
+}
+
+.ag-theme-alpine .ag-root-wrapper-body.ag-layout-normal {
+  height: auto;
+}
+
+.ag-theme-alpine.row-hover .ag-row:hover {
+  background: #f0f0f0;
+  cursor: pointer;
+}
@@ -0,0 +1,47 @@
+import { useRef, useCallback, useEffect } from 'react';
+import { AgGridReact } from 'ag-grid-react';
+import {
+  type AgGridReactProps,
+  type AgReactUiProps,
+  type AgGridReact as AgGridReactType,
+} from 'ag-grid-react';
+import classNames from 'classnames';
+import 'ag-grid-community/styles/ag-grid.css';
+import 'ag-grid-community/styles/ag-theme-alpine.css';
+
+import './grid.scss';
+
+type Props = (AgGridReactProps | AgReactUiProps) & {
+  isRowClickable?: boolean;
+  style?: React.CSSProperties;
+};
+
+export const Grid = ({ isRowClickable, ...props }: Props) => {
+  const gridRef = useRef<AgGridReactType | null>(null);
+
+  const resizeGrid = useCallback(() => {
+    gridRef.current?.api?.sizeColumnsToFit();
+  }, [gridRef]);
+
+  const handleOnGridReady = useCallback(() => {
+    resizeGrid();
+  }, [resizeGrid]);
+
+  useEffect(() => {
+    window.addEventListener('resize', resizeGrid);
+    return () => window.removeEventListener('resize', resizeGrid);
+  }, [resizeGrid]);
+
+  return (
+    <AgGridReact
+      className={classNames('ag-theme-alpine font-alpha calt h-full', {
+        'row-hover': isRowClickable,
+      })}
+      rowHeight={92}
+      ref={gridRef}
+      onGridReady={handleOnGridReady}
+      suppressRowClickSelection
+      {...props}
+    />
+  );
+};
@@ -0,0 +1 @@
+export * from './grid';
@@ -0,0 +1,110 @@
+import { t } from '@vegaprotocol/i18n';
+import { Dialog, HealthBar } from '@vegaprotocol/ui-toolkit';
+import * as Schema from '@vegaprotocol/types';
+import classNames from 'classnames';
+import { intentForStatus } from '../../lib/utils';
+
+interface HealthDialogProps {
+  isOpen: boolean;
+  onChange: (isOpen: boolean) => void;
+}
+
+const ROWS = [
+  {
+    key: '1',
+    title: 'Continuous',
+    copy: 'Markets that have committed liquidity equal or greater than the target stake are trading continuously.',
+    data: {
+      status: Schema.MarketTradingMode.TRADING_MODE_CONTINUOUS,
+      target: '171320',
+      decimals: 5,
+      levels: [
+        { fee: '0.6', commitmentAmount: 150000 },
+        { fee: '1', commitmentAmount: 150000 },
+        { fee: '2', commitmentAmount: 30000 },
+      ],
+    },
+  },
+  {
+    key: '2',
+    title: 'Monitoring auction (liquidity)',
+    copy: 'Markets below the target stake will see trading suspended and go into liquidity auction.',
+    data: {
+      status: Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION,
+      target: '171320',
+      decimals: 5,
+      levels: [
+        { fee: '0.6', commitmentAmount: 110000 },
+        { fee: '1', commitmentAmount: 50000 },
+      ],
+    },
+  },
+  {
+    key: '3',
+    title: 'Opening auction',
+    copy: 'A newly created market looking for a target liquidity amount to start trading.',
+    data: {
+      status: Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION,
+      target: '171320',
+      decimals: 3,
+      levels: [
+        { fee: '0.6', commitmentAmount: 110000 },
+        { fee: '1', commitmentAmount: 50000 },
+      ],
+    },
+  },
+];
+
+export const HealthDialog = ({ onChange, isOpen }: HealthDialogProps) => {
+  return (
+    <Dialog size="large" open={isOpen} onChange={onChange}>
+      <h1 className="text-2xl mb-5 pr-2 font-medium font-alpha uppercase">
+        {t('Health')}
+      </h1>
+      <p className="text-lg font-medium font-alpha mb-8">
+        {t(
+          'Market health is a representation of market and liquidity status and how close that market is to moving from one fee level to another.'
+        )}
+      </p>
+
+      <table className="table-fixed">
+        <thead className="border-b border-greys-light-300">
+          <th className="w-1/2 text-left font-medium font-alpha text-base pb-4 uppercase">
+            {t('Market status')}
+          </th>
+          <th className="w-1/2 text-lef font-medium font-alpha text-base pb-4 uppercase">
+            {t('Liquidity status')}
+          </th>
+        </thead>
+        <tbody>
+          {ROWS.map((r, index) => {
+            const isFirstRow = index === 0;
+            return (
+              <tr key={r.key}>
+                <td
+                  className={classNames('pr-4 pb-10', { 'pt-8': isFirstRow })}
+                >
+                  <h2 className="font-medium font-alpha uppercase text-base">
+                    {t(r.title)}
+                  </h2>
+                  <p className="font-medium font-alpha text-lg">{t(r.copy)}</p>
+                </td>
+                <td
+                  className={classNames('pl-4 pb-10', { 'pt-8': isFirstRow })}
+                >
+                  <HealthBar
+                    size="large"
+                    levels={r.data.levels}
+                    target={r.data.target}
+                    decimals={r.data.decimals}
+                    intent={intentForStatus(r.data.status)}
+                  />
+                </td>
+              </tr>
+            );
+          })}
+        </tbody>
+      </table>
+    </Dialog>
+  );
+};
@@ -0,0 +1 @@
+export * from './health-dialog';
@@ -0,0 +1 @@
+export * from './indicator';
@@ -0,0 +1,24 @@
+import type * as Schema from '@vegaprotocol/types';
+
+import { getColorForStatus } from '../../lib/utils';
+
+export const Indicator = ({
+  status,
+  opacity,
+}: {
+  status?: Schema.MarketTradingMode;
+  opacity?: number;
+}) => {
+  const backgroundColor = status ? getColorForStatus(status) : undefined;
+  return (
+    <div className="inline-block w-2 h-2 mr-1 rounded-full bg-white overflow-hidden shrink-0">
+      <div
+        className="h-full bg-black"
+        style={{
+          opacity,
+          backgroundColor,
+        }}
+      />
+    </div>
+  );
+};
@@ -0,0 +1,35 @@
+.ag-theme-alpine {
+  --ag-line-height: 24px;
+  --ag-row-hover-color: transparent;
+  --ag-header-background-color: #f5f5f5;
+  --ag-odd-row-background-color: transparent;
+  --ag-header-foreground-color: #000;
+  --ag-secondary-foreground-color: #fff;
+  --ag-font-family: 'Helvetica Neue';
+  --ag-font-size: 12px;
+
+  font-family: 'Helvetica Neue', -apple-system, BlinkMacSystemFont, 'Segoe UI',
+    Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif;
+}
+
+.ag-theme-alpine .ag-cell {
+  display: flex;
+}
+
+.ag-theme-alpine .ag-header {
+  border: 1px solid #bfccd6;
+}
+
+.ag-theme-alpine .ag-root-wrapper {
+  border: none;
+}
+
+.ag-theme-alpine .ag-row {
+  border: none;
+  border-bottom: 1px solid #bfccd6;
+  font-size: 12px;
+}
+
+.ag-theme-alpine .ag-root-wrapper-body.ag-layout-normal {
+  height: auto;
+}
@@ -0,0 +1 @@
+export * from './navbar';
@@ -0,0 +1,15 @@
+import { Link } from 'react-router-dom';
+import { VegaLogo } from '@vegaprotocol/ui-toolkit';
+
+export const Navbar = () => {
+  return (
+    <div className="px-8 py-4 flex items-stretch border-b border-greys-light-200">
+      <div className="flex gap-4 mr-4 items-center h-full">
+        <Link to="/">
+          <VegaLogo />
+        </Link>
+      </div>
+      <div className="flex items-center gap-2 ml-auto"></div>
+    </div>
+  );
+};
@@ -0,0 +1 @@
+export * from './status';
@@ -0,0 +1,96 @@
+import { Lozenge, Tooltip } from '@vegaprotocol/ui-toolkit';
+import classNames from 'classnames';
+
+import * as Schema from '@vegaprotocol/types';
+import { t } from '@vegaprotocol/i18n';
+
+import { Indicator } from '../indicator';
+import type { AuctionTrigger } from '@vegaprotocol/types';
+
+export const Status = ({
+  tradingMode,
+  trigger,
+  size = 'small',
+}: {
+  tradingMode?: Schema.MarketTradingMode;
+  trigger?: Schema.AuctionTrigger;
+  size?: 'small' | 'large';
+}) => {
+  const getStatus = () => {
+    if (!tradingMode) return '';
+    if (
+      tradingMode === Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION
+    ) {
+      if (
+        trigger &&
+        trigger !== Schema.AuctionTrigger.AUCTION_TRIGGER_UNSPECIFIED
+      ) {
+        return `${Schema.MarketTradingModeMapping[tradingMode]} - ${Schema.AuctionTriggerMapping[trigger]}`;
+      }
+    }
+    return Schema.MarketTradingModeMapping[tradingMode];
+  };
+
+  const status = getStatus();
+  const tooltipDescription =
+    tradingMode && getTooltipDescription(tradingMode, trigger);
+
+  return (
+    <div>
+      <Tooltip description={tooltipDescription}>
+        <div
+          className={classNames('inline-flex whitespace-normal', {
+            'text-base': size === 'large',
+            'text-sm': size === 'small',
+          })}
+        >
+          <Lozenge className="border border-greys-light-300 bg-greys-light-100 flex items-center">
+            <Indicator status={tradingMode} />
+            {status}
+          </Lozenge>
+        </div>
+      </Tooltip>
+    </div>
+  );
+};
+
+const getTooltipDescription = (
+  status: Schema.MarketTradingMode,
+  trigger?: Schema.AuctionTrigger
+) => {
+  switch (status) {
+    case Schema.MarketTradingMode.TRADING_MODE_CONTINUOUS:
+      return t(
+        'This is the standard trading mode where trades are executed whenever orders are received'
+      );
+    case Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION:
+      return getMonitoringDescriptionTooltip(trigger);
+    case Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION:
+      return t(
+        'This is a new market in an opening auction to determine a fair mid-price before starting continuous trading.'
+      );
+    default:
+      return '';
+  }
+};
+
+const getMonitoringDescriptionTooltip = (trigger?: AuctionTrigger) => {
+  switch (trigger) {
+    case Schema.AuctionTrigger.AUCTION_TRIGGER_LIQUIDITY_TARGET_NOT_MET:
+      return t(
+        `This market is in auction until it reaches sufficient liquidity.`
+      );
+    case Schema.AuctionTrigger.AUCTION_TRIGGER_UNABLE_TO_DEPLOY_LP_ORDERS:
+      return t(
+        `This market may have sufficient liquidity but there are not enough priced limit orders in the order book, which are required to deploy liquidity commitment pegged orders.`
+      );
+    case Schema.AuctionTrigger.AUCTION_TRIGGER_PRICE:
+      return t(`This market is in auction due to high price volatility.`);
+    case Schema.AuctionTrigger.AUCTION_TRIGGER_OPENING:
+      return t(
+        `This is a new market in an opening auction to determine a fair mid-price before starting continuous trading`
+      );
+    default:
+      return '';
+  }
+};
@@ -0,0 +1,28 @@
+import * as Schema from '@vegaprotocol/types';
+import { Intent } from '@vegaprotocol/ui-toolkit';
+
+const marketTradingModeStyle = {
+  [Schema.MarketTradingMode.TRADING_MODE_CONTINUOUS]: '#00D46E',
+  [Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION]: '#CF0064',
+  [Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION]: '#0046CD',
+  [Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION]: '#CF0064',
+  [Schema.MarketTradingMode.TRADING_MODE_NO_TRADING]: '#CF0064',
+  [Schema.MarketTradingMode.TRADING_MODE_SUSPENDED_VIA_GOVERNANCE]: '#CF0064',
+};
+
+export const getColorForStatus = (status: Schema.MarketTradingMode) =>
+  marketTradingModeStyle[status];
+
+const marketTradingModeIntent = {
+  [Schema.MarketTradingMode.TRADING_MODE_CONTINUOUS]: Intent.Success,
+  [Schema.MarketTradingMode.TRADING_MODE_MONITORING_AUCTION]: Intent.Danger,
+  [Schema.MarketTradingMode.TRADING_MODE_OPENING_AUCTION]: Intent.Primary,
+  [Schema.MarketTradingMode.TRADING_MODE_BATCH_AUCTION]: Intent.Danger,
+  [Schema.MarketTradingMode.TRADING_MODE_NO_TRADING]: Intent.Danger,
+  [Schema.MarketTradingMode.TRADING_MODE_SUSPENDED_VIA_GOVERNANCE]:
+    Intent.Danger,
+};
+
+export const intentForStatus = (status: Schema.MarketTradingMode) => {
+  return marketTradingModeIntent[status];
+};
@@ -0,0 +1 @@
+export * from './router-config';
@@ -0,0 +1,25 @@
+import { t } from '@vegaprotocol/i18n';
+
+import { Dashboard } from '../components/dashboard';
+import { Detail } from '../components/detail';
+
+export const ROUTES = {
+  MARKETS: 'markets',
+};
+
+export const routerConfig = [
+  { path: '/', element: <Dashboard />, icon: '' },
+  {
+    path: ROUTES.MARKETS,
+    name: 'Markets',
+    text: t('Markets'),
+    children: [
+      {
+        path: ':marketId',
+        element: <Detail />,
+      },
+    ],
+    icon: 'trade',
+    isNavItem: true,
+  },
+];
@@ -0,0 +1,3 @@
+export const environment = {
+  production: true,
+};
@@ -0,0 +1,6 @@
+// This file can be replaced during build by using the `fileReplacements` array.
+// When building for production, this file is replaced with `environment.prod.ts`.
+
+export const environment = {
+  production: false,
+};
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Liquidity Provision Dashboard</title>
+    <base href="/" />
+
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="icon" type="image/x-icon" href="favicon.ico" />
+    <link
+      rel="preload"
+      href="https://static.vega.xyz/AlphaLyrae-Medium.woff2"
+      as="font"
+      type="font/woff2"
+      crossorigin="anonymous"
+    />
+
+    <link rel="stylesheet" href="https://static.vega.xyz/fonts.css" />
+  </head>
+  <body>
+    <div id="root" class="h-full max-h-full min-h-full"></div>
+  </body>
+</html>
@@ -0,0 +1,15 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { BrowserRouter } from 'react-router-dom';
+
+import App from './app/app';
+
+const rootElement = document.getElementById('root');
+const root = rootElement && createRoot(rootElement);
+root?.render(
+  <StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </StrictMode>
+);
@@ -0,0 +1,7 @@
+/**
+ * Polyfill stable language features. These imports will be optimized by `@babel/preset-env`.
+ *
+ * See: https://github.com/zloirock/core-js#babel
+ */
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
@@ -0,0 +1,10 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+html,
+body {
+  @apply h-full;
+
+  font-family: 'Helvetica Neue', Helvetica, sans-serif;
+}
@@ -0,0 +1,29 @@
+const { join } = require('path');
+const { createGlobPatternsForDependencies } = require('@nx/react/tailwind');
+const theme = require('../../libs/tailwindcss-config/src/theme-lite');
+const vegaCustomClasses = require('../../libs/tailwindcss-config/src/vega-custom-classes');
+const vegaCustomClassesLite = require('../../libs/tailwindcss-config/src/vega-custom-classes-lite');
+
+module.exports = {
+  content: [
+    join(__dirname, 'src/**/*.{js,ts,jsx,tsx}'),
+    'libs/ui-toolkit/src/utils/shared.ts',
+    ...createGlobPatternsForDependencies(__dirname),
+  ],
+  darkMode: 'class',
+  theme: {
+    ...theme,
+    colors: {
+      ...theme.colors,
+      greys: {
+        light: {
+          100: '#F0F0F0',
+          200: '#D2D2D2',
+          300: '#A7A7A7',
+          400: '#626262',
+        },
+      },
+    },
+  },
+  plugins: [vegaCustomClasses, vegaCustomClassesLite],
+};
@@ -0,0 +1,27 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "node",
+      "@nx/react/typings/cssmodule.d.ts",
+      "@nx/react/typings/image.d.ts"
+    ]
+  },
+  "files": [
+    "../../node_modules/@nx/react/typings/cssmodule.d.ts",
+    "../../node_modules/@nx/react/typings/image.d.ts"
+  ],
+  "exclude": [
+    "jest.config.ts",
+    "**/*.spec.ts",
+    "**/*.test.ts",
+    "**/*.spec.tsx",
+    "**/*.test.tsx",
+    "**/*.spec.js",
+    "**/*.test.js",
+    "**/*.spec.jsx",
+    "**/*.test.jsx"
+  ],
+  "include": ["**/*.js", "**/*.jsx", "**/*.ts", "**/*.tsx"]
+}
@@ -0,0 +1,24 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}
@@ -0,0 +1,33 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": [
+      "jest",
+      "node",
+      "@testing-library/jest-dom",
+      "@nx/react/typings/cssmodule.d.ts",
+      "@nx/react/typings/image.d.ts"
+    ],
+    "jsx": "react",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true
+  },
+  "include": [
+    "jest.config.ts",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/*.test.tsx",
+    "**/*.spec.tsx",
+    "**/*.test.js",
+    "**/*.spec.js",
+    "**/*.test.jsx",
+    "**/*.spec.jsx",
+    "**/*.d.ts"
+  ],
+  "files": [
+    "../../node_modules/@nx/react/typings/cssmodule.d.ts",
+    "../../node_modules/@nx/react/typings/image.d.ts"
+  ]
+}
@@ -30,6 +30,8 @@ export const ChartContainer = ({ marketId }: { marketId: string }) => {
    setStudies,
    setStudySizes,
    setOverlays,
+    state,
+    setState,
  } = useChartSettings();

  const pennantChart = (
@@ -66,6 +68,10 @@ export const ChartContainer = ({ marketId }: { marketId: string }) => {
          onIntervalChange={(newInterval) => {
            setInterval(fromTradingViewResolution(newInterval));
          }}
+          onAutoSaveNeeded={(data) => {
+            setState(data);
+          }}
+          state={state}
        />
      );
    }
@@ -6,12 +6,7 @@ export const SUPPORTED_INTERVALS = [
  Interval.INTERVAL_I1M,
  Interval.INTERVAL_I5M,
  Interval.INTERVAL_I15M,
-  Interval.INTERVAL_I30M,
  Interval.INTERVAL_I1H,
-  Interval.INTERVAL_I4H,
  Interval.INTERVAL_I6H,
-  Interval.INTERVAL_I8H,
-  Interval.INTERVAL_I12H,
  Interval.INTERVAL_I1D,
-  Interval.INTERVAL_I7D,
 ] as const;
@@ -9,6 +9,7 @@ type StudySizes = { [S in Study]?: number };
 export type Chartlib = 'pennant' | 'tradingview';

 interface StoredSettings {
+  state: object | undefined; // Don't see a better type provided from TradingView type definitions
  chartlib: Chartlib;
  // For interval we use the enum from @vegaprotocol/types, this is to make mapping between different
  // chart types easier and more consistent
@@ -29,6 +30,7 @@ const STUDY_ORDER: Study[] = [
 ];

 export const DEFAULT_CHART_SETTINGS = {
+  state: undefined,
  chartlib: 'pennant' as const,
  interval: Interval.INTERVAL_I15M,
  type: ChartType.CANDLE,
@@ -45,6 +47,7 @@ export const useChartSettingsStore = create<
    setStudies: (studies?: Study[]) => void;
    setStudySizes: (sizes: number[]) => void;
    setChartlib: (lib: Chartlib) => void;
+    setState: (state: object) => void;
  }
 >()(
  persist(
@@ -92,6 +95,9 @@ export const useChartSettingsStore = create<
          state.chartlib = lib;
        });
      },
+      setState: (state) => {
+        set({ state });
+      },
    })),
    {
      name: 'vega_candles_chart_store',
@@ -145,5 +151,7 @@ export const useChartSettings = () => {
    setOverlays: settings.setOverlays,
    setStudySizes: settings.setStudySizes,
    setChartlib: settings.setChartlib,
+    state: settings.state,
+    setState: settings.setState,
  };
 };
@@ -1 +0,0 @@
-export { ProfileDialog } from './profile-dialog';
@@ -1,150 +0,0 @@
-import {
-  Dialog,
-  FormGroup,
-  Input,
-  InputError,
-  Intent,
-  TradingButton,
-} from '@vegaprotocol/ui-toolkit';
-import { useProfileDialogStore } from '../../stores/profile-dialog-store';
-import { useForm } from 'react-hook-form';
-import { useT } from '../../lib/use-t';
-import { useRequired } from '@vegaprotocol/utils';
-import {
-  useSimpleTransaction,
-  type Status,
-  useVegaWallet,
-} from '@vegaprotocol/wallet-react';
-import {
-  usePartyProfilesQuery,
-  type PartyProfilesQuery,
-} from '../vega-wallet-connect-button/__generated__/PartyProfiles';
-
-export const ProfileDialog = () => {
-  const t = useT();
-  const { pubKeys } = useVegaWallet();
-  const { data, refetch } = usePartyProfilesQuery({
-    variables: { partyIds: pubKeys.map((pk) => pk.publicKey) },
-    skip: pubKeys.length <= 0,
-  });
-  const open = useProfileDialogStore((store) => store.open);
-  const pubKey = useProfileDialogStore((store) => store.pubKey);
-  const setOpen = useProfileDialogStore((store) => store.setOpen);
-
-  const { send, status, error, reset } = useSimpleTransaction({
-    onSuccess: () => {
-      refetch();
-    },
-  });
-
-  const profileEdge = data?.partiesProfilesConnection?.edges.find(
-    (e) => e.node.partyId === pubKey
-  );
-
-  const sendTx = (field: FormFields) => {
-    send({
-      updatePartyProfile: {
-        alias: field.alias,
-        metadata: [],
-      },
-    });
-  };
-
-  return (
-    <Dialog
-      open={open}
-      onChange={() => {
-        setOpen(undefined);
-        reset();
-      }}
-      title={t('Edit profile')}
-    >
-      <ProfileForm
-        profile={profileEdge?.node}
-        status={status}
-        error={error}
-        onSubmit={sendTx}
-      />
-    </Dialog>
-  );
-};
-
-interface FormFields {
-  alias: string;
-}
-
-type Profile = NonNullable<
-  PartyProfilesQuery['partiesProfilesConnection']
->['edges'][number]['node'];
-
-const ProfileForm = ({
-  profile,
-  onSubmit,
-  status,
-  error,
-}: {
-  profile: Profile | undefined;
-  onSubmit: (fields: FormFields) => void;
-  status: Status;
-  error: string | undefined;
-}) => {
-  const t = useT();
-  const required = useRequired();
-  const {
-    register,
-    handleSubmit,
-    formState: { errors },
-  } = useForm<FormFields>({
-    defaultValues: {
-      alias: profile?.alias,
-    },
-  });
-
-  const renderButtonText = () => {
-    if (status === 'requested') {
-      return t('Confirm in wallet...');
-    }
-
-    if (status === 'pending') {
-      return t('Confirming transaction...');
-    }
-
-    return t('Submit');
-  };
-
-  const errorMessage = errors.alias?.message || error;
-
-  return (
-    <form onSubmit={handleSubmit(onSubmit)} className="mt-3">
-      <FormGroup label="Alias" labelFor="alias">
-        <Input
-          {...register('alias', {
-            validate: {
-              required,
-            },
-          })}
-        />
-        {errorMessage && (
-          <InputError>
-            <p className="break-words max-w-full first-letter:uppercase">
-              {errorMessage}
-            </p>
-          </InputError>
-        )}
-
-        {status === 'confirmed' && (
-          <p className="mt-2 mb-4 text-sm text-success">
-            {t('Profile updated')}
-          </p>
-        )}
-      </FormGroup>
-      <TradingButton
-        type="submit"
-        intent={Intent.Info}
-        disabled={status === 'requested' || status === 'pending'}
-      >
-        {renderButtonText()}
-      </TradingButton>
-    </form>
-  );
-};
@@ -1,14 +0,0 @@
-query PartyProfiles($partyIds: [ID!]) {
-  partiesProfilesConnection(ids: $partyIds) {
-    edges {
-      node {
-        partyId
-        alias
-        metadata {
-          key
-          value
-        }
-      }
-    }
-  }
-}
@@ -1,57 +0,0 @@
-import * as Types from '@vegaprotocol/types';
-
-import { gql } from '@apollo/client';
-import * as Apollo from '@apollo/client';
-const defaultOptions = {} as const;
-export type PartyProfilesQueryVariables = Types.Exact<{
-  partyIds?: Types.InputMaybe<Array<Types.Scalars['ID']> | Types.Scalars['ID']>;
-}>;
-
-
-export type PartyProfilesQuery = { __typename?: 'Query', partiesProfilesConnection?: { __typename?: 'PartiesProfilesConnection', edges: Array<{ __typename?: 'PartyProfileEdge', node: { __typename?: 'PartyProfile', partyId: string, alias: string, metadata: Array<{ __typename?: 'Metadata', key: string, value: string }> } }> } | null };
-
-
-export const PartyProfilesDocument = gql`
-    query PartyProfiles($partyIds: [ID!]) {
-  partiesProfilesConnection(ids: $partyIds) {
-    edges {
-      node {
-        partyId
-        alias
-        metadata {
-          key
-          value
-        }
-      }
-    }
-  }
-}
-    `;
-
-/**
- * __usePartyProfilesQuery__
- *
- * To run a query within a React component, call `usePartyProfilesQuery` and pass it any options that fit your needs.
- * When your component renders, `usePartyProfilesQuery` returns an object from Apollo Client that contains loading, error, and data properties
- * you can use to render your UI.
- *
- * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
- *
- * @example
- * const { data, loading, error } = usePartyProfilesQuery({
- *   variables: {
- *      partyIds: // value for 'partyIds'
- *   },
- * });
- */
-export function usePartyProfilesQuery(baseOptions?: Apollo.QueryHookOptions<PartyProfilesQuery, PartyProfilesQueryVariables>) {
-        const options = {...defaultOptions, ...baseOptions}
-        return Apollo.useQuery<PartyProfilesQuery, PartyProfilesQueryVariables>(PartyProfilesDocument, options);
-      }
-export function usePartyProfilesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PartyProfilesQuery, PartyProfilesQueryVariables>) {
-          const options = {...defaultOptions, ...baseOptions}
-          return Apollo.useLazyQuery<PartyProfilesQuery, PartyProfilesQueryVariables>(PartyProfilesDocument, options);
-        }
-export type PartyProfilesQueryHookResult = ReturnType<typeof usePartyProfilesQuery>;
-export type PartyProfilesLazyQueryHookResult = ReturnType<typeof usePartyProfilesLazyQuery>;
-export type PartyProfilesQueryResult = Apollo.QueryResult<PartyProfilesQuery, PartyProfilesQueryVariables>;
@@ -1,57 +1,21 @@
-import { act, fireEvent, render, screen, within } from '@testing-library/react';
+import { act, fireEvent, render, screen } from '@testing-library/react';
 import { VegaWalletConnectButton } from './vega-wallet-connect-button';
+import { truncateByChars } from '@vegaprotocol/utils';
 import userEvent from '@testing-library/user-event';
 import {
  mockConfig,
  MockedWalletProvider,
 } from '@vegaprotocol/wallet-react/testing';
-import { MockedProvider, type MockedResponse } from '@apollo/react-testing';
-import {
-  PartyProfilesDocument,
-  type PartyProfilesQuery,
-} from './__generated__/PartyProfiles';

 jest.mock('../../lib/hooks/use-get-current-route-id', () => ({
  useGetCurrentRouteId: jest.fn().mockReturnValue('current-route-id'),
 }));

-const key = { publicKey: '123456__123456', name: 'test' };
-const key2 = { publicKey: 'abcdef__abcdef', name: 'test2' };
-const keys = [key, key2];
-const keyProfile = {
-  __typename: 'PartyProfile' as const,
-  partyId: key.publicKey,
-  alias: `${key.name} alias`,
-  metadata: [],
-};
-
 const renderComponent = (mockOnClick = jest.fn()) => {
-  const partyProfilesMock: MockedResponse<PartyProfilesQuery> = {
-    request: {
-      query: PartyProfilesDocument,
-      variables: { partyIds: keys.map((k) => k.publicKey) },
-    },
-    result: {
-      data: {
-        partiesProfilesConnection: {
-          __typename: 'PartiesProfilesConnection',
-          edges: [
-            {
-              __typename: 'PartyProfileEdge',
-              node: keyProfile,
-            },
-          ],
-        },
-      },
-    },
-  };
-
  return (
-    <MockedProvider mocks={[partyProfilesMock]}>
-      <MockedWalletProvider>
-        <VegaWalletConnectButton onClick={mockOnClick} />
-      </MockedWalletProvider>
-    </MockedProvider>
+    <MockedWalletProvider>
+      <VegaWalletConnectButton onClick={mockOnClick} />
+    </MockedWalletProvider>
  );
 };

@@ -79,6 +43,10 @@ describe('VegaWalletConnectButton', () => {
  });

  it('should open dropdown and refresh keys when connected', async () => {
+    const key = { publicKey: '123456__123456', name: 'test' };
+    const key2 = { publicKey: 'abcdef__abcdef', name: 'test2' };
+    const keys = [key, key2];
+
    mockConfig.store.setState({
      status: 'connected',
      keys,
@@ -93,22 +61,14 @@ describe('VegaWalletConnectButton', () => {

    expect(screen.queryByTestId('connect-vega-wallet')).not.toBeInTheDocument();
    const button = screen.getByTestId('manage-vega-wallet');
-    expect(button).toHaveTextContent(key.name);
+    expect(button).toHaveTextContent(truncateByChars(key.publicKey));

    fireEvent.click(button);

    expect(await screen.findByRole('menu')).toBeInTheDocument();
-    const menuItems = await screen.findAllByRole('menuitemradio');
-    expect(menuItems).toHaveLength(keys.length);
-
-    expect(within(menuItems[0]).getByTestId('alias')).toHaveTextContent(
-      keyProfile.alias
+    expect(await screen.findAllByRole('menuitemradio')).toHaveLength(
+      keys.length
    );
-
-    expect(within(menuItems[1]).getByTestId('alias')).toHaveTextContent(
-      'No alias'
-    );
-
    expect(refreshKeys).toHaveBeenCalled();

    fireEvent.click(screen.getByTestId(`key-${key2.publicKey}`));
@@ -14,7 +14,6 @@ import {
  TradingDropdownItem,
  TradingDropdownRadioItem,
  TradingDropdownItemIndicator,
-  Tooltip,
 } from '@vegaprotocol/ui-toolkit';
 import { isBrowserWalletInstalled, type Key } from '@vegaprotocol/wallet';
 import { useDialogStore, useVegaWallet } from '@vegaprotocol/wallet-react';
@@ -23,8 +22,6 @@ import classNames from 'classnames';
 import { ViewType, useSidebar } from '../sidebar';
 import { useGetCurrentRouteId } from '../../lib/hooks/use-get-current-route-id';
 import { useT } from '../../lib/use-t';
-import { usePartyProfilesQuery } from './__generated__/PartyProfiles';
-import { useProfileDialogStore } from '../../stores/profile-dialog-store';

 export const VegaWalletConnectButton = ({
  intent = Intent.None,
@@ -71,10 +68,10 @@ export const VegaWalletConnectButton = ({
              {activeKey ? (
                <>
                  {activeKey && (
-                    <span className="uppercase">
-                      {activeKey.name ? activeKey.name : t('Unnamed key')}
-                    </span>
+                    <span className="uppercase">{activeKey.name}</span>
                  )}
+                  {' | '}
+                  {truncateByChars(activeKey.publicKey)}
                </>
              ) : (
                <>{'Select key'}</>
@@ -91,11 +88,20 @@ export const VegaWalletConnectButton = ({
          onEscapeKeyDown={() => setDropdownOpen(false)}
        >
          <div className="min-w-[340px]" data-testid="keypair-list">
-            <KeypairRadioGroup
-              pubKey={pubKey}
-              pubKeys={pubKeys}
-              onSelect={selectPubKey}
-            />
+            <TradingDropdownRadioGroup
+              value={pubKey || undefined}
+              onValueChange={(value) => {
+                selectPubKey(value);
+              }}
+            >
+              {pubKeys.map((pk) => (
+                <KeypairItem
+                  key={pk.publicKey}
+                  pk={pk}
+                  active={pk.publicKey === pubKey}
+                />
+              ))}
+            </TradingDropdownRadioGroup>
            <TradingDropdownSeparator />
            {!isReadOnly && (
              <TradingDropdownItem
@@ -135,52 +141,28 @@ export const VegaWalletConnectButton = ({
  );
 };

-const KeypairRadioGroup = ({
-  pubKey,
-  pubKeys,
-  onSelect,
-}: {
-  pubKey: string | undefined;
-  pubKeys: Key[];
-  onSelect: (pubKey: string) => void;
-}) => {
-  const { data } = usePartyProfilesQuery({
-    variables: { partyIds: pubKeys.map((pk) => pk.publicKey) },
-    skip: pubKeys.length <= 0,
-  });
-
-  return (
-    <TradingDropdownRadioGroup value={pubKey} onValueChange={onSelect}>
-      {pubKeys.map((pk) => {
-        const profile = data?.partiesProfilesConnection?.edges.find(
-          (e) => e.node.partyId === pk.publicKey
-        );
-        return (
-          <KeypairItem key={pk.publicKey} pk={pk} alias={profile?.node.alias} />
-        );
-      })}
-    </TradingDropdownRadioGroup>
-  );
-};
-
-const KeypairItem = ({ pk, alias }: { pk: Key; alias: string | undefined }) => {
+const KeypairItem = ({ pk, active }: { pk: Key; active: boolean }) => {
  const t = useT();
  const [copied, setCopied] = useCopyTimeout();
-  const setOpen = useProfileDialogStore((store) => store.setOpen);

  return (
    <TradingDropdownRadioItem value={pk.publicKey}>
-      <div>
-        <div className="flex items-center gap-2">
-          <span>{pk.name ? pk.name : t('Unnamed key')}</span>
+      <div
+        className={classNames('flex-1 mr-2', {
+          'text-default': active,
+          'text-muted': !active,
+        })}
+        data-testid={`key-${pk.publicKey}`}
+      >
+        <span className={classNames('mr-2 uppercase')}>
+          {pk.name}
          {' | '}
-          <span className="font-mono">
-            {truncateByChars(pk.publicKey, 3, 3)}
-          </span>
+          {truncateByChars(pk.publicKey)}
+        </span>
+        <span className="inline-flex items-center gap-1">
          <CopyToClipboard text={pk.publicKey} onCopy={() => setCopied(true)}>
            <button
              data-testid="copy-vega-public-key"
-              className="relative -top-px"
              onClick={(e) => e.stopPropagation()}
            >
              <span className="sr-only">{t('Copy')}</span>
@@ -188,17 +170,7 @@ const KeypairItem = ({ pk, alias }: { pk: Key; alias: string | undefined }) => {
            </button>
          </CopyToClipboard>
          {copied && <span className="text-xs">{t('Copied')}</span>}
-        </div>
-        <div
-          className={classNames('flex-1 mr-2 text-secondary text-sm')}
-          data-testid={`key-${pk.publicKey}`}
-        >
-          <Tooltip description={t('Public facing key alias. Click to edit')}>
-            <button data-testid="alias" onClick={() => setOpen(pk.publicKey)}>
-              {alias ? alias : t('No alias')}
-            </button>
-          </Tooltip>
-        </div>
+        </span>
      </div>
      <TradingDropdownItemIndicator />
    </TradingDropdownRadioItem>
@@ -50,6 +50,8 @@ def truncate_middle(market_id, start=6, end=4):
 def change_keys(page: Page, vega: VegaServiceNull, key_name):
    page.get_by_test_id("manage-vega-wallet").click()
    page.get_by_test_id("key-" + vega.wallet.public_key(key_name)).click()
+    page.click(
+        f'data-testid=key-{vega.wallet.public_key(key_name)} >> .inline-flex')
    page.reload()


@@ -339,3 +339,4 @@ def retry_on_http_error(request):
                print(f"Retrying due to HTTPError (attempt {i+1}/{retry_count})")
            else:
                raise
+
@@ -18,7 +18,7 @@ expire = "expire"
@pytest.fixture(scope="module")
 def vega(request):
    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
+        request.addfinalizer(lambda: cleanup_container(vega_instance))  # Register the cleanup function
        yield vega_instance


@@ -261,7 +261,7 @@ class TestStopOcoValidation:
    @pytest.fixture(scope="class")
    def vega(request):
        with init_vega(request) as vega_instance:
-            request.addfinalizer(lambda: cleanup_container(vega_instance))
+            request.addfinalizer(lambda: cleanup_container(vega_instance))  # Register the cleanup function
            yield vega_instance

    @pytest.fixture(scope="class")
@@ -1,7 +1,6 @@
 import pytest
-from typing import Tuple, Generator
 from fees_test_ids import *
-from playwright.sync_api import expect, Page
+from playwright.sync_api import Page, expect
 from vega_sim.null_service import VegaServiceNull
 from actions.vega import submit_order
 from wallet_config import MM_WALLET
@@ -17,70 +16,77 @@ from fixtures.market import setup_continuous_market


@pytest.fixture(scope="module")
-def setup_environment(
-    request, browser
-) -> Generator[Tuple[VegaServiceNull, str, Page], None, None]:
+def vega(request):
    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
-        market = setup_continuous_market(vega_instance, custom_quantum=100000)
-        vega_instance.update_volume_discount_program(
-            proposal_key=MM_WALLET.name,
-            benefit_tiers=[
-                {
-                    "minimum_running_notional_taker_volume": 100,
-                    "volume_discount_factor": 0.1,
-                },
-                {
-                    "minimum_running_notional_taker_volume": 200,
-                    "volume_discount_factor": 0.2,
-                },
-            ],
-            window_length=7,
+        request.addfinalizer(
+            lambda: cleanup_container(vega_instance)
        )
-        next_epoch(vega_instance)
-
-        vega_instance.update_referral_program(
-            proposal_key=MM_WALLET.name,
-            benefit_tiers=[
-                {
-                    "minimum_running_notional_taker_volume": 100,
-                    "minimum_epochs": 1,
-                    "referral_reward_factor": 0.1,
-                    "referral_discount_factor": 0.1,
-                },
-                {
-                    "minimum_running_notional_taker_volume": 200,
-                    "minimum_epochs": 2,
-                    "referral_reward_factor": 0.2,
-                    "referral_discount_factor": 0.2,
-                },
-            ],
-            staking_tiers=[
-                {"minimum_staked_tokens": 100, "referral_reward_multiplier": 1.1},
-                {"minimum_staked_tokens": 200, "referral_reward_multiplier": 1.2},
-            ],
-            window_length=1,
-        )
-        vega_instance.create_referral_set(key_name=MM_WALLET.name)
-        next_epoch(vega_instance)
-        referral_set_id = list(vega_instance.list_referral_sets().keys())[0]
-        vega_instance.apply_referral_code(key_name="Key 1", id=referral_set_id)
-        next_epoch(vega_instance)
-
-        for _ in range(2):
-            submit_order(vega_instance, "Key 1", market, "SIDE_BUY", 2, 110)
-            forward_time(vega_instance, True if _ < 2 - 1 else False)
-
-        with init_page(vega_instance, browser, request) as page_instance:
-            risk_accepted_setup(page_instance)
-            auth_setup(vega_instance, page_instance)
-            yield vega_instance, market, page_instance
+        yield vega_instance


-def test_fees_page_discount_program_my_trading_fees(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        yield page
+
+
+@pytest.fixture(scope="module", autouse=True)
+def setup_combined_market(vega: VegaServiceNull):
+    market = setup_continuous_market(vega, custom_quantum=100000)
+    vega.update_volume_discount_program(
+        proposal_key=MM_WALLET.name,
+        benefit_tiers=[
+            {
+                "minimum_running_notional_taker_volume": 100,
+                "volume_discount_factor": 0.1,
+            },
+            {
+                "minimum_running_notional_taker_volume": 200,
+                "volume_discount_factor": 0.2,
+            },
+        ],
+        window_length=7,
+    )
+    next_epoch(vega=vega)
+
+    vega.update_referral_program(
+        proposal_key=MM_WALLET.name,
+        benefit_tiers=[
+            {
+                "minimum_running_notional_taker_volume": 100,
+                "minimum_epochs": 1,
+                "referral_reward_factor": 0.1,
+                "referral_discount_factor": 0.1,
+            },
+            {
+                "minimum_running_notional_taker_volume": 200,
+                "minimum_epochs": 2,
+                "referral_reward_factor": 0.2,
+                "referral_discount_factor": 0.2,
+            },
+        ],
+        staking_tiers=[
+            {"minimum_staked_tokens": 100, "referral_reward_multiplier": 1.1},
+            {"minimum_staked_tokens": 200, "referral_reward_multiplier": 1.2},
+        ],
+        window_length=1,
+    )
+    vega.create_referral_set(key_name=MM_WALLET.name)
+    next_epoch(vega=vega)
+    referral_set_id = list(vega.list_referral_sets().keys())[0]
+    vega.apply_referral_code(key_name="Key 1", id=referral_set_id)
+    next_epoch(vega=vega)
+
+    for _ in range(2):
+        submit_order(vega, "Key 1", market, "SIDE_BUY", 2, 110)
+        forward_time(vega, True if _ < 2 - 1 else False)
+    return market
+
+
+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
+def test_fees_page_discount_program_my_trading_fees(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(ADJUSTED_FEES)).to_have_text("6.432%-6.432%")
    expect(page.get_by_test_id(TOTAL_FEE_BEFORE_DISCOUNT)).to_have_text(
@@ -91,10 +97,10 @@ def test_fees_page_discount_program_my_trading_fees(
    expect(page.get_by_test_id(LIQUIDITY_FEES)).to_have_text("Liquidity0%-0%")


+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
 def test_fees_page_discount_program_total_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+    page: Page,
+):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TOTAL_DISCOUNT)).to_have_text("36%")
    expect(page.get_by_test_id(VOLUME_DISCOUNT_ROW)).to_have_text("Volume discount20%")
@@ -107,10 +113,8 @@ def test_fees_page_discount_program_total_discount(
    )


-def test_fees_page_discount_program_fees_by_market(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
+def test_fees_page_discount_program_fees_by_market(page: Page):
    page.goto("/#/fees")
    pinned = page.locator(PINNED_ROW_LOCATOR)
    row = page.locator(ROW_LOCATOR)
@@ -122,11 +126,12 @@ def test_fees_page_discount_program_fees_by_market(
    expect(row.locator(COL_TOTAL_FEE)).to_have_text("10.05%")


+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
 def test_deal_ticket_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_combined_market,
+):
+    page.goto(f"/#/markets/{setup_combined_market}")
    page.get_by_test_id(ORDER_SIZE).fill("1")
    page.get_by_test_id(ORDER_PRICE).fill("1")
    expect(page.get_by_test_id(DISCOUNT_PILL)).to_have_text("-36%")
@@ -145,9 +150,12 @@ def test_deal_ticket_discount_program(
    expect(tooltip.get_by_test_id(TOTAL_FEE_VALUE)).to_have_text("0.06432 tDAI")


-def test_fills_taker_discount_program(setup_environment):
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
+def test_fills_taker_discount_program(
+    page: Page,
+    setup_combined_market,
+):
+    page.goto(f"/#/markets/{setup_combined_market}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    expect(row.locator(COL_SIZE)).to_have_text("+2")
@@ -158,11 +166,13 @@ def test_fills_taker_discount_program(setup_environment):
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("7.48926 tDAI")


+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
 def test_fills_maker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull,
+    page: Page,
+    setup_combined_market,
+):
+    page.goto(f"/#/markets/{setup_combined_market}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -174,11 +184,11 @@ def test_fills_maker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("7.452 tDAI")


+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
 def test_fills_maker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull, page: Page, setup_combined_market
+):
+    page.goto(f"/#/markets/{setup_combined_market}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -190,11 +200,12 @@ def test_fills_maker_fee_tooltip_discount_program(
    )


+@pytest.mark.xdist_group(name="test_fees_combo_tier_2")
 def test_fills_taker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_combined_market,
+):
+    page.goto(f"/#/markets/{setup_combined_market}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    # tbd - tooltip is not visible without this wait
@@ -1,5 +1,4 @@
 import pytest
-from typing import Tuple, Generator
 from fees_test_ids import *
 from playwright.sync_api import Page, expect
 from vega_sim.null_service import VegaServiceNull
@@ -15,58 +14,63 @@ from conftest import (
 from actions.utils import next_epoch, change_keys, forward_time
 from fixtures.market import setup_continuous_market

+@pytest.fixture(scope="module")
+def vega(request):
+    with init_vega(request) as vega_instance:
+        request.addfinalizer(
+            lambda: cleanup_container(vega_instance)
+        )
+        yield vega_instance
+

@pytest.fixture(scope="module")
-def setup_environment(
-    request, browser
-) -> Generator[Tuple[VegaServiceNull, str, Page], None, None]:
-    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        # Setup the market with the referral discount program
-        market = setup_continuous_market(vega_instance, custom_quantum=100000)
-        vega_instance.update_referral_program(
-            proposal_key=MM_WALLET.name,
-            benefit_tiers=[
-                {
-                    "minimum_running_notional_taker_volume": 100,
-                    "minimum_epochs": 1,
-                    "referral_reward_factor": 0.1,
-                    "referral_discount_factor": 0.1,
-                },
-                {
-                    "minimum_running_notional_taker_volume": 200,
-                    "minimum_epochs": 2,
-                    "referral_reward_factor": 0.2,
-                    "referral_discount_factor": 0.2,
-                },
-            ],
-            staking_tiers=[
-                {"minimum_staked_tokens": 100, "referral_reward_multiplier": 1.1},
-                {"minimum_staked_tokens": 200, "referral_reward_multiplier": 1.2},
-            ],
-            window_length=1,
-        )
-        vega_instance.create_referral_set(key_name=MM_WALLET.name)
-        next_epoch(vega_instance)
-        referral_set_id = list(vega_instance.list_referral_sets().keys())[0]
-        vega_instance.apply_referral_code(key_name="Key 1", id=referral_set_id)
-        next_epoch(vega_instance)
-
-        for _ in range(2):
-            submit_order(vega_instance, "Key 1", market, "SIDE_BUY", 1, 110)
-            forward_time(vega_instance, True if _ < 2 - 1 else False)
-
-        with init_page(vega_instance, browser, request) as page_instance:
-            risk_accepted_setup(page_instance)
-            auth_setup(vega_instance, page_instance)
-            yield vega_instance, market, page_instance
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        yield page


-def test_fees_page_discount_program_my_trading_fees(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.fixture(scope="module", autouse=True)
+def setup_market_with_referral_discount_program(vega: VegaServiceNull):
+    market = setup_continuous_market(vega, custom_quantum=100000)
+    vega.update_referral_program(
+        proposal_key=MM_WALLET.name,
+        benefit_tiers=[
+            {
+                "minimum_running_notional_taker_volume": 100,
+                "minimum_epochs": 1,
+                "referral_reward_factor": 0.1,
+                "referral_discount_factor": 0.1,
+            },
+            {
+                "minimum_running_notional_taker_volume": 200,
+                "minimum_epochs": 2,
+                "referral_reward_factor": 0.2,
+                "referral_discount_factor": 0.2,
+            },
+        ],
+        staking_tiers=[
+            {"minimum_staked_tokens": 100, "referral_reward_multiplier": 1.1},
+            {"minimum_staked_tokens": 200, "referral_reward_multiplier": 1.2},
+        ],
+        window_length=1,
+    )
+    vega.create_referral_set(key_name=MM_WALLET.name)
+    next_epoch(vega=vega)
+    referral_set_id = list(vega.list_referral_sets().keys())[0]
+    vega.apply_referral_code(key_name="Key 1", id=referral_set_id)
+    next_epoch(vega=vega)
+
+    for _ in range(2):
+        submit_order(vega, "Key 1", market, "SIDE_BUY", 1, 110)
+        forward_time(vega, True if _ < 2 - 1 else False)
+
+    return market
+
+
+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
+def test_fees_page_discount_program_my_trading_fees(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(ADJUSTED_FEES)).to_have_text("9.045%-9.045%")
    expect(page.get_by_test_id(TOTAL_FEE_BEFORE_DISCOUNT)).to_have_text(
@@ -77,10 +81,8 @@ def test_fees_page_discount_program_my_trading_fees(
    expect(page.get_by_test_id(LIQUIDITY_FEES)).to_have_text("Liquidity0%-0%")


-def test_fees_page_discount_program_total_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
+def test_fees_page_discount_program_total_discount(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TOTAL_DISCOUNT)).to_have_text("10%")
    expect(page.get_by_test_id(VOLUME_DISCOUNT_ROW)).to_have_text("Volume discount0%")
@@ -93,19 +95,15 @@ def test_fees_page_discount_program_total_discount(
    )


-def test_fees_page_referral_discount_program_referral_benefits(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
+def test_fees_page_referral_discount_program_referral_benefits(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(RUNNING_NOTIONAL_TAKER_VOLUME)).to_have_text("103")
    expect(page.get_by_test_id(EPOCHS_IN_REFERRAL_SET)).to_have_text("1")


-def test_fees_page_discount_program_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
+def test_fees_page_discount_program_discount(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TIER_VALUE_0)).to_have_text("1")
    expect(page.get_by_test_id(TIER_VALUE_1)).to_have_text("2")
@@ -121,10 +119,8 @@ def test_fees_page_discount_program_discount(
    expect(page.get_by_test_id("your-referral-tier-0").nth(1)).to_have_text("Your tier")


-def test_fees_page_discount_program_fees_by_market(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
+def test_fees_page_discount_program_fees_by_market(page: Page):
    page.goto("/#/fees")
    pinned = page.locator(PINNED_ROW_LOCATOR)
    row = page.locator(ROW_LOCATOR)
@@ -136,11 +132,11 @@ def test_fees_page_discount_program_fees_by_market(
    expect(row.locator(COL_TOTAL_FEE)).to_have_text("10.05%")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
 def test_deal_ticket_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page, setup_market_with_referral_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    page.get_by_test_id(ORDER_SIZE).fill("1")
    page.get_by_test_id(ORDER_PRICE).fill("1")
    expect(page.get_by_test_id(DISCOUNT_PILL)).to_have_text("-10%")
@@ -159,11 +155,12 @@ def test_deal_ticket_discount_program(
    expect(tooltip.get_by_test_id(TOTAL_FEE_VALUE)).to_have_text("0.09045 tDAI")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
 def test_fills_taker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_referral_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    expect(row.locator(COL_SIZE)).to_have_text("+1")
@@ -174,11 +171,13 @@ def test_fills_taker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("1.04017 tDAI")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
 def test_fills_maker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull,
+    page: Page,
+    setup_market_with_referral_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -190,11 +189,11 @@ def test_fills_maker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("1.035 tDAI")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
 def test_fills_maker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull, page: Page, setup_market_with_referral_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -206,11 +205,12 @@ def test_fills_maker_fee_tooltip_discount_program(
    )


+@pytest.mark.xdist_group(name="test_fees_referral_tier_1")
 def test_fills_taker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_referral_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    # tbd - tooltip is not visible without this wait
@@ -1,6 +1,5 @@
 import pytest
 from fees_test_ids import *
-from typing import Tuple, Generator
 from playwright.sync_api import Page, expect
 from vega_sim.null_service import VegaServiceNull
 from actions.vega import submit_order
@@ -17,56 +16,62 @@ from fixtures.market import setup_continuous_market


@pytest.fixture(scope="module")
-def setup_environment(
-    request, browser
-) -> Generator[Tuple[VegaServiceNull, str, Page], None, None]:
+def vega(request):
    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        # Setup market with referral discount program
-        market = setup_continuous_market(vega_instance, custom_quantum=100000)
-        vega_instance.update_referral_program(
-            proposal_key=MM_WALLET.name,
-            benefit_tiers=[
-                {
-                    "minimum_running_notional_taker_volume": 100,
-                    "minimum_epochs": 1,
-                    "referral_reward_factor": 0.1,
-                    "referral_discount_factor": 0.1,
-                },
-                {
-                    "minimum_running_notional_taker_volume": 200,
-                    "minimum_epochs": 2,
-                    "referral_reward_factor": 0.2,
-                    "referral_discount_factor": 0.2,
-                },
-            ],
-            staking_tiers=[
-                {"minimum_staked_tokens": 100, "referral_reward_multiplier": 1.1},
-                {"minimum_staked_tokens": 200, "referral_reward_multiplier": 1.2},
-            ],
-            window_length=1,
+        request.addfinalizer(
+            lambda: cleanup_container(vega_instance)
        )
-        vega_instance.create_referral_set(key_name=MM_WALLET.name)
-        next_epoch(vega_instance)
-        referral_set_id = list(vega_instance.list_referral_sets().keys())[0]
-        vega_instance.apply_referral_code(key_name="Key 1", id=referral_set_id)
-        next_epoch(vega_instance)
-
-        for _ in range(2):
-            submit_order(vega_instance, "Key 1", market, "SIDE_BUY", 2, 110)
-            forward_time(vega_instance, True if _ < 2 - 1 else False)
-
-        with init_page(vega_instance, browser, request) as page_instance:
-            risk_accepted_setup(page_instance)
-            auth_setup(vega_instance, page_instance)
-            yield vega_instance, market, page_instance
+        yield vega_instance


-def test_fees_page_discount_program_my_trading_fees(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        yield page
+
+
+@pytest.fixture(scope="module", autouse=True)
+def setup_market_with_referral_discount_program(vega: VegaServiceNull):
+    market = setup_continuous_market(vega, custom_quantum=100000)
+    vega.update_referral_program(
+        proposal_key=MM_WALLET.name,
+        benefit_tiers=[
+            {
+                "minimum_running_notional_taker_volume": 100,
+                "minimum_epochs": 1,
+                "referral_reward_factor": 0.1,
+                "referral_discount_factor": 0.1,
+            },
+            {
+                "minimum_running_notional_taker_volume": 200,
+                "minimum_epochs": 2,
+                "referral_reward_factor": 0.2,
+                "referral_discount_factor": 0.2,
+            },
+        ],
+        staking_tiers=[
+            {"minimum_staked_tokens": 100, "referral_reward_multiplier": 1.1},
+            {"minimum_staked_tokens": 200, "referral_reward_multiplier": 1.2},
+        ],
+        window_length=1,
+    )
+    vega.create_referral_set(key_name=MM_WALLET.name)
+    next_epoch(vega=vega)
+    referral_set_id = list(vega.list_referral_sets().keys())[0]
+    vega.apply_referral_code(key_name="Key 1", id=referral_set_id)
+    next_epoch(vega=vega)
+
+    for _ in range(2):
+        submit_order(vega, "Key 1", market, "SIDE_BUY", 2, 110)
+        forward_time(vega, True if _ < 2 - 1 else False)
+
+    return market
+
+
+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
+def test_fees_page_discount_program_my_trading_fees(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(ADJUSTED_FEES)).to_have_text("8.04%-8.04%")
    expect(page.get_by_test_id(TOTAL_FEE_BEFORE_DISCOUNT)).to_have_text(
@@ -77,10 +82,8 @@ def test_fees_page_discount_program_my_trading_fees(
    expect(page.get_by_test_id(LIQUIDITY_FEES)).to_have_text("Liquidity0%-0%")


-def test_fees_page_discount_program_total_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
+def test_fees_page_discount_program_total_discount(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TOTAL_DISCOUNT)).to_have_text("20%")
    expect(page.get_by_test_id(VOLUME_DISCOUNT_ROW)).to_have_text("Volume discount0%")
@@ -93,19 +96,15 @@ def test_fees_page_discount_program_total_discount(
    )


-def test_fees_page_referral_discount_program_referral_benefits(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
+def test_fees_page_referral_discount_program_referral_benefits(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(RUNNING_NOTIONAL_TAKER_VOLUME)).to_have_text("207")
    expect(page.get_by_test_id(REQUIRED_FOR_NEXT_TIER)).not_to_be_visible()


-def test_fees_page_discount_program_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
+def test_fees_page_discount_program_discount(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TIER_VALUE_0)).to_have_text("1")
    expect(page.get_by_test_id(TIER_VALUE_1)).to_have_text("2")
@@ -121,10 +120,8 @@ def test_fees_page_discount_program_discount(
    expect(page.get_by_test_id("your-referral-tier-1").nth(1)).to_have_text("Your tier")


-def test_fees_page_discount_program_fees_by_market(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
+def test_fees_page_discount_program_fees_by_market(page: Page):
    page.goto("/#/fees")
    pinned = page.locator(PINNED_ROW_LOCATOR)
    row = page.locator(ROW_LOCATOR)
@@ -136,11 +133,11 @@ def test_fees_page_discount_program_fees_by_market(
    expect(row.locator(COL_TOTAL_FEE)).to_have_text("10.05%")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
 def test_deal_ticket_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page, setup_market_with_referral_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    page.get_by_test_id(ORDER_SIZE).fill("1")
    page.get_by_test_id(ORDER_PRICE).fill("1")
    expect(page.get_by_test_id(DISCOUNT_PILL)).to_have_text("-20%")
@@ -159,11 +156,12 @@ def test_deal_ticket_discount_program(
    expect(tooltip.get_by_test_id(TOTAL_FEE_VALUE)).to_have_text("0.0804 tDAI")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
 def test_fills_taker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_referral_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    expect(row.locator(COL_SIZE)).to_have_text("+2")
@@ -174,11 +172,13 @@ def test_fills_taker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("4.1607 tDAI")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
 def test_fills_maker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull,
+    page: Page,
+    setup_market_with_referral_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -190,11 +190,11 @@ def test_fills_maker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("4.14 tDAI")


+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
 def test_fills_maker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull, page: Page, setup_market_with_referral_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -206,11 +206,12 @@ def test_fills_maker_fee_tooltip_discount_program(
    )


+@pytest.mark.xdist_group(name="test_fees_referral_tier_2")
 def test_fills_taker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_referral_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_referral_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    # tbd - tooltip is not visible without this wait
@@ -1,6 +1,5 @@
 import pytest
 from fees_test_ids import *
-from typing import Tuple, Generator
 from playwright.sync_api import Page, expect
 from vega_sim.null_service import VegaServiceNull
 from actions.vega import submit_order
@@ -17,45 +16,49 @@ from fixtures.market import setup_continuous_market


@pytest.fixture(scope="module")
-def setup_environment(
-    request, browser
-) -> Generator[Tuple[VegaServiceNull, str, Page], None, None]:
+def vega(request):
    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        # Setup the market with volume discount program
-        market = setup_continuous_market(vega_instance, custom_quantum=100000)
-        vega_instance.update_volume_discount_program(
-            proposal_key=MM_WALLET.name,
-            benefit_tiers=[
-                {
-                    "minimum_running_notional_taker_volume": 100,
-                    "volume_discount_factor": 0.1,
-                },
-                {
-                    "minimum_running_notional_taker_volume": 200,
-                    "volume_discount_factor": 0.2,
-                },
-            ],
-            window_length=7,
+        request.addfinalizer(
+            lambda: cleanup_container(vega_instance)
        )
-        next_epoch(vega=vega_instance)
-
-        for _ in range(2):
-            submit_order(vega_instance, "Key 1", market, "SIDE_BUY", 1, 110)
-            forward_time(vega_instance, True if _ < 2 - 1 else False)
-
-        # Initialize and setup page
-        with init_page(vega_instance, browser, request) as page:
-            risk_accepted_setup(page)
-            auth_setup(vega_instance, page)
-            yield vega_instance, market, page
+        yield vega_instance


-def test_fees_page_discount_program_my_trading_fees(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        yield page
+
+
+@pytest.fixture(scope="module", autouse=True)
+def setup_market_with_volume_discount_program(vega: VegaServiceNull):
+    market = setup_continuous_market(vega, custom_quantum=100000)
+    vega.update_volume_discount_program(
+        proposal_key=MM_WALLET.name,
+        benefit_tiers=[
+            {
+                "minimum_running_notional_taker_volume": 100,
+                "volume_discount_factor": 0.1,
+            },
+            {
+                "minimum_running_notional_taker_volume": 200,
+                "volume_discount_factor": 0.2,
+            },
+        ],
+        window_length=7,
+    )
+    next_epoch(vega=vega)
+
+    for _ in range(2):
+        submit_order(vega, "Key 1", market, "SIDE_BUY", 1, 110)
+        forward_time(vega, True if _ < 2 - 1 else False)
+    return market
+
+
+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
+def test_fees_page_discount_program_my_trading_fees(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(ADJUSTED_FEES)).to_have_text("9.045%-9.045%")
    expect(page.get_by_test_id(TOTAL_FEE_BEFORE_DISCOUNT)).to_have_text(
@@ -66,10 +69,10 @@ def test_fees_page_discount_program_my_trading_fees(
    expect(page.get_by_test_id(LIQUIDITY_FEES)).to_have_text("Liquidity0%-0%")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_fees_page_discount_program_total_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+    page: Page,
+):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TOTAL_DISCOUNT)).to_have_text("10%")
    expect(page.get_by_test_id(VOLUME_DISCOUNT_ROW)).to_have_text("Volume discount10%")
@@ -82,20 +85,20 @@ def test_fees_page_discount_program_total_discount(
    )


+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_fees_page_volume_discount_program_my_current_volume(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+    page: Page,
+):
    page.goto("/#/fees")
    expect(page.get_by_test_id(PAST_EPOCHS_VOLUME)).to_have_text("103")

    expect(page.get_by_test_id(REQUIRED_FOR_NEXT_TIER)).to_have_text("97")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_fees_page_discount_program_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+    page: Page,
+):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TIER_VALUE_0)).to_have_text("1")
    expect(page.get_by_test_id(TIER_VALUE_1)).to_have_text("2")
@@ -108,10 +111,8 @@ def test_fees_page_discount_program_discount(
    expect(page.get_by_test_id("your-volume-tier-0").nth(1)).to_have_text("Your tier")


-def test_fees_page_discount_program_fees_by_market(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
+def test_fees_page_discount_program_fees_by_market(page: Page):
    page.goto("/#/fees")
    pinned = page.locator(PINNED_ROW_LOCATOR)
    row = page.locator(ROW_LOCATOR)
@@ -123,11 +124,11 @@ def test_fees_page_discount_program_fees_by_market(
    expect(row.locator(COL_TOTAL_FEE)).to_have_text("10.05%")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_deal_ticket_discount_program_testing(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page, setup_market_with_volume_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    page.get_by_test_id(ORDER_SIZE).fill("1")
    page.get_by_test_id(ORDER_PRICE).fill("1")
    expect(page.get_by_test_id(DISCOUNT_PILL)).to_have_text("-10%")
@@ -148,10 +149,9 @@ def test_deal_ticket_discount_program_testing(

@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_fills_taker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page, setup_market_with_volume_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    expect(row.locator(COL_SIZE)).to_have_text("+1")
@@ -164,10 +164,9 @@ def test_fills_taker_discount_program(

@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_fills_maker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page, setup_market_with_volume_discount_program, vega: VegaServiceNull
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -179,11 +178,11 @@ def test_fills_maker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("1.035 tDAI")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_fills_maker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull, page: Page, setup_market_with_volume_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -195,11 +194,12 @@ def test_fills_maker_fee_tooltip_discount_program(
    )


+@pytest.mark.xdist_group(name="test_fees_volume_tier_1")
 def test_fills_taker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_volume_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    # tbd - tooltip is not visible without this wait
@@ -1,6 +1,5 @@
 import pytest
 from fees_test_ids import *
-from typing import Tuple, Generator
 from playwright.sync_api import Page, expect
 from vega_sim.null_service import VegaServiceNull
 from actions.vega import submit_order
@@ -15,47 +14,51 @@ from conftest import (
 from actions.utils import next_epoch, change_keys, forward_time
 from fixtures.market import setup_continuous_market

+@pytest.fixture(scope="module")
+def vega(request):
+    with init_vega(request) as vega_instance:
+        request.addfinalizer(
+            lambda: cleanup_container(vega_instance)
+        )
+        yield vega_instance
+

@pytest.fixture(scope="module")
-def setup_environment(
-    request, browser
-) -> Generator[Tuple[VegaServiceNull, str, Page], None, None]:
-    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        # Setup the market with volume discount program
-        market = setup_continuous_market(vega_instance, custom_quantum=100000)
-        vega_instance.update_volume_discount_program(
-            proposal_key=MM_WALLET.name,
-            benefit_tiers=[
-                {
-                    "minimum_running_notional_taker_volume": 100,
-                    "volume_discount_factor": 0.1,
-                },
-                {
-                    "minimum_running_notional_taker_volume": 200,
-                    "volume_discount_factor": 0.2,
-                },
-            ],
-            window_length=7,
-        )
-        next_epoch(vega=vega_instance)
-
-        for _ in range(3):
-            submit_order(vega_instance, "Key 1", market, "SIDE_BUY", 1, 110)
-            forward_time(vega_instance, True if _ < 3 - 1 else False)
-
-        # Initialize page and apply setups
-        with init_page(vega_instance, browser, request) as page_instance:
-            risk_accepted_setup(page_instance)
-            auth_setup(vega_instance, page_instance)
-            yield vega_instance, market, page_instance
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        yield page


-def test_fees_page_discount_program_my_trading_fees(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.fixture(scope="module", autouse=True)
+def setup_market_with_volume_discount_program(vega: VegaServiceNull):
+    market = setup_continuous_market(vega, custom_quantum=100000)
+    vega.update_volume_discount_program(
+        proposal_key=MM_WALLET.name,
+        benefit_tiers=[
+            {
+                "minimum_running_notional_taker_volume": 100,
+                "volume_discount_factor": 0.1,
+            },
+            {
+                "minimum_running_notional_taker_volume": 200,
+                "volume_discount_factor": 0.2,
+            },
+        ],
+        window_length=7,
+    )
+    next_epoch(vega=vega)
+
+    for _ in range(3):
+        submit_order(vega, "Key 1", market, "SIDE_BUY", 1, 110)
+        forward_time(vega, True if _ < 3 - 1 else False)
+
+    return market
+
+
+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
+def test_fees_page_discount_program_my_trading_fees(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(ADJUSTED_FEES)).to_have_text("8.04%-8.04%")
    expect(page.get_by_test_id(TOTAL_FEE_BEFORE_DISCOUNT)).to_have_text(
@@ -66,10 +69,8 @@ def test_fees_page_discount_program_my_trading_fees(
    expect(page.get_by_test_id(LIQUIDITY_FEES)).to_have_text("Liquidity0%-0%")


-def test_fees_page_discount_program_total_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
+def test_fees_page_discount_program_total_discount(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TOTAL_DISCOUNT)).to_have_text("20%")
    expect(page.get_by_test_id(VOLUME_DISCOUNT_ROW)).to_have_text("Volume discount20%")
@@ -82,19 +83,15 @@ def test_fees_page_discount_program_total_discount(
    )


-def test_fees_page_volume_discount_program_my_current_volume(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
+def test_fees_page_volume_discount_program_my_current_volume(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(PAST_EPOCHS_VOLUME)).to_have_text("206")
    expect(page.get_by_test_id(REQUIRED_FOR_NEXT_TIER)).not_to_be_visible()


-def test_fees_page_discount_program_discount(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
+def test_fees_page_discount_program_discount(page: Page):
    page.goto("/#/fees")
    expect(page.get_by_test_id(TIER_VALUE_0)).to_have_text("1")
    expect(page.get_by_test_id(TIER_VALUE_1)).to_have_text("2")
@@ -107,8 +104,8 @@ def test_fees_page_discount_program_discount(
    expect(page.get_by_test_id("your-volume-tier-1").nth(1)).to_have_text("Your tier")


-def test_fees_page_discount_program_fees_by_market(setup_environment):
-    vega, market, page = setup_environment
+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
+def test_fees_page_discount_program_fees_by_market(page: Page):
    page.goto("/#/fees")
    pinned = page.locator(PINNED_ROW_LOCATOR)
    row = page.locator(ROW_LOCATOR)
@@ -120,11 +117,12 @@ def test_fees_page_discount_program_fees_by_market(setup_environment):
    expect(row.locator(COL_TOTAL_FEE)).to_have_text("10.05%")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
 def test_deal_ticket_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_volume_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    page.get_by_test_id(ORDER_SIZE).fill("1")
    page.get_by_test_id(ORDER_PRICE).fill("1")
    expect(page.get_by_test_id(DISCOUNT_PILL)).to_have_text("-20%")
@@ -143,11 +141,12 @@ def test_deal_ticket_discount_program(
    expect(tooltip.get_by_test_id(TOTAL_FEE_VALUE)).to_have_text("0.0804 tDAI")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
 def test_fills_taker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_volume_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    expect(row.locator(COL_SIZE)).to_have_text("+1")
@@ -160,11 +159,13 @@ def test_fills_taker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("2.08035 tDAI")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
 def test_fills_maker_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega: VegaServiceNull,
+    page: Page,
+    setup_market_with_volume_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -176,11 +177,11 @@ def test_fills_maker_discount_program(
    expect(row.locator(COL_FEE_DISCOUNT)).to_have_text("2.07 tDAI")


+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
 def test_fills_maker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    vega, page: Page, setup_market_with_volume_discount_program
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    change_keys(page, vega, MM_WALLET.name)
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
@@ -192,11 +193,12 @@ def test_fills_maker_fee_tooltip_discount_program(
    )


+@pytest.mark.xdist_group(name="test_fees_volume_tier_2")
 def test_fills_taker_fee_tooltip_discount_program(
-    setup_environment: Tuple[VegaServiceNull, str, Page],
-) -> None:
-    vega, market, page = setup_environment
-    page.goto(f"/#/markets/{market}")
+    page: Page,
+    setup_market_with_volume_discount_program,
+):
+    page.goto(f"/#/markets/{setup_market_with_volume_discount_program}")
    page.get_by_test_id(FILLS).click()
    row = page.get_by_test_id(TAB_FILLS).locator(ROW_LOCATOR).first
    # tbd - tooltip is not visible without this wait
@@ -10,218 +10,228 @@ order_tab = "tab-orders"


@pytest.fixture(scope="module")
-def setup_environment(request, browser):
-    # Initialize Vega with cleanup
+def vega(request):
    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
+        request.addfinalizer(lambda: cleanup_container(vega_instance))  # Register the cleanup function
+        yield vega_instance

-        # Setup multiple markets
-        markets = {
-            "market_1": setup_continuous_market(vega_instance, custom_market_name="market-1"),
-            "market_2": setup_continuous_market(vega_instance, custom_market_name="market-2"),
-            "market_3": setup_continuous_market(vega_instance, custom_market_name="market-3"),
-            "market_4": setup_continuous_market(vega_instance, custom_market_name="market-4"),
-            "market_5": setup_simple_market(vega_instance, custom_market_name="market-5"),
-        }

-        # Execute a series of orders across different markets
-        # Example for market_1 orders, adjust as necessary for your test scenario
-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_1"],
-            time_in_force="TIME_IN_FORCE_IOC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_SELL",
-            volume=100,
-            price=130,
-        )
-        
-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+@pytest.fixture(scope="module", autouse=True)
+def markets(vega: VegaServiceNull):
+    market_1 = setup_continuous_market(
+        vega,
+        custom_market_name="market-1",
+    )
+    market_2 = setup_continuous_market(
+        vega,
+        custom_market_name="market-2",
+    )
+    market_3 = setup_continuous_market(
+        vega,
+        custom_market_name="market-3",
+    )
+    market_4 = setup_continuous_market(
+        vega,
+        custom_market_name="market-4",
+    )
+    market_5 = setup_simple_market(
+        vega,
+        custom_market_name="market-5",
+    )

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_1"],
-            time_in_force="TIME_IN_FORCE_GTC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_SELL",
-            volume=100,
-            price=88,
-        )
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_1,
+        time_in_force="TIME_IN_FORCE_IOC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_SELL",
+        volume=100,
+        price=130,
+    )

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_1"],
-            time_in_force="TIME_IN_FORCE_IOC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_SELL",
-            volume=100,
-            price=88,
-        )
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_1,
+        time_in_force="TIME_IN_FORCE_GTC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_SELL",
+        volume=100,
+        price=88,
+    )

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_1"],
-            time_in_force="TIME_IN_FORCE_GTC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_SELL",
-            volume=1e10,
-            price=130,
-            wait=False,
-        )
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_1,
+        time_in_force="TIME_IN_FORCE_IOC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_SELL",
+        volume=100,
+        price=88,
+    )

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_2"],
-            time_in_force="TIME_IN_FORCE_IOC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_BUY",
-            volume=100,
-            price=104,
-        )
-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_1,
+        time_in_force="TIME_IN_FORCE_GTC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_SELL",
+        volume=1e10,
+        price=130,
+        wait=False,
+    )

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_3"],
-            time_in_force="TIME_IN_FORCE_GTT",
-            order_type="TYPE_LIMIT",
-            side="SIDE_SELL",
-            volume=10,
-            price=120,
-            expires_at=vega_instance.get_blockchain_time() + 5 * 1e9,
-        )
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_2,
+        time_in_force="TIME_IN_FORCE_IOC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_BUY",
+        volume=100,
+        price=104,
+    )
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            market_id=markets["market_4"],
-            trading_key="Key 1",
-            side="SIDE_BUY",
-            order_type="TYPE_LIMIT",
-            pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_MID", offset=5),
-            time_in_force="TIME_IN_FORCE_GTC",
-            volume=20,
-        )
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_3,
+        time_in_force="TIME_IN_FORCE_GTT",
+        order_type="TYPE_LIMIT",
+        side="SIDE_SELL",
+        volume=10,
+        price=120,
+        expires_at=vega.get_blockchain_time() + 5 * 1e9,
+    )

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            market_id=markets["market_4"],
-            trading_key="Key 1",
-            side="SIDE_BUY",
-            order_type="TYPE_LIMIT",
-            pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_BEST_BID", offset=10),
-            time_in_force="TIME_IN_FORCE_GTC",
-            volume=40,
-        )
+    vega.submit_order(
+        market_id=market_4,
+        trading_key="Key 1",
+        side="SIDE_BUY",
+        order_type="TYPE_LIMIT",
+        pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_MID", offset=5),
+        time_in_force="TIME_IN_FORCE_GTC",
+        volume=20,
+    )

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            market_id=markets["market_4"],
-            trading_key="Key 1",
-            side="SIDE_SELL",
-            order_type="TYPE_LIMIT",
-            pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_BEST_ASK", offset=15),
-            time_in_force="TIME_IN_FORCE_GTC",
-            volume=60,
-        )
+    vega.submit_order(
+        market_id=market_4,
+        trading_key="Key 1",
+        side="SIDE_BUY",
+        order_type="TYPE_LIMIT",
+        pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_BEST_BID", offset=10),
+        time_in_force="TIME_IN_FORCE_GTC",
+        volume=40,
+    )

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            market_id=markets["market_5"],
-            trading_key="Key 1",
-            side="SIDE_SELL",
-            order_type="TYPE_LIMIT",
-            pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_BEST_ASK", offset=15),
-            wait=False,
-            time_in_force="TIME_IN_FORCE_GTC",
-            volume=60,
-        )
+    vega.submit_order(
+        market_id=market_4,
+        trading_key="Key 1",
+        side="SIDE_SELL",
+        order_type="TYPE_LIMIT",
+        pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_BEST_ASK", offset=15),
+        time_in_force="TIME_IN_FORCE_GTC",
+        volume=60,
+    )

-        vega_instance.forward("2s")
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_2"],
-            time_in_force="TIME_IN_FORCE_GTC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_SELL",
-            volume=10,
-            price=150,
-        )
-        
-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.submit_order(
+        market_id=market_5,
+        trading_key="Key 1",
+        side="SIDE_SELL",
+        order_type="TYPE_LIMIT",
+        pegged_order=PeggedOrder(reference="PEGGED_REFERENCE_BEST_ASK", offset=15),
+        wait=False,
+        time_in_force="TIME_IN_FORCE_GTC",
+        volume=60,
+    )

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_2"],
-            time_in_force="TIME_IN_FORCE_GTC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_SELL",
-            volume=10,
-            price=160,
-        )
+    vega.forward("2s")
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_2,
+        time_in_force="TIME_IN_FORCE_GTC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_SELL",
+        volume=10,
+        price=150,
+    )
+    
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()

-        vega_instance.submit_order(
-            trading_key="Key 1",
-            market_id=markets["market_3"],
-            time_in_force="TIME_IN_FORCE_GTC",
-            order_type="TYPE_LIMIT",
-            side="SIDE_BUY",
-            volume=10,
-            price=60,
-        )
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_2,
+        time_in_force="TIME_IN_FORCE_GTC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_SELL",
+        volume=10,
+        price=160,
+    )

-        vega_instance.wait_fn(1)
-        vega_instance.wait_for_total_catchup()
-        # Initialize page and setup
-        
-        yield vega_instance, markets
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()
+
+    vega.submit_order(
+        trading_key="Key 1",
+        market_id=market_3,
+        time_in_force="TIME_IN_FORCE_GTC",
+        order_type="TYPE_LIMIT",
+        side="SIDE_BUY",
+        volume=10,
+        price=60,
+    )
+
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()


@pytest.fixture(scope="module")
-def page(setup_environment, browser, request):
-    vega_instance, markets = setup_environment
-    with init_page(vega_instance, browser, request) as page:
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
        risk_accepted_setup(page)
-        auth_setup(vega_instance, page)
+        auth_setup(vega, page)
        page.goto("/")
        page.get_by_test_id("All").click()
        yield page


+# close toast that is still opened after test
@pytest.fixture(autouse=True)
 def after_each(page: Page):
    yield
@@ -371,8 +381,7 @@ def test_order_status_pegged_mid(page: Page):
    )


-def test_order_amend_order(setup_environment, page:Page):
-    vega, markets = setup_environment
+def test_order_amend_order(vega: VegaServiceNull, page: Page):
    #  7002-SORD-053
    #  7003-MORD-012
    #  7003-MORD-014
@@ -393,13 +402,13 @@ def test_order_amend_order(setup_environment, page:Page):
    )


-def test_order_cancel_single_order(setup_environment, page:Page):
-    vega, markets = setup_environment
+def test_order_cancel_single_order(vega: VegaServiceNull, page: Page):
    #  7003-MORD-009
    #  7003-MORD-010
    #  7003-MORD-011
    #  7002-SORD-043
    page.get_by_test_id("cancel").first.click()
+
    wait_for_toast_confirmation(page, timeout=5000)
    vega.wait_fn(1)
    vega.wait_for_total_catchup()
@@ -411,8 +420,7 @@ def test_order_cancel_single_order(setup_environment, page:Page):
    )


-def test_order_cancel_all_orders(setup_environment, page:Page):
-    vega, markets = setup_environment
+def test_order_cancel_all_orders(vega: VegaServiceNull, page: Page):
    #  7003-MORD-009
    #  7003-MORD-010
    #  7003-MORD-011
@@ -1,15 +1,8 @@
 import pytest
 import vega_sim.proto.vega as vega_protos
-from typing import Tuple, Generator
 from rewards_test_ids import *
 from playwright.sync_api import Page, expect
-from conftest import (
-    init_vega,
-    init_page,
-    auth_setup,
-    risk_accepted_setup,
-    cleanup_container,
-)
+from conftest import init_vega, init_page, auth_setup, risk_accepted_setup, cleanup_container
 from fixtures.market import setup_continuous_market
 from actions.utils import next_epoch, change_keys
 from wallet_config import MM_WALLET
@@ -17,20 +10,22 @@ from vega_sim.null_service import VegaServiceNull


@pytest.fixture(scope="module")
-def setup_environment(request, browser) -> Generator[Tuple[Page, str, str], None, None]:
+def vega(request):
    with init_vega(request) as vega_instance:
        request.addfinalizer(lambda: cleanup_container(vega_instance))
+        yield vega_instance

-        tDAI_market, tDAI_asset_id = setup_market_with_reward_program(vega_instance)
-
-        with init_page(vega_instance, browser, request) as page:
-            risk_accepted_setup(page)
-            auth_setup(vega_instance, page)
-            page.goto(REWARDS_URL)
-            change_keys(page, vega_instance, PARTY_B)
-            yield page, tDAI_market, tDAI_asset_id
+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        page.goto(REWARDS_URL)
+        change_keys(page, vega, PARTY_B)
+        yield page


+@pytest.fixture(scope="module", autouse=True)
 def setup_market_with_reward_program(vega: VegaServiceNull):
    tDAI_market = setup_continuous_market(vega)
    PARTY_A, PARTY_B, PARTY_C, PARTY_D = keys(vega)
@@ -88,39 +83,39 @@ def setup_market_with_reward_program(vega: VegaServiceNull):
    return tDAI_market, tDAI_asset_id


+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_0")
 def test_network_reward_pot(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(TOTAL_REWARDS)).to_have_text("50.00 tDAI")


+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_0")
 def test_reward_multiplier(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(COMBINED_MULTIPLIERS)).to_have_text("1x")
    expect(page.get_by_test_id(STREAK_REWARD_MULTIPLIER_VALUE)).to_have_text("1x")
    expect(page.get_by_test_id(HOARDER_REWARD_MULTIPLIER_VALUE)).to_have_text("1x")


+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_0")
 def test_hoarder_bonus(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(HOARDER_BONUS_TOTAL_HOARDED)).to_contain_text(
        "5,000,000"
    )


+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_0")
 def test_reward_history(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    page.locator('[name="fromEpoch"]').fill("1")
    expect((page.get_by_role(ROW).locator(PRICE_TAKING_COL_ID)).nth(1)).to_have_text(
        "100.00100.00%"
    )
    expect((page.get_by_role(ROW).locator(TOTAL_COL_ID)).nth(1)).to_have_text("100.00")
    page.get_by_test_id(EARNED_BY_ME_BUTTON).click()
-    expect((page.get_by_role(ROW).locator(TOTAL_COL_ID)).nth(1)).to_have_text("50.00")
+    expect((page.get_by_role(ROW).locator(TOTAL_COL_ID)).nth(1)).to_have_text("50.00")
@@ -1,15 +1,8 @@
 import pytest
 from rewards_test_ids import *
-from typing import Tuple, Generator
 import vega_sim.proto.vega as vega_protos
 from playwright.sync_api import Page, expect
-from conftest import (
-    init_vega,
-    init_page,
-    auth_setup,
-    risk_accepted_setup,
-    cleanup_container,
-)
+from conftest import init_vega, init_page, auth_setup, risk_accepted_setup, cleanup_container
 from fixtures.market import setup_continuous_market
 from actions.utils import next_epoch, change_keys
 from wallet_config import MM_WALLET
@@ -17,21 +10,23 @@ from vega_sim.null_service import VegaServiceNull


@pytest.fixture(scope="module")
-def setup_environment(request, browser) -> Generator[Tuple[Page, str, str], None, None]:
-
+def vega(request):
    with init_vega(request) as vega_instance:
-        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        tDAI_market, tDAI_asset_id = setup_market_with_reward_program(vega_instance)
-
-        with init_page(vega_instance, browser, request) as page:
-            risk_accepted_setup(page)
-            auth_setup(vega_instance, page)
-            page.goto(REWARDS_URL)
-            change_keys(page, vega_instance, PARTY_B)
-            yield page, tDAI_market, tDAI_asset_id
+        request.addfinalizer(lambda: cleanup_container(vega_instance)) 
+        yield vega_instance


+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        page.goto(REWARDS_URL)
+        change_keys(page, vega, PARTY_B)
+        yield page
+
+
+@pytest.fixture(scope="module", autouse=True)
 def setup_market_with_reward_program(vega: VegaServiceNull):
    tDAI_market = setup_continuous_market(vega)
    PARTY_A, PARTY_B, PARTY_C, PARTY_D = keys(vega)
@@ -140,35 +135,31 @@ def setup_market_with_reward_program(vega: VegaServiceNull):
    return tDAI_market, tDAI_asset_id


+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_1")
 def test_network_reward_pot(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(TOTAL_REWARDS)).to_have_text("166.66666 tDAI")


+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_1")
 def test_reward_multiplier(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(COMBINED_MULTIPLIERS)).to_have_text("2x")
    expect(page.get_by_test_id(STREAK_REWARD_MULTIPLIER_VALUE)).to_have_text("1x")
    expect(page.get_by_test_id(HOARDER_REWARD_MULTIPLIER_VALUE)).to_have_text("2x")


-def test_hoarder_bonus(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_1")
+def test_hoarder_bonus(page: Page):
    expect(page.get_by_test_id(HOARDER_BONUS_TOTAL_HOARDED)).to_contain_text(
        "16,666,666"
    )


-def test_reward_history(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+@pytest.mark.xdist_group(name="test_rewards_hoarder_tier_1")
+def test_reward_history(page: Page):
    page.locator('[name="fromEpoch"]').fill("1")
    expect((page.get_by_role(ROW).locator(PRICE_TAKING_COL_ID)).nth(1)).to_have_text(
        "299.99999100.00%"
@@ -179,4 +170,4 @@ def test_reward_history(
    page.get_by_test_id(EARNED_BY_ME_BUTTON).click()
    expect((page.get_by_role(ROW).locator(TOTAL_COL_ID)).nth(1)).to_have_text(
        "166.66666"
-    )
+    )
@@ -1,6 +1,5 @@
 import pytest
 from rewards_test_ids import *
-from typing import Tuple, Generator
 import vega_sim.proto.vega as vega_protos
 from playwright.sync_api import Page, expect
 from conftest import (
@@ -17,23 +16,23 @@ from vega_sim.null_service import VegaServiceNull


@pytest.fixture(scope="module")
-def setup_environment(request, browser) -> Generator[Tuple[Page, str, str], None, None]:
-
+def vega(request):
    with init_vega(request) as vega_instance:
        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        tDAI_market, tDAI_asset_id = setup_market_with_reward_program(vega_instance)
-
-        with init_page(vega_instance, browser, request) as page:
-            risk_accepted_setup(page)
-            auth_setup(vega_instance, page)
-            page.goto(REWARDS_URL)
-            change_keys(page, vega_instance, PARTY_B)
-            yield page, tDAI_market, tDAI_asset_id
+        yield vega_instance


+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        page.goto(REWARDS_URL)
+        change_keys(page, vega, PARTY_B)
+        yield page


+@pytest.fixture(scope="module", autouse=True)
 def setup_market_with_reward_program(vega: VegaServiceNull):
    tDAI_market = setup_continuous_market(vega)
    PARTY_A, PARTY_B, PARTY_C, PARTY_D = keys(vega)
@@ -91,23 +90,25 @@ def setup_market_with_reward_program(vega: VegaServiceNull):
    return tDAI_market, tDAI_asset_id


+@pytest.mark.xdist_group(name="test_rewards_activity_tier_0")
 def test_network_reward_pot(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(TOTAL_REWARDS)).to_have_text("50.00 tDAI")
+    page.pause()


+@pytest.mark.xdist_group(name="test_rewards_activity_tier_0")
 def test_reward_multiplier(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
+    page.pause()
    expect(page.get_by_test_id(COMBINED_MULTIPLIERS)).to_have_text("1x")
    expect(page.get_by_test_id(STREAK_REWARD_MULTIPLIER_VALUE)).to_have_text("1x")
    expect(page.get_by_test_id(HOARDER_REWARD_MULTIPLIER_VALUE)).to_have_text("1x")


-"""
+""" @pytest.mark.xdist_group(name="test_rewards_activity_tier_0")
 def test_activity_streak(
    page: Page,
 ):
@@ -116,6 +117,7 @@ def test_activity_streak(
    )


+@pytest.mark.xdist_group(name="test_rewards_activity_tier_0")
 def test_reward_history(
    page: Page,
 ):
@@ -1,15 +1,8 @@
 import pytest
 from rewards_test_ids import *
-from typing import Tuple, Generator
 import vega_sim.proto.vega as vega_protos
 from playwright.sync_api import Page, expect
-from conftest import (
-    init_vega,
-    init_page,
-    auth_setup,
-    risk_accepted_setup,
-    cleanup_container,
-)
+from conftest import init_vega, init_page, auth_setup, risk_accepted_setup, cleanup_container
 from fixtures.market import setup_continuous_market
 from actions.utils import next_epoch, change_keys
 from wallet_config import MM_WALLET
@@ -17,21 +10,22 @@ from vega_sim.null_service import VegaServiceNull


@pytest.fixture(scope="module")
-def setup_environment(request, browser) -> Generator[Tuple[Page, str, str], None, None]:
-
+def vega(request):
    with init_vega(request) as vega_instance:
        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        tDAI_market, tDAI_asset_id = setup_market_with_reward_program(vega_instance)
-
-        with init_page(vega_instance, browser, request) as page:
-            risk_accepted_setup(page)
-            auth_setup(vega_instance, page)
-            page.goto(REWARDS_URL)
-            change_keys(page, vega_instance, PARTY_B)
-            yield page, tDAI_market, tDAI_asset_id
+        yield vega_instance


+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        page.goto(REWARDS_URL)
+        change_keys(page, vega, PARTY_B)
+        yield page
+
+@pytest.fixture(scope="module", autouse=True)
 def setup_market_with_reward_program(vega: VegaServiceNull):
    tDAI_market = setup_continuous_market(vega)
    PARTY_A, PARTY_B, PARTY_C, PARTY_D = keys(vega)
@@ -134,35 +128,34 @@ def setup_market_with_reward_program(vega: VegaServiceNull):
    return tDAI_market, tDAI_asset_id


-def test_network_reward_pot(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+@pytest.mark.xdist_group(name="test_rewards_activity_tier_1")
+def test_network_reward_pot(page: Page):
+    
    expect(page.get_by_test_id(TOTAL_REWARDS)).to_have_text("116.66666 tDAI")


+@pytest.mark.xdist_group(name="test_rewards_activity_tier_1")
 def test_reward_multiplier(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(COMBINED_MULTIPLIERS)).to_have_text("2x")
    expect(page.get_by_test_id(STREAK_REWARD_MULTIPLIER_VALUE)).to_have_text("2x")
    expect(page.get_by_test_id(HOARDER_REWARD_MULTIPLIER_VALUE)).to_have_text("1x")


+@pytest.mark.xdist_group(name="test_rewards_activity_tier_1")
 def test_activity_streak(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(EPOCH_STREAK)).to_have_text(
        "Active trader: 7 epochs so far (Tier 1 as of last epoch)"
    )


+@pytest.mark.xdist_group(name="test_rewards_activity_tier_1")
 def test_reward_history(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    page.locator('[name="fromEpoch"]').fill("1")
    expect((page.get_by_role(ROW).locator(PRICE_TAKING_COL_ID)).nth(1)).to_have_text(
        "300.00100.00%"
@@ -174,10 +167,10 @@ def test_reward_history(
    )


+@pytest.mark.xdist_group(name="test_rewards_activity_tier_1")
 def test_redeem(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    page.get_by_test_id("redeem-rewards-button").click()
    available_to_withdraw = page.get_by_test_id(
        "available-to-withdraw-value"
@@ -191,4 +184,4 @@ def test_redeem(
    )

    page.get_by_test_id("use-max-button").first.click()
-    expect(page.get_by_test_id(TRANSFER_AMOUNT)).to_have_text(available_to_withdraw)
+    expect(page.get_by_test_id(TRANSFER_AMOUNT)).to_have_text(available_to_withdraw)
@@ -1,6 +1,5 @@
 import pytest
 from rewards_test_ids import *
-from typing import Tuple, Generator
 import vega_sim.proto.vega as vega_protos
 from playwright.sync_api import Page, expect
 from conftest import init_vega, init_page, auth_setup, risk_accepted_setup, cleanup_container
@@ -10,20 +9,24 @@ from wallet_config import MM_WALLET
 from vega_sim.null_service import VegaServiceNull

@pytest.fixture(scope="module")
-def setup_environment(request, browser) -> Generator[Tuple[Page, str, str], None, None]:
+def vega(request):
    with init_vega(request) as vega_instance:
        request.addfinalizer(lambda: cleanup_container(vega_instance))
-
-        tDAI_market, tDAI_asset_id = setup_market_with_reward_program(vega_instance)
-
-        with init_page(vega_instance, browser, request) as page:
-            risk_accepted_setup(page)
-            auth_setup(vega_instance, page)
-            page.goto(REWARDS_URL)
-            change_keys(page, vega_instance, PARTY_B)
-            yield page, tDAI_market, tDAI_asset_id
+        yield vega_instance


+
+@pytest.fixture(scope="module")
+def page(vega, browser, request):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        page.goto(REWARDS_URL)
+        change_keys(page, vega, PARTY_B)
+        yield page
+
+
+@pytest.fixture(scope="module", autouse=True)
 def setup_market_with_reward_program(vega: VegaServiceNull):
    tDAI_market = setup_continuous_market(vega)
    PARTY_A, PARTY_B, PARTY_C, PARTY_D = keys(vega)
@@ -54,16 +57,6 @@ def setup_market_with_reward_program(vega: VegaServiceNull):
    )

    next_epoch(vega=vega)
-    vega.recurring_transfer(
-        from_key_name=PARTY_A.name,
-        from_account_type=vega_protos.vega.ACCOUNT_TYPE_GENERAL,
-        to_account_type=vega_protos.vega.ACCOUNT_TYPE_GLOBAL_REWARD,
-        asset=tDAI_asset_id,
-        amount=100,
-        factor=1.0,
-    )
-    vega.wait_fn(1)
-    vega.wait_for_total_catchup()
    vega.recurring_transfer(
        from_key_name=PARTY_A.name,
        from_account_type=vega_protos.vega.ACCOUNT_TYPE_GENERAL,
@@ -147,18 +140,16 @@ def setup_market_with_reward_program(vega: VegaServiceNull):
    return tDAI_market, tDAI_asset_id


-
-def test_network_reward_pot(     setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+@pytest.mark.xdist_group(name="test_rewards_combo_tier_1")
+def test_network_reward_pot( page: Page
+):
    expect(page.get_by_test_id(TOTAL_REWARDS)).to_have_text("183.33333 tDAI")


-
+@pytest.mark.xdist_group(name="test_rewards_combo_tier_1")
 def test_reward_multiplier(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    expect(page.get_by_test_id(COMBINED_MULTIPLIERS)).to_have_text("4x")
    expect(page.get_by_test_id(STREAK_REWARD_MULTIPLIER_VALUE)).to_have_text(
        "2x"
@@ -168,11 +159,10 @@ def test_reward_multiplier(
    )


-
+@pytest.mark.xdist_group(name="test_rewards_combo_tier_1")
 def test_reward_history(
-    setup_environment: Tuple[Page, str, str],
-) -> None:
-    page, tDAI_market, tDAI_asset_id = setup_environment
+    page: Page,
+):
    page.locator('[name="fromEpoch"]').fill("1")
    expect((page.get_by_role(ROW).locator(PRICE_TAKING_COL_ID)).nth(1)).to_have_text(
        "299.99999100.00%"
@@ -181,22 +171,4 @@ def test_reward_history(
    page.get_by_test_id(EARNED_BY_ME_BUTTON).click()
    expect((page.get_by_role(ROW).locator(TOTAL_COL_ID)).nth(1)).to_have_text(
        "183.33333"
-    )
-
-def test_staking_reward(
-    page: Page,
-):
-    expect(page.get_by_test_id("active-rewards-card")).to_have_count(2)
-    staking_reward_card = page.get_by_test_id("active-rewards-card").nth(1)
-    expect(staking_reward_card).to_be_visible()
-    expect(staking_reward_card.get_by_test_id("entity-scope")).to_have_text("Individual")
-    expect(staking_reward_card.get_by_test_id("locked-for")).to_have_text("0 epochs")
-    expect(staking_reward_card.get_by_test_id("reward-value")).to_have_text("100.00")
-    expect(staking_reward_card.get_by_test_id("distribution-strategy")).to_have_text("Pro rata")
-    expect(staking_reward_card.get_by_test_id("dispatch-metric-info")).to_have_text(
-        "Staking rewards"
-    )
-    expect(staking_reward_card.get_by_test_id("assessed-over")).to_have_text("1 epoch")
-    expect(staking_reward_card.get_by_test_id("scope")).to_have_text("Individual")
-    expect(staking_reward_card.get_by_test_id("staking-requirement")).to_have_text("1.00")
-    expect(staking_reward_card.get_by_test_id("average-position")).to_have_text("0.00")
+    )
@@ -97,13 +97,10 @@ def test_banners(vega: VegaServiceNull, page: Page):
        settlement_price=100,
        market_id=parent_market_id,
    )
-    vega.wait_fn(1)
-    vega.wait_for_total_catchup()
+
    successor_name = "successor market name"
    propose_successor(vega, parent_market_id, tdai_id, successor_name)
-    vega.wait_fn(1)
-    vega.wait_for_total_catchup()
-    page.reload()
+
    # Check that the banners notifying about the successor proposal and market has been settled are shown
    banner = page.get_by_test_id(market_banner)
    expect(banner).to_be_attached()
@@ -299,10 +299,10 @@ def test_leaderboard(competitions_page: Page, setup_teams_and_games):


 def test_game_card(competitions_page: Page):
-    expect(competitions_page.get_by_test_id("active-rewards-card")).to_have_count(1)
+    expect(competitions_page.get_by_test_id("active-rewards-card")).to_have_count(2)
    game_1 = competitions_page.get_by_test_id("active-rewards-card").first
    expect(game_1).to_be_visible()
-    expect(game_1.get_by_test_id("entity-scope")).to_have_text("Team")
+    expect(game_1.get_by_test_id("entity-scope")).to_have_text("Individual")
    expect(game_1.get_by_test_id("locked-for")).to_have_text("1 epoch")
    expect(game_1.get_by_test_id("reward-value")).to_have_text("100.00")
    expect(game_1.get_by_test_id("reward-asset")).to_have_text("VEGA")
@@ -311,7 +311,7 @@ def test_game_card(competitions_page: Page):
        "Price maker fees paid • tDAI"
    )
    expect(game_1.get_by_test_id("assessed-over")).to_have_text("15 epochs")
-    expect(game_1.get_by_test_id("scope")).to_have_text("All teams")
+    expect(game_1.get_by_test_id("scope")).to_have_text("In team")
    expect(game_1.get_by_test_id("staking-requirement")).to_have_text("0.00")
    expect(game_1.get_by_test_id("average-position")).to_have_text("0.00")

@@ -25,12 +25,8 @@ fragment GameFields on Game {
  }
 }

-query Games($epochFrom: Int, $teamId: ID) {
-  games(
-    epochFrom: $epochFrom
-    teamId: $teamId
-    entityScope: ENTITY_SCOPE_TEAMS
-  ) {
+query Games($epochFrom: Int) {
+  games(epochFrom: $epochFrom, entityScope: ENTITY_SCOPE_TEAMS) {
    edges {
      node {
        ...GameFields
@@ -9,7 +9,6 @@ export type GameFieldsFragment = { __typename?: 'Game', id: string, epoch: numbe

 export type GamesQueryVariables = Types.Exact<{
  epochFrom?: Types.InputMaybe<Types.Scalars['Int']>;
-  teamId?: Types.InputMaybe<Types.Scalars['ID']>;
 }>;


@@ -45,8 +44,8 @@ export const GameFieldsFragmentDoc = gql`
 }
    ${TeamEntityFragmentDoc}`;
 export const GamesDocument = gql`
-    query Games($epochFrom: Int, $teamId: ID) {
-  games(epochFrom: $epochFrom, teamId: $teamId, entityScope: ENTITY_SCOPE_TEAMS) {
+    query Games($epochFrom: Int) {
+  games(epochFrom: $epochFrom, entityScope: ENTITY_SCOPE_TEAMS) {
    edges {
      node {
        ...GameFields
@@ -69,7 +68,6 @@ export const GamesDocument = gql`
 * const { data, loading, error } = useGamesQuery({
 *   variables: {
 *      epochFrom: // value for 'epochFrom'
- *      teamId: // value for 'teamId'
 *   },
 * });
 */
@@ -51,7 +51,6 @@ export const useGames = (teamId?: string, epochFrom?: number): GamesData => {
  const { data, loading, error } = useGamesQuery({
    variables: {
      epochFrom: from,
-      teamId: teamId,
    },
    skip: !from,
    fetchPolicy: 'cache-and-network',
@@ -194,11 +194,11 @@ describe('isScopedToTeams', () => {
        undefined,
        makeDispatchStrategy(
          EntityScope.ENTITY_SCOPE_INDIVIDUALS,
-          IndividualScope.INDIVIDUAL_SCOPE_IN_TEAM // individual in teams but not a team game
+          IndividualScope.INDIVIDUAL_SCOPE_IN_TEAM // individual in teams
        ),
        'RecurringTransfer'
      ),
-      false,
+      true,
    ],
    [
      makeReward(
@@ -14,6 +14,7 @@ import {
  TransferStatus,
  type DispatchStrategy,
  EntityScope,
+  IndividualScope,
  MarketState,
  AccountType,
 } from '@vegaprotocol/types';
@@ -74,11 +75,20 @@ export const isActiveReward = (node: RewardTransfer, currentEpoch: number) => {

 /**
 * Checks if given reward (transfer) is scoped to teams.
+ *
+ * A reward is scoped to teams if it's entity scope is set to teams or
+ * if the scope is set to individuals but the individuals are in a team.
 */
 export const isScopedToTeams = (node: EnrichedRewardTransfer) =>
  // scoped to teams
  node.transfer.kind.dispatchStrategy?.entityScope ===
-  EntityScope.ENTITY_SCOPE_TEAMS;
+    EntityScope.ENTITY_SCOPE_TEAMS ||
+  // or to individuals
+  (node.transfer.kind.dispatchStrategy?.entityScope ===
+    EntityScope.ENTITY_SCOPE_INDIVIDUALS &&
+    // but they have to be in a team
+    node.transfer.kind.dispatchStrategy?.individualScope ===
+      IndividualScope.INDIVIDUAL_SCOPE_IN_TEAM);

 /** Retrieves rewards (transfers) */
 export const useRewards = ({
@@ -8,7 +8,6 @@ import {
 } from '@vegaprotocol/web3';
 import { WelcomeDialog } from '../components/welcome-dialog';
 import { VegaWalletConnectDialog } from '../components/vega-wallet-connect-dialog';
-import { ProfileDialog } from '../components/profile-dialog';

 const DialogsContainer = () => {
  const { isOpen, id, trigger, setOpen } = useAssetDetailsDialogStore();
@@ -25,7 +24,6 @@ const DialogsContainer = () => {
      <WelcomeDialog />
      <Web3ConnectUncontrolledDialog />
      <WithdrawalApprovalDialogContainer />
-      <ProfileDialog />
    </>
  );
 };
@@ -1,19 +0,0 @@
-import { create } from 'zustand';
-
-interface ProfileDialogStore {
-  open: boolean;
-  pubKey: string | undefined;
-  setOpen: (pubKey: string | undefined) => void;
-}
-
-export const useProfileDialogStore = create<ProfileDialogStore>((set) => ({
-  open: false,
-  pubKey: undefined,
-  setOpen: (pubKey) => {
-    if (pubKey) {
-      set({ open: true, pubKey });
-    } else {
-      set({ open: false, pubKey: undefined });
-    }
-  },
-}));
@@ -62,10 +62,3 @@ export const DENY_LIST: Record<string, string[]> = {
    'fdf0ec118d98393a7702cf72e46fc87ad680b152f64b2aac59e093ac2d688fbb',
  ],
 };
-
-// We need a record of USDT on mainnet as it needs special handling for
-// deposits and approvals due to the contract not conforming exactly
-// to ERC20
-export const USDT_ID = {
-  MAINNET: 'bf1e88d19db4b3ca0d1d5bdb73718a01686b18cf731ca26adedf3c8b83802bba',
-} as const;
@@ -6,12 +6,7 @@ export const PENNANT_INTERVAL_MAP = {
  [Interval.INTERVAL_I1M]: PennantInterval.I1M,
  [Interval.INTERVAL_I5M]: PennantInterval.I5M,
  [Interval.INTERVAL_I15M]: PennantInterval.I15M,
-  [Interval.INTERVAL_I30M]: PennantInterval.I30M,
  [Interval.INTERVAL_I1H]: PennantInterval.I1H,
-  [Interval.INTERVAL_I4H]: PennantInterval.I4H,
  [Interval.INTERVAL_I6H]: PennantInterval.I6H,
-  [Interval.INTERVAL_I8H]: PennantInterval.I8H,
-  [Interval.INTERVAL_I12H]: PennantInterval.I12H,
  [Interval.INTERVAL_I1D]: PennantInterval.I1D,
-  [Interval.INTERVAL_I7D]: PennantInterval.I7D,
 } as const;
@@ -34,28 +34,18 @@ const INTERVAL_TO_PENNANT_MAP = {
  [PennantInterval.I1M]: Schema.Interval.INTERVAL_I1M,
  [PennantInterval.I5M]: Schema.Interval.INTERVAL_I5M,
  [PennantInterval.I15M]: Schema.Interval.INTERVAL_I15M,
-  [PennantInterval.I30M]: Schema.Interval.INTERVAL_I30M,
  [PennantInterval.I1H]: Schema.Interval.INTERVAL_I1H,
-  [PennantInterval.I4H]: Schema.Interval.INTERVAL_I4H,
  [PennantInterval.I6H]: Schema.Interval.INTERVAL_I6H,
-  [PennantInterval.I8H]: Schema.Interval.INTERVAL_I8H,
-  [PennantInterval.I12H]: Schema.Interval.INTERVAL_I12H,
  [PennantInterval.I1D]: Schema.Interval.INTERVAL_I1D,
-  [PennantInterval.I7D]: Schema.Interval.INTERVAL_I7D,
 };

 const defaultConfig = {
  decimalPlaces: 5,
  supportedIntervals: [
-    PennantInterval.I7D,
    PennantInterval.I1D,
-    PennantInterval.I12H,
-    PennantInterval.I8H,
    PennantInterval.I6H,
-    PennantInterval.I4H,
    PennantInterval.I1H,
    PennantInterval.I15M,
-    PennantInterval.I30M,
    PennantInterval.I5M,
    PennantInterval.I1M,
  ],
@@ -147,15 +137,10 @@ export class VegaDataSource implements DataSource {
          decimalPlaces: this._decimalPlaces,
          positionDecimalPlaces: this._positionDecimalPlaces,
          supportedIntervals: [
-            PennantInterval.I7D,
            PennantInterval.I1D,
-            PennantInterval.I12H,
-            PennantInterval.I8H,
            PennantInterval.I6H,
-            PennantInterval.I4H,
            PennantInterval.I1H,
            PennantInterval.I15M,
-            PennantInterval.I30M,
            PennantInterval.I5M,
            PennantInterval.I1M,
          ],
@@ -270,10 +255,6 @@ const getDuration = (
  multiplier: number
 ): Duration => {
  switch (interval) {
-    case 'I7D':
-      return {
-        days: 7 * multiplier,
-      };
    case 'I1D':
      return {
        days: 1 * multiplier,
@@ -290,30 +271,14 @@ const getDuration = (
      return {
        minutes: 5 * multiplier,
      };
-    case 'I4H':
-      return {
-        hours: 4 * multiplier,
-      };
    case 'I6H':
      return {
        hours: 6 * multiplier,
      };
-    case 'I8H':
-      return {
-        hours: 8 * multiplier,
-      };
-    case 'I12H':
-      return {
-        hours: 12 * multiplier,
-      };
    case 'I15M':
      return {
        minutes: 15 * multiplier,
      };
-    case 'I30M':
-      return {
-        minutes: 30 * multiplier,
-      };
  }
 };

@@ -323,24 +288,14 @@ const getDifference = (
  dateRight: Date
 ): number => {
  switch (interval) {
-    case 'I7D':
-      return differenceInDays(dateRight, dateLeft) / 7;
    case 'I1D':
      return differenceInDays(dateRight, dateLeft);
-    case 'I12H':
-      return differenceInHours(dateRight, dateLeft) / 12;
-    case 'I8H':
-      return differenceInHours(dateRight, dateLeft) / 8;
    case 'I6H':
      return differenceInHours(dateRight, dateLeft) / 6;
-    case 'I4H':
-      return differenceInHours(dateRight, dateLeft) / 4;
    case 'I1H':
      return differenceInHours(dateRight, dateLeft);
    case 'I15M':
      return differenceInMinutes(dateRight, dateLeft) / 15;
-    case 'I30M':
-      return differenceInMinutes(dateRight, dateLeft) / 30;
    case 'I5M':
      return differenceInMinutes(dateRight, dateLeft) / 5;
    case 'I1M':
@@ -73,7 +73,7 @@ export const DealTicketContainer = ({
              market={market}
              marketPrice={marketPrice}
              marketData={marketData}
-              submit={(transaction) => create(transaction)}
+              submit={(orderSubmission) => create({ orderSubmission })}
            />
          )}
        </>
@@ -1,172 +0,0 @@
-import { Controller, type Control } from 'react-hook-form';
-import type { Market } from '@vegaprotocol/markets';
-import type { OrderFormValues } from '../../hooks/use-form-values';
-import { toDecimal, useValidateAmount } from '@vegaprotocol/utils';
-import {
-  TradingFormGroup,
-  TradingInputError,
-  Tooltip,
-  FormGroup,
-  Input,
-  InputError,
-  Pill,
-} from '@vegaprotocol/ui-toolkit';
-import { useT } from '../../use-t';
-
-export interface DealTicketPriceTakeProfitStopLossProps {
-  control: Control<OrderFormValues>;
-  market: Market;
-  takeProfitError?: string;
-  stopLossError?: string;
-  quoteName?: string;
-}
-
-export const DealTicketPriceTakeProfitStopLoss = ({
-  control,
-  market,
-  takeProfitError,
-  stopLossError,
-  quoteName,
-}: DealTicketPriceTakeProfitStopLossProps) => {
-  const t = useT();
-  const validateAmount = useValidateAmount();
-  const priceStep = toDecimal(market?.decimalPlaces);
-
-  const renderTakeProfitError = () => {
-    if (takeProfitError) {
-      return (
-        <TradingInputError testId="deal-ticket-take-profit-error-message">
-          {takeProfitError}
-        </TradingInputError>
-      );
-    }
-
-    return null;
-  };
-
-  const renderStopLossError = () => {
-    if (stopLossError) {
-      return (
-        <TradingInputError testId="deal-stop-loss-error-message">
-          {stopLossError}
-        </TradingInputError>
-      );
-    }
-
-    return null;
-  };
-
-  return (
-    <div className="mb-2">
-      <div className="flex flex-col gap-2">
-        <div className="flex-1">
-          <TradingFormGroup
-            label={
-              <Tooltip
-                description={<div>{t('The price for take profit.')}</div>}
-              >
-                <span className="text-xs">{t('Take profit')}</span>
-              </Tooltip>
-            }
-            labelFor="input-order-take-profit"
-            className="!mb-1"
-          >
-            <Controller
-              name="takeProfit"
-              control={control}
-              rules={{
-                min: {
-                  value: priceStep,
-                  message: t(
-                    'Take profit price cannot be lower than {{priceStep}}',
-                    {
-                      priceStep,
-                    }
-                  ),
-                },
-                validate: validateAmount(priceStep, 'takeProfit'),
-              }}
-              render={({ field, fieldState }) => (
-                <div className="mb-2">
-                  <FormGroup
-                    labelFor="input-price-take-profit"
-                    label={''}
-                    compact
-                  >
-                    <Input
-                      id="input-price-take-profit"
-                      appendElement={<Pill size="xs">{quoteName}</Pill>}
-                      className="w-full"
-                      type="number"
-                      step={priceStep}
-                      data-testid="order-price-take-profit"
-                      onWheel={(e) => e.currentTarget.blur()}
-                      {...field}
-                    />
-                  </FormGroup>
-                  {fieldState.error && (
-                    <InputError testId="deal-ticket-error-message-price-take-profit">
-                      {fieldState.error.message}
-                    </InputError>
-                  )}
-                </div>
-              )}
-            />
-          </TradingFormGroup>
-        </div>
-        <div className="flex-1">
-          <TradingFormGroup
-            label={
-              <Tooltip description={<div>{t('The price for stop loss.')}</div>}>
-                <span className="text-xs">{t('Stop loss')}</span>
-              </Tooltip>
-            }
-            labelFor="input-order-stop-loss"
-            className="!mb-1"
-          >
-            <Controller
-              name="stopLoss"
-              control={control}
-              rules={{
-                min: {
-                  value: priceStep,
-                  message: t('Price cannot be lower than {{priceStep}}', {
-                    priceStep,
-                  }),
-                },
-                validate: validateAmount(priceStep, 'stopLoss'),
-              }}
-              render={({ field, fieldState }) => (
-                <div className="mb-2">
-                  <FormGroup
-                    labelFor="input-price-stop-loss"
-                    label={''}
-                    compact
-                  >
-                    <Input
-                      id="input-price-stop-loss"
-                      appendElement={<Pill size="xs">{quoteName}</Pill>}
-                      className="w-full"
-                      type="number"
-                      step={priceStep}
-                      data-testid="order-price-stop-loss"
-                      onWheel={(e) => e.currentTarget.blur()}
-                      {...field}
-                    />
-                  </FormGroup>
-                  {fieldState.error && (
-                    <InputError testId="deal-ticket-error-message-price-stop-loss">
-                      {fieldState.error.message}
-                    </InputError>
-                  )}
-                </div>
-              )}
-            />
-          </TradingFormGroup>
-        </div>
-      </div>
-      {renderTakeProfitError()}
-      {renderStopLossError()}
-    </div>
-  );
-};
@@ -1003,7 +1003,7 @@ export const StopOrder = ({ market, marketPrice, submit }: StopOrderProps) => {
                name="oco"
                label={
                  <Tooltip
-                    description={<span>{t('One cancels the other')}</span>}
+                    description={<span>{t('One cancels another')}</span>}
                  >
                    <>{t('OCO')}</>
                  </Tooltip>
@@ -8,12 +8,9 @@ import { ExpirySelector } from './expiry-selector';
 import { SideSelector } from './side-selector';
 import { TimeInForceSelector } from './time-in-force-selector';
 import { TypeSelector } from './type-selector';
+import { type OrderSubmission } from '@vegaprotocol/wallet';
 import { useVegaWallet } from '@vegaprotocol/wallet-react';
-import { type Transaction } from '@vegaprotocol/wallet';
-import {
-  mapFormValuesToOrderSubmission,
-  mapFormValuesToTakeProfitAndStopLoss,
-} from '../../utils/map-form-values-to-submission';
+import { mapFormValuesToOrderSubmission } from '../../utils/map-form-values-to-submission';
 import {
  TradingInput as Input,
  TradingCheckbox as Checkbox,
@@ -80,8 +77,6 @@ import { isNonPersistentOrder } from '../../utils/time-in-force-persistence';
 import { KeyValue } from './key-value';
 import { DocsLinks } from '@vegaprotocol/environment';
 import { useT } from '../../use-t';
-import { DealTicketPriceTakeProfitStopLoss } from './deal-ticket-price-tp-sl';
-import uniqueId from 'lodash/uniqueId';

 export const REDUCE_ONLY_TOOLTIP =
  '"Reduce only" will ensure that this order will not increase the size of an open position. When the order is matched, it will only trade enough volume to bring your open volume towards 0 but never change the direction of your position. If applied to a limit order that is not instantly filled, the order will be stopped.';
@@ -91,7 +86,7 @@ export interface DealTicketProps {
  marketData: StaticMarketData;
  marketPrice?: string | null;
  onMarketClick?: (marketId: string, metaKey?: boolean) => void;
-  submit: (order: Transaction) => void;
+  submit: (order: OrderSubmission) => void;
  onDeposit: (assetId: string) => void;
 }

@@ -189,7 +184,6 @@ export const DealTicket = ({
  const rawSize = watch('size');
  const rawPrice = watch('price');
  const iceberg = watch('iceberg');
-  const tpSl = watch('tpSl');
  const peakSize = watch('peakSize');
  const expiresAt = watch('expiresAt');
  const postOnly = watch('postOnly');
@@ -388,28 +382,17 @@ export const DealTicket = ({
      if (lastSubmitTime.current && now - lastSubmitTime.current < 1000) {
        return;
      }
-      if (formValues.tpSl) {
-        const reference = `${pubKey}-${now}-${uniqueId()}`;
-        const batchMarketInstructions = mapFormValuesToTakeProfitAndStopLoss(
-          formValues,
-          market,
-          reference
-        );
-        submit({
-          batchMarketInstructions,
-        });
-      } else {
-        const orderSubmission = mapFormValuesToOrderSubmission(
+      submit(
+        mapFormValuesToOrderSubmission(
          formValues,
          market.id,
          market.decimalPlaces,
          market.positionDecimalPlaces
-        );
-        submit({ orderSubmission });
-      }
+        )
+      );
      lastSubmitTime.current = now;
    },
-    [market, pubKey, submit]
+    [submit, market.decimalPlaces, market.positionDecimalPlaces, market.id]
  );
  useController({
    name: 'type',
@@ -691,63 +674,40 @@ export const DealTicket = ({
          )}
        />
      </div>
-      {
+      {isLimitType && (
        <>
          <div className="flex justify-between gap-2 pb-2">
-            {isLimitType && (
-              <Controller
-                name="iceberg"
-                control={control}
-                render={({ field }) => (
-                  <Tooltip
-                    description={
-                      <p>
-                        {t(
-                          'ICEBERG_TOOLTIP',
-                          'Trade only a fraction of the order size at once. After the peak size of the order has traded, the size is reset. This is repeated until the order is cancelled, expires, or its full volume trades away. For example, an iceberg order with a size of 1000 and a peak size of 100 will effectively be split into 10 orders with a size of 100 each. Note that the full volume of the order is not hidden and is still reflected in the order book.'
-                        )}{' '}
-                        <ExternalLink href={DocsLinks?.ICEBERG_ORDERS}>
-                          {t('Find out more')}
-                        </ExternalLink>{' '}
-                      </p>
-                    }
-                  >
-                    <div>
-                      <Checkbox
-                        name="iceberg"
-                        checked={field.value}
-                        onCheckedChange={field.onChange}
-                        disabled={disableIcebergCheckbox}
-                        label={t('Iceberg')}
-                      />
-                    </div>
-                  </Tooltip>
-                )}
-              />
-            )}
            <Controller
-              name="tpSl"
+              name="iceberg"
              control={control}
              render={({ field }) => (
                <Tooltip
                  description={
-                    <p>{t('TP_SL_TOOLTIP', 'Take profit / Stop loss')}</p>
+                    <p>
+                      {t(
+                        'ICEBERG_TOOLTIP',
+                        'Trade only a fraction of the order size at once. After the peak size of the order has traded, the size is reset. This is repeated until the order is cancelled, expires, or its full volume trades away. For example, an iceberg order with a size of 1000 and a peak size of 100 will effectively be split into 10 orders with a size of 100 each. Note that the full volume of the order is not hidden and is still reflected in the order book.'
+                      )}{' '}
+                      <ExternalLink href={DocsLinks?.ICEBERG_ORDERS}>
+                        {t('Find out more')}
+                      </ExternalLink>{' '}
+                    </p>
                  }
                >
                  <div>
                    <Checkbox
-                      name="tpSl"
+                      name="iceberg"
                      checked={field.value}
                      onCheckedChange={field.onChange}
-                      disabled={false}
-                      label={t('TP / SL')}
+                      disabled={disableIcebergCheckbox}
+                      label={t('Iceberg')}
                    />
                  </div>
                </Tooltip>
              )}
            />
          </div>
-          {isLimitType && iceberg && (
+          {iceberg && (
            <DealTicketSizeIceberg
              market={market}
              peakSizeError={errors.peakSize?.message}
@@ -757,18 +717,8 @@ export const DealTicket = ({
              peakSize={peakSize}
            />
          )}
-          {tpSl && (
-            <DealTicketPriceTakeProfitStopLoss
-              market={market}
-              takeProfitError={errors.takeProfit?.message}
-              stopLossError={errors.stopLoss?.message}
-              control={control}
-              quoteName={quoteName}
-            />
-          )}
        </>
-      }
-
+      )}
      <SummaryMessage
        error={summaryError}
        asset={asset}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dariusz Majcherczyk	6502d2e26e	chore: temp change exit code	2024-03-06 15:19:31 +01:00
Dariusz Majcherczyk	8e6a3aa153	chore: update or condition	2024-03-06 14:51:24 +01:00
Dariusz Majcherczyk	02dc202342	chore: update projects condition	2024-03-06 14:08:10 +01:00
Dariusz Majcherczyk	286e7c3e51	chore: update project	2024-03-06 13:51:36 +01:00
Dariusz Majcherczyk	81fe572a4b	chore: skip cypress check for trading	2024-03-06 13:44:28 +01:00
bwallacee	7e4143e6f3	chore(trading): skip market info volume test	2024-03-06 10:38:06 +00:00
				`@@ -1 +0,0 @@`
				`export { ProfileDialog } from './profile-dialog';`