test(explorer): add tests for games display

Co-authored-by: bwallacee <ben@vega.xyz>

README.md

@@ -4,7 +4,7 @@ The front-end monorepo provides a toolkit for building apps that interact with V
 
 This repository is managed using [Nx](https://nx.dev).
 
-# 🔎 Applications in this repo
+## 🔎 Applications in this repo
 
 ### [Block explorer](./apps/explorer)
 
@@ -30,7 +30,7 @@ Hosting for static content being shared across apps, for example fonts.
 
 The utility dApp for validators wishing to add or remove themselves as a signer of the multisig contract.
 
-# 🧱 Libraries in this repo
+## 🧱 Libraries in this repo
 
 ### [UI toolkit](./libs/ui-toolkit)
 
@@ -53,7 +53,7 @@ A utility library for connecting to the Ethereum network and interacting with Ve
 
 Generic react helpers that can be used across multiple applications, along with other utilities.
 
-# 💻 Develop
+## 💻 Develop
 
 ### Set up
 
@@ -103,7 +103,7 @@ In CI linting, formatting and also run. These checks can be seen in the [CI work
 
 Visit the [Nx Documentation](https://nx.dev/getting-started/intro) to learn more.
 
-# 🐋 Hosting a console
+## 🐋 Hosting a console
 
 To host a console there are two possible build scenarios for running the frontends: nx performed **outside** or **inside** docker build. For specific build instructions follow [build instructions](#build-instructions).
 
@@ -226,6 +226,6 @@ Note: The script is only needed if capsule was built for first time or fresh. To
 vega wallet service run -n DV --load-tokens --tokens-passphrase-file passphrase --no-version-check --automatic-consent --home ~/.vegacapsule/testnet/wallet
 ```
 
-# 📑 License
+## 📑 License
 
 [MIT](./LICENSE)

apps/explorer/src/app/components/links/hash.tsx

@@ -1,4 +1,4 @@
-export type HashProps = {
+export type HashProps = React.HTMLProps<HTMLSpanElement> & {
   text: string;
   truncate?: boolean;
 };

apps/explorer/src/app/components/links/index.ts

@@ -2,4 +2,5 @@ export { default as BlockLink } from './block-link/block-link';
 export { default as PartyLink } from './party-link/party-link';
 export { default as NodeLink } from './node-link/node-link';
 export { default as MarketLink } from './market-link/market-link';
+export { default as NetworkParameterLink } from './network-parameter-link/network-parameter-link';
 export * from './asset-link/asset-link';

apps/explorer/src/app/components/links/network-parameter-link/network-parameter-link.tsx

@@ -0,0 +1,30 @@
+import React from 'react';
+import { Routes } from '../../../routes/route-names';
+import { Link } from 'react-router-dom';
+
+import type { ComponentProps } from 'react';
+import Hash from '../hash';
+
+export type NetworkParameterLinkProps = Partial<ComponentProps<typeof Link>> & {
+  parameter: string;
+};
+
+/**
+ * Links a given network parameter to the relevant page and anchor on the page
+ */
+const NetworkParameterLink = ({
+  parameter,
+  ...props
+}: NetworkParameterLinkProps) => {
+  return (
+    <Link
+      className="underline"
+      {...props}
+      to={`/${Routes.NETWORK_PARAMETERS}#${parameter}`}
+    >
+      <Hash text={parameter} />
+    </Link>
+  );
+};
+
+export default NetworkParameterLink;

apps/explorer/src/app/components/links/proposal-link/proposal-link.tsx

@@ -26,7 +26,7 @@ const ProposalLink = ({ id, text }: ProposalLinkProps) => {
   >;
 
   const base = ENV.dataSources.governanceUrl;
-  const label = proposal?.rationale.title || id;
+  const label = proposal?.rationale?.title || id;
 
   return (
     <ExternalLink href={`${base}/proposals/${id}`}>

apps/explorer/src/app/components/txs/details/proposal/Proposal.graphql

@@ -5,5 +5,10 @@ query ExplorerProposalStatus($id: ID!) {
       state
       rejectionReason
     }
+    ... on BatchProposal {
+      id
+      state
+      rejectionReason
+    }
   }
 }

apps/explorer/src/app/components/txs/details/proposal/__generated__/Proposal.ts

@@ -8,7 +8,7 @@ export type ExplorerProposalStatusQueryVariables = Types.Exact<{
 }>;
 
 
-export type ExplorerProposalStatusQuery = { __typename?: 'Query', proposal?: { __typename?: 'BatchProposal' } | { __typename?: 'Proposal', id?: string | null, state: Types.ProposalState, rejectionReason?: Types.ProposalRejectionReason | null } | null };
+export type ExplorerProposalStatusQuery = { __typename?: 'Query', proposal?: { __typename?: 'BatchProposal', id?: string | null, state: Types.ProposalState, rejectionReason?: Types.ProposalRejectionReason | null } | { __typename?: 'Proposal', id?: string | null, state: Types.ProposalState, rejectionReason?: Types.ProposalRejectionReason | null } | null };
 
 
 export const ExplorerProposalStatusDocument = gql`
@@ -19,6 +19,11 @@ export const ExplorerProposalStatusDocument = gql`
       state
       rejectionReason
     }
+    ... on BatchProposal {
+      id
+      state
+      rejectionReason
+    }
   }
 }
     `;

apps/explorer/src/app/components/txs/details/proposal/batch-item.spec.tsx

@@ -0,0 +1,257 @@
+import { render, screen } from '@testing-library/react';
+import { BatchItem } from './batch-item';
+import { MemoryRouter } from 'react-router-dom';
+import { MockedProvider } from '@apollo/client/testing';
+import type { components } from '../../../../../types/explorer';
+type Item = components['schemas']['vegaBatchProposalTermsChange'];
+
+describe('BatchItem', () => {
+  it('Renders "Unknown proposal type" by default', () => {
+    const item = {};
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('Unknown proposal type')).toBeInTheDocument();
+  });
+
+  it('Renders "Unknown proposal type" for unknown items', () => {
+    const item = {
+      newLochNessMonster: {
+        location: 'Loch Ness',
+      },
+    } as unknown as Item;
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('Unknown proposal type')).toBeInTheDocument();
+  });
+
+  it('Renders "New spot market"', () => {
+    const item = {
+      newSpotMarket: {},
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('New spot market')).toBeInTheDocument();
+  });
+
+  it('Renders "Cancel transfer"', () => {
+    const item = {
+      cancelTransfer: {
+        changes: {
+          transferId: 'transfer123',
+        },
+      },
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('Cancel transfer')).toBeInTheDocument();
+    expect(screen.getByText('transf')).toBeInTheDocument();
+  });
+
+  it('Renders "Cancel transfer" without an id', () => {
+    const item = {
+      cancelTransfer: {
+        changes: {},
+      },
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('Cancel transfer')).toBeInTheDocument();
+  });
+
+  it('Renders "New freeform"', () => {
+    const item = {
+      newFreeform: {},
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('New freeform proposal')).toBeInTheDocument();
+  });
+
+  it('Renders "New market"', () => {
+    const item = {
+      newMarket: {},
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('New market')).toBeInTheDocument();
+  });
+
+  it('Renders "New transfer"', () => {
+    const item = {
+      newTransfer: {},
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('New transfer')).toBeInTheDocument();
+  });
+
+  it('Renders "Update asset" with assetId', () => {
+    const item = {
+      updateAsset: {
+        assetId: 'asset123',
+      },
+    };
+    render(
+      <MemoryRouter>
+        <MockedProvider>
+          <BatchItem item={item} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(screen.getByText('Update asset')).toBeInTheDocument();
+    expect(screen.getByText('asset123')).toBeInTheDocument();
+  });
+
+  it('Renders "Update asset" even if assetId is not set', () => {
+    const item = {
+      updateAsset: {
+        assetId: undefined,
+      },
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('Update asset')).toBeInTheDocument();
+  });
+
+  it('Renders "Update market state" with marketId', () => {
+    const item = {
+      updateMarketState: {
+        changes: {
+          marketId: 'market123',
+        },
+      },
+    };
+    render(
+      <MemoryRouter>
+        <MockedProvider>
+          <BatchItem item={item} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(screen.getByText('Update market state')).toBeInTheDocument();
+    expect(screen.getByText('market123')).toBeInTheDocument();
+  });
+
+  it('Renders "Update market state" even if marketId is not set', () => {
+    const item = {
+      updateMarketState: {
+        changes: {
+          marketId: undefined,
+        },
+      },
+    };
+    render(
+      <MemoryRouter>
+        <MockedProvider>
+          <BatchItem item={item} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(screen.getByText('Update market state')).toBeInTheDocument();
+  });
+
+  it('Renders "Update network parameter" with parameter', () => {
+    const item = {
+      updateNetworkParameter: {
+        changes: {
+          key: 'parameter123',
+        },
+      },
+    };
+    render(
+      <MockedProvider>
+        <MemoryRouter>
+          <BatchItem item={item} />
+        </MemoryRouter>
+      </MockedProvider>
+    );
+    expect(screen.getByText('Update network parameter')).toBeInTheDocument();
+    expect(screen.getByText('parameter123')).toBeInTheDocument();
+  });
+
+  it('Renders "Update network parameter" even if parameter is not set', () => {
+    const item = {
+      updateNetworkParameter: {
+        changes: {
+          key: undefined,
+        },
+      },
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('Update network parameter')).toBeInTheDocument();
+  });
+
+  it('Renders "Update referral program"', () => {
+    const item = {
+      updateReferralProgram: {},
+    };
+    render(<BatchItem item={item} />);
+    expect(screen.getByText('Update referral program')).toBeInTheDocument();
+  });
+
+  it('Renders "Update spot market" with marketId', () => {
+    const item = {
+      updateSpotMarket: {
+        marketId: 'market123',
+      },
+    };
+    render(
+      <MemoryRouter>
+        <MockedProvider>
+          <BatchItem item={item} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(screen.getByText('Update spot market')).toBeInTheDocument();
+    expect(screen.getByText('market123')).toBeInTheDocument();
+  });
+
+  it('Renders "Update spot market" even if marketId is not set', () => {
+    const item = {
+      updateSpotMarket: {
+        marketId: undefined,
+      },
+    };
+    render(
+      <MemoryRouter>
+        <MockedProvider>
+          <BatchItem item={item} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(screen.getByText('Update spot market')).toBeInTheDocument();
+  });
+  it('Renders "Update market" with marketId', () => {
+    const item = {
+      updateMarket: {
+        marketId: 'market123',
+      },
+    };
+    render(
+      <MemoryRouter>
+        <MockedProvider>
+          <BatchItem item={item} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(screen.getByText('Update market')).toBeInTheDocument();
+    expect(screen.getByText('market123')).toBeInTheDocument();
+  });
+
+  it('Renders "Update market" even if marketId is not set', () => {
+    const item = {
+      updateMarket: {
+        marketId: undefined,
+      },
+    };
+    render(
+      <MemoryRouter>
+        <MockedProvider>
+          <BatchItem item={item} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(screen.getByText('Update market')).toBeInTheDocument();
+  });
+
+  it('Renders "Update volume discount program"', () => {
+    const item = {
+      updateVolumeDiscountProgram: {},
+    };
+    render(<BatchItem item={item} />);
+    expect(
+      screen.getByText('Update volume discount program')
+    ).toBeInTheDocument();
+  });
+});

apps/explorer/src/app/components/txs/details/proposal/batch-item.tsx

@@ -0,0 +1,87 @@
+import { t } from '@vegaprotocol/i18n';
+import { AssetLink, MarketLink, NetworkParameterLink } from '../../../links';
+import type { components } from '../../../../../types/explorer';
+import Hash from '../../../links/hash';
+
+type Item = components['schemas']['vegaBatchProposalTermsChange'];
+
+export interface BatchItemProps {
+  item: Item;
+}
+
+/**
+ * Produces a one line summary for an item in a batch proposal. Could
+ * easily be adapted to summarise individual proposals, but there is no
+ * place for that yet.
+ *
+ * Details (like IDs) should be shown and linked if available, but handled
+ * if not available. This is adequate as the ProposalSummary component contains
+ * a JSON viewer for the full proposal.
+ */
+export const BatchItem = ({ item }: BatchItemProps) => {
+  if (item.cancelTransfer) {
+    const transferId = item?.cancelTransfer?.changes?.transferId || false;
+    return (
+      <span>
+        {t('Cancel transfer')}&nbsp;
+        {transferId && (
+          <Hash className="ml-1" truncate={true} text={transferId} />
+        )}
+      </span>
+    );
+  } else if (item.newFreeform) {
+    return <span>{t('New freeform proposal')}</span>;
+  } else if (item.newMarket) {
+    return <span>{t('New market')}</span>;
+  } else if (item.newSpotMarket) {
+    return <span>{t('New spot market')}</span>;
+  } else if (item.newTransfer) {
+    return <span>{t('New transfer')}</span>;
+  } else if (item.updateAsset) {
+    const assetId = item?.updateAsset?.assetId || false;
+    return (
+      <span>
+        {t('Update asset')}
+        {assetId && <AssetLink className="ml-1" assetId={assetId} />}
+      </span>
+    );
+  } else if (item.updateMarket) {
+    const marketId = item?.updateMarket?.marketId || false;
+    return (
+      <span>
+        {t('Update market')}{' '}
+        {marketId && <MarketLink className="ml-1" id={marketId} />}
+      </span>
+    );
+  } else if (item.updateMarketState) {
+    const marketId = item?.updateMarketState?.changes?.marketId || false;
+    return (
+      <span>
+        {t('Update market state')}
+        {marketId && <MarketLink className="ml-1" id={marketId} />}
+      </span>
+    );
+  } else if (item.updateNetworkParameter) {
+    const param = item?.updateNetworkParameter?.changes?.key || false;
+    return (
+      <span>
+        {t('Update network parameter')}
+        {param && <NetworkParameterLink className="ml-1" parameter={param} />}
+      </span>
+    );
+  } else if (item.updateReferralProgram) {
+    return <span>{t('Update referral program')}</span>;
+  } else if (item.updateSpotMarket) {
+    const marketId = item?.updateSpotMarket?.marketId || '';
+    return (
+      <span>
+        {t('Update spot market')}
+        <MarketLink className="ml-1" id={marketId} />
+      </span>
+    );
+  } else if (item.updateVolumeDiscountProgram) {
+    return <span>{t('Update volume discount program')}</span>;
+  }
+
+  return <span>{t('Unknown proposal type')}</span>;
+};

apps/explorer/src/app/components/txs/details/proposal/summary.tsx

@@ -1,6 +1,4 @@
-import type { ProposalTerms } from '../tx-proposal';
 import { useState } from 'react';
-import type { components } from '../../../../../types/explorer';
 import { JsonViewerDialog } from '../../../dialogs/json-viewer-dialog';
 import ProposalLink from '../../../links/proposal-link/proposal-link';
 import truncate from 'lodash/truncate';
@@ -9,7 +7,12 @@ import ReactMarkdown from 'react-markdown';
 import { ProposalDate } from './proposal-date';
 import { t } from '@vegaprotocol/i18n';
 
+import type { ProposalTerms } from '../tx-proposal';
+import type { components } from '../../../../../types/explorer';
+import { BatchItem } from './batch-item';
+
 type Rationale = components['schemas']['vegaProposalRationale'];
+type Batch = components['schemas']['v1BatchProposalSubmissionTerms']['changes'];
 
 type ProposalTermsDialog = {
   open: boolean;
@@ -21,6 +24,7 @@ interface ProposalSummaryProps {
   id: string;
   rationale?: Rationale;
   terms?: ProposalTerms;
+  batch?: Batch;
 }
 
 /**
@@ -31,6 +35,7 @@ export const ProposalSummary = ({
   id,
   rationale,
   terms,
+  batch,
 }: ProposalSummaryProps) => {
   const [dialog, setDialog] = useState<ProposalTermsDialog>({
     open: false,
@@ -59,7 +64,9 @@ export const ProposalSummary = ({
   return (
     <div className="w-auto max-w-lg border-2 border-solid border-vega-light-100 dark:border-vega-dark-200 p-5">
       {id && <ProposalStatusIcon id={id} />}
-      {rationale?.title && <h1 className="text-xl pb-1">{rationale.title}</h1>}
+      {rationale?.title && (
+        <h1 className="text-xl pb-1 break-all">{rationale.title}</h1>
+      )}
       {rationale?.description && (
         <div className="pt-2 text-sm leading-tight">
           <ReactMarkdown
@@ -72,6 +79,18 @@ export const ProposalSummary = ({
           </ReactMarkdown>
         </div>
       )}
+      {batch && (
+        <section className="pt-2 text-sm leading-tight my-3">
+          <h2 className="text-lg pb-1">{t('Changes')}</h2>
+          <ol>
+            {batch.map((change, index) => (
+              <li className="ml-4 list-decimal" key={`batch-${index}`}>
+                <BatchItem item={change} />
+              </li>
+            ))}
+          </ol>
+        </section>
+      )}
       <div className="pt-5">
         <button className="underline max-md:hidden mr-5" onClick={openDialog}>
           {t('View terms')}

apps/explorer/src/app/components/txs/details/transfer/Transfer.graphql

@@ -0,0 +1,18 @@
+query ExplorerTransferStatus($id: ID!) {
+  transfer(id: $id) {
+    transfer {
+      reference
+      timestamp
+      status
+      reason
+      fromAccountType
+      from
+      to
+      toAccountType
+      asset {
+        id
+      }
+      amount
+    }
+  }
+}

apps/explorer/src/app/components/txs/details/transfer/__generated__/Transfer.ts

@@ -0,0 +1,61 @@
+import * as Types from '@vegaprotocol/types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type ExplorerTransferStatusQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID'];
+}>;
+
+
+export type ExplorerTransferStatusQuery = { __typename?: 'Query', transfer?: { __typename?: 'TransferNode', transfer: { __typename?: 'Transfer', reference?: string | null, timestamp: any, status: Types.TransferStatus, reason?: string | null, fromAccountType: Types.AccountType, from: string, to: string, toAccountType: Types.AccountType, amount: string, asset?: { __typename?: 'Asset', id: string } | null } } | null };
+
+
+export const ExplorerTransferStatusDocument = gql`
+    query ExplorerTransferStatus($id: ID!) {
+  transfer(id: $id) {
+    transfer {
+      reference
+      timestamp
+      status
+      reason
+      fromAccountType
+      from
+      to
+      toAccountType
+      asset {
+        id
+      }
+      amount
+    }
+  }
+}
+    `;
+
+/**
+ * __useExplorerTransferStatusQuery__
+ *
+ * To run a query within a React component, call `useExplorerTransferStatusQuery` and pass it any options that fit your needs.
+ * When your component renders, `useExplorerTransferStatusQuery` 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 } = useExplorerTransferStatusQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useExplorerTransferStatusQuery(baseOptions: Apollo.QueryHookOptions<ExplorerTransferStatusQuery, ExplorerTransferStatusQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<ExplorerTransferStatusQuery, ExplorerTransferStatusQueryVariables>(ExplorerTransferStatusDocument, options);
+      }
+export function useExplorerTransferStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExplorerTransferStatusQuery, ExplorerTransferStatusQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<ExplorerTransferStatusQuery, ExplorerTransferStatusQueryVariables>(ExplorerTransferStatusDocument, options);
+        }
+export type ExplorerTransferStatusQueryHookResult = ReturnType<typeof useExplorerTransferStatusQuery>;
+export type ExplorerTransferStatusLazyQueryHookResult = ReturnType<typeof useExplorerTransferStatusLazyQuery>;
+export type ExplorerTransferStatusQueryResult = Apollo.QueryResult<ExplorerTransferStatusQuery, ExplorerTransferStatusQueryVariables>;

apps/explorer/src/app/components/txs/details/transfer/blocks/transfer-participants.tsx

@@ -111,7 +111,7 @@ export function TransferParticipants({
               <svg
                 xmlns="http://www.w3.org/2000/svg"
                 viewBox="0 0 16 9"
-                className="fill-vega-light-100 dark:fill-black"
+                className="fill-white dark:fill-black"
               >
                 <path d="M0,0L8,9l8,-9Z" />
               </svg>
@@ -120,7 +120,7 @@ export function TransferParticipants({
               <svg
                 xmlns="http://www.w3.org/2000/svg"
                 viewBox="0 0 16 9"
-                className="fill-vega-light-100 dark:fill-vega-dark-200"
+                className="fill-vega-light-200 dark:fill-vega-dark-200"
               >
                 <path d="M0,0L8,9l8,-9Z" />
               </svg>

apps/explorer/src/app/components/txs/details/transfer/blocks/transfer-rewards.tsx

@@ -1,97 +1,223 @@
 import { t } from '@vegaprotocol/i18n';
 import { AssetLink, MarketLink } from '../../../../links';
-import { headerClasses, wrapperClasses } from '../transfer-details';
 import type { components } from '../../../../../../types/explorer';
 import type { Recurring } from '../transfer-details';
-import { DispatchMetricLabels } from '@vegaprotocol/types';
-
+import {
+  DispatchMetricLabels,
+  DistributionStrategy,
+} from '@vegaprotocol/types';
+import { VegaIcon, VegaIconNames } from '@vegaprotocol/ui-toolkit';
+import { formatNumber } from '@vegaprotocol/utils';
 export type Metric = components['schemas']['vegaDispatchMetric'];
 export type Strategy = components['schemas']['vegaDispatchStrategy'];
 
+export const wrapperClasses = 'border pv-2 w-full flex-auto basis-full';
+export const headerClasses =
+  'bg-solid bg-vega-light-150 dark:bg-vega-dark-150 text-center text-xl py-2 font-alpha calt';
+
 const metricLabels: Record<Metric, string> = {
   DISPATCH_METRIC_UNSPECIFIED: 'Unknown metric',
   ...DispatchMetricLabels,
 };
 
+// Maps the two (non-null) values of entityScope to the icon that represents it
+const entityScopeIcons: Record<
+  string,
+  typeof VegaIconNames[keyof typeof VegaIconNames]
+> = {
+  ENTITY_SCOPE_INDIVIDUALS: VegaIconNames.MAN,
+  ENTITY_SCOPE_TEAMS: VegaIconNames.TEAM,
+};
+
+const distributionStrategyLabel: Record<DistributionStrategy, string> = {
+  [DistributionStrategy.DISTRIBUTION_STRATEGY_PRO_RATA]: 'Pro Rata',
+  [DistributionStrategy.DISTRIBUTION_STRATEGY_RANK]: 'Ranked',
+};
+
 interface TransferRewardsProps {
   recurring: Recurring;
 }
 
 /**
- * Renderer for a transfer. These can vary quite
- * widely, essentially every field can be null.
+ * Renders recurring transfers/game details in a way that is, perhaps, easy to understand
  *
  * @param transfer A recurring transfer object
  */
 export function TransferRewards({ recurring }: TransferRewardsProps) {
-  const metric =
-    recurring?.dispatchStrategy?.metric || 'DISPATCH_METRIC_UNSPECIFIED';
-
   if (!recurring || !recurring.dispatchStrategy) {
     return null;
   }
 
+  // Destructure to make things a bit more readable
+  const {
+    entityScope,
+    individualScope,
+    teamScope,
+    distributionStrategy,
+    lockPeriod,
+    markets,
+    stakingRequirement,
+    windowLength,
+    notionalTimeWeightedAveragePositionRequirement,
+    rankTable,
+    nTopPerformers,
+  } = recurring.dispatchStrategy;
+
   return (
     <div className={wrapperClasses}>
-      <h2 className={headerClasses}>{t('Reward metrics')}</h2>
-      <ul className="relative block rounded-lg py-6 text-center p-6">
-        {recurring.dispatchStrategy.assetForMetric ? (
+      <h2 className={headerClasses}>{getRewardTitle(entityScope)}</h2>
+      <ul className="relative block rounded-lg py-6 text-left p-6">
+        {entityScope && entityScopeIcons[entityScope] ? (
           <li>
-            <strong>{t('Asset')}</strong>:{' '}
-            <AssetLink assetId={recurring.dispatchStrategy.assetForMetric} />
+            <strong>{t('Scope')}</strong>:{' '}
+            <VegaIcon name={entityScopeIcons[entityScope]} />
+            &nbsp;
+            {individualScope ? individualScopeLabels[individualScope] : null}
+            {getScopeLabel(entityScope, teamScope)}
           </li>
         ) : null}
-        <li>
-          <strong>{t('Metric')}</strong>: {metricLabels[metric]}
-        </li>
-        {recurring.dispatchStrategy.markets &&
-        recurring.dispatchStrategy.markets.length > 0 ? (
+        {recurring.dispatchStrategy &&
+          recurring.dispatchStrategy.assetForMetric && (
+            <li>
+              <strong>{t('Asset for metric')}</strong>:{' '}
+              <AssetLink assetId={recurring.dispatchStrategy.assetForMetric} />
+            </li>
+          )}
+        {recurring.dispatchStrategy.metric &&
+          metricLabels[recurring.dispatchStrategy.metric] && (
+            <li>
+              <strong>{t('Metric')}</strong>:{' '}
+              {metricLabels[recurring.dispatchStrategy.metric]}
+            </li>
+          )}
+        {lockPeriod && (
+          <li>
+            <strong>{t('Reward lock')}</strong>:&nbsp;
+            {recurring.dispatchStrategy.lockPeriod}{' '}
+            {recurring.dispatchStrategy.lockPeriod === '1'
+              ? t('epoch')
+              : t('epochs')}
+          </li>
+        )}
+
+        {markets && markets.length > 0 ? (
           <li>
             <strong>{t('Markets in scope')}</strong>:
-            <ul>
-              {recurring.dispatchStrategy.markets.map((m) => (
-                <li key={m}>
+            <ul className="inline-block ml-1">
+              {markets.map((m) => (
+                <li key={m} className="inline-block mr-2">
                   <MarketLink id={m} />
                 </li>
               ))}
             </ul>
           </li>
         ) : null}
-        <li>
-          <strong>{t('Factor')}</strong>: {recurring.factor}
-        </li>
+
+        {stakingRequirement && stakingRequirement !== '0' ? (
+          <li>
+            <strong>{t('Staking requirement')}</strong>: {stakingRequirement}
+          </li>
+        ) : null}
+
+        {windowLength && windowLength !== '0' ? (
+          <li>
+            <strong>{t('Window length')}</strong>:{' '}
+            {recurring.dispatchStrategy.windowLength}{' '}
+            {recurring.dispatchStrategy.windowLength === '1'
+              ? t('epoch')
+              : t('epochs')}
+          </li>
+        ) : null}
+
+        {notionalTimeWeightedAveragePositionRequirement &&
+        notionalTimeWeightedAveragePositionRequirement !== '' ? (
+          <li>
+            <strong>{t('Notional TWAP')}</strong>:{' '}
+            {notionalTimeWeightedAveragePositionRequirement}
+          </li>
+        ) : null}
+
+        {nTopPerformers && (
+          <li>
+            <strong>{t('Elligible team members:')}</strong> top{' '}
+            {`${formatNumber(Number(nTopPerformers) * 100, 0)}%`}
+          </li>
+        )}
+
+        {distributionStrategy &&
+          distributionStrategy !== 'DISTRIBUTION_STRATEGY_UNSPECIFIED' && (
+            <li>
+              <strong>{t('Distribution strategy')}</strong>:{' '}
+              {distributionStrategyLabel[distributionStrategy]}
+            </li>
+          )}
       </ul>
+      <div className="px-6 pt-1 pb-5">
+        {rankTable && rankTable.length > 0 ? (
+          <table className="border-collapse border border-gray-400 ">
+            <thead>
+              <tr>
+                <th className="border border-gray-300 bg-gray-300 px-3">
+                  <strong>{t('Start rank')}</strong>
+                </th>
+                <th className="border border-gray-300 bg-gray-300 px-3">
+                  <strong>{t('Share of reward pool')}</strong>
+                </th>
+              </tr>
+            </thead>
+            <tbody>
+              {rankTable.map((row, i) => {
+                return (
+                  <tr key={`rank-${i}`}>
+                    <td className="border border-slate-300 text-center">
+                      {row.startRank}
+                    </td>
+                    <td className="border border-slate-300 text-center">
+                      {row.shareRatio}
+                    </td>
+                  </tr>
+                );
+              })}
+            </tbody>
+          </table>
+        ) : null}
+      </div>
     </div>
   );
 }
 
-interface TransferRecurringStrategyProps {
-  strategy: Strategy;
-}
-
-/**
- * Simple renderer for a dispatch strategy in a recurring transfer
- *
- * @param strategy Dispatch strategy object
- */
-export function TransferRecurringStrategy({
-  strategy,
-}: TransferRecurringStrategyProps) {
-  if (!strategy) {
-    return null;
+export function getScopeLabel(
+  scope: components['schemas']['vegaEntityScope'] | undefined,
+  teamScope: readonly string[] | undefined
+): string {
+  if (scope === 'ENTITY_SCOPE_TEAMS') {
+    if (teamScope && teamScope.length !== 0) {
+      return ` ${teamScope.length} teams`;
+    } else {
+      return t('All teams');
+    }
+  } else if (scope === 'ENTITY_SCOPE_INDIVIDUALS') {
+    return t('Individuals');
+  } else {
+    return '';
   }
-
-  return (
-    <>
-      {strategy.assetForMetric ? (
-        <li>
-          <strong>{t('Asset for metric')}</strong>:{' '}
-          <AssetLink assetId={strategy.assetForMetric} />
-        </li>
-      ) : null}
-      <li>
-        <strong>{t('Metric')}</strong>: {strategy.metric}
-      </li>
-    </>
-  );
 }
+export function getRewardTitle(
+  scope?: components['schemas']['vegaEntityScope']
+) {
+  if (scope === 'ENTITY_SCOPE_TEAMS') {
+    return t('Game');
+  }
+  return t('Reward metrics');
+}
+
+const individualScopeLabels: Record<
+  components['schemas']['vegaIndividualScope'],
+  string
+> = {
+  // Unspecified and All are not rendered
+  INDIVIDUAL_SCOPE_UNSPECIFIED: '',
+  INDIVIDUAL_SCOPE_ALL: '',
+  INDIVIDUAL_SCOPE_IN_TEAM: '(in team)',
+  INDIVIDUAL_SCOPE_NOT_IN_TEAM: '(not in team)',
+};

apps/explorer/src/app/components/txs/details/transfer/blocks/transfer-status.tsx

@@ -0,0 +1,84 @@
+import { t } from '@vegaprotocol/i18n';
+import { headerClasses, wrapperClasses } from '../transfer-details';
+import { Icon, Loader } from '@vegaprotocol/ui-toolkit';
+import type { IconName } from '@vegaprotocol/ui-toolkit';
+import type { ApolloError } from '@apollo/client';
+import { TransferStatus, TransferStatusMapping } from '@vegaprotocol/types';
+import { IconNames } from '@blueprintjs/icons';
+
+interface TransferStatusProps {
+  status: TransferStatus | undefined;
+  error: ApolloError | undefined;
+  loading: boolean;
+}
+
+/**
+ * Renderer for a transfer. These can vary quite
+ * widely, essentially every field can be null.
+ *
+ * @param transfer A recurring transfer object
+ */
+export function TransferStatusView({ status, loading }: TransferStatusProps) {
+  if (!status) {
+    status = TransferStatus.STATUS_PENDING;
+  }
+
+  return (
+    <div className={wrapperClasses}>
+      <h2 className={headerClasses}>{t('Status')}</h2>
+      <div className="relative block rounded-lg py-6 text-center p-6">
+        {loading ? (
+          <div className="leading-10 mt-12">
+            <Loader size={'small'} />
+          </div>
+        ) : (
+          <>
+            <p className="leading-10 my-2">
+              <Icon
+                name={getIconForStatus(status)}
+                className={getColourForStatus(status)}
+              />
+            </p>
+            <p className="leading-10 my-2">{TransferStatusMapping[status]}</p>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/**
+ * Simple mapping from status to icon name
+ * @param status TransferStatus
+ * @returns IconName
+ */
+export function getIconForStatus(status: TransferStatus): IconName {
+  switch (status) {
+    case TransferStatus.STATUS_PENDING:
+      return IconNames.TIME;
+    case TransferStatus.STATUS_DONE:
+      return IconNames.TICK;
+    case TransferStatus.STATUS_REJECTED:
+      return IconNames.CROSS;
+    default:
+      return IconNames.TIME;
+  }
+}
+
+/**
+ * Simple mapping from status to colour
+ * @param status TransferStatus
+ * @returns string Tailwind classname
+ */
+export function getColourForStatus(status: TransferStatus): string {
+  switch (status) {
+    case TransferStatus.STATUS_PENDING:
+      return 'text-yellow-500';
+    case TransferStatus.STATUS_DONE:
+      return 'text-green-500';
+    case TransferStatus.STATUS_REJECTED:
+      return 'text-red-500';
+    default:
+      return 'text-yellow-500';
+  }
+}

apps/explorer/src/app/components/txs/details/transfer/transfer-details.tsx

@@ -2,12 +2,15 @@ import type { components } from '../../../../../types/explorer';
 import { TransferRepeat } from './blocks/transfer-repeat';
 import { TransferRewards } from './blocks/transfer-rewards';
 import { TransferParticipants } from './blocks/transfer-participants';
+import { useExplorerTransferStatusQuery } from './__generated__/Transfer';
+import { TransferStatusView } from './blocks/transfer-status';
+import { TransferStatus } from '@vegaprotocol/types';
 
 export type Recurring = components['schemas']['commandsv1RecurringTransfer'];
 export type Metric = components['schemas']['vegaDispatchMetric'];
 
 export const wrapperClasses =
-  'border border-vega-light-150 dark:border-vega-dark-200 rounded-md pv-2 mb-5 w-full sm:w-1/4 min-w-[200px] ';
+  'border border-vega-light-150 dark:border-vega-dark-200 pv-2 w-full sm:w-1/3 basis-1/3';
 export const headerClasses =
   'bg-solid bg-vega-light-150 dark:bg-vega-dark-150 border-vega-light-150 text-center text-xl py-2 font-alpha calt';
 
@@ -16,6 +19,7 @@ export type Transfer = components['schemas']['commandsv1Transfer'];
 interface TransferDetailsProps {
   transfer: Transfer;
   from: string;
+  id: string;
 }
 
 /**
@@ -24,13 +28,24 @@ interface TransferDetailsProps {
  *
  * @param transfer A recurring transfer object
  */
-export function TransferDetails({ transfer, from }: TransferDetailsProps) {
+export function TransferDetails({ transfer, from, id }: TransferDetailsProps) {
   const recurring = transfer.recurring;
 
+  // Currently all this is passed in to TransferStatus, but the extra details
+  // may be useful in the future.
+  const { data, error, loading } = useExplorerTransferStatusQuery({
+    variables: { id },
+  });
+
+  const status = error
+    ? TransferStatus.STATUS_REJECTED
+    : data?.transfer?.transfer.status;
+
   return (
-    <div className="flex gap-5 flex-wrap">
+    <div className="flex flex-wrap">
       <TransferParticipants from={from} transfer={transfer} />
       {recurring ? <TransferRepeat recurring={transfer.recurring} /> : null}
+      <TransferStatusView status={status} error={error} loading={loading} />
       {recurring && recurring.dispatchStrategy ? (
         <TransferRewards recurring={transfer.recurring} />
       ) : null}

apps/explorer/src/app/components/txs/details/transfer/transfer-rewards.spec.tsx

@@ -0,0 +1,172 @@
+import {
+  getScopeLabel,
+  getRewardTitle,
+  TransferRewards,
+} from './blocks/transfer-rewards';
+import { render } from '@testing-library/react';
+import type { components } from '../../../../../types/explorer';
+import type { Recurring } from './transfer-details';
+import {
+  DispatchMetric,
+  DistributionStrategy,
+  EntityScope,
+  IndividualScope,
+} from '@vegaprotocol/types';
+import { MemoryRouter } from 'react-router-dom';
+import { MockedProvider } from '@apollo/client/testing';
+
+describe('getScopeLabel', () => {
+  it('should return the correct label for ENTITY_SCOPE_TEAMS with teamScope', () => {
+    const scope = 'ENTITY_SCOPE_TEAMS';
+    const teamScope = ['team1', 'team2', 'team3'];
+    const expectedLabel = ' 3 teams';
+
+    const result = getScopeLabel(scope, teamScope);
+
+    expect(result).toEqual(expectedLabel);
+  });
+
+  it('should return the correct label for ENTITY_SCOPE_TEAMS without teamScope', () => {
+    const scope = 'ENTITY_SCOPE_TEAMS';
+    const teamScope = undefined;
+    const expectedLabel = 'All teams';
+
+    const result = getScopeLabel(scope, teamScope);
+
+    expect(result).toEqual(expectedLabel);
+  });
+
+  it('should return the correct label for ENTITY_SCOPE_INDIVIDUALS', () => {
+    const scope = 'ENTITY_SCOPE_INDIVIDUALS';
+    const teamScope = undefined;
+    const expectedLabel = 'Individuals';
+
+    const result = getScopeLabel(scope, teamScope);
+
+    expect(result).toEqual(expectedLabel);
+  });
+
+  it('should return an empty string for unknown scope', () => {
+    const scope = 'UNKNOWN_SCOPE';
+    const teamScope = undefined;
+    const expectedLabel = '';
+
+    const result = getScopeLabel(
+      scope as unknown as components['schemas']['vegaEntityScope'],
+      teamScope
+    );
+
+    expect(result).toEqual(expectedLabel);
+  });
+});
+
+describe('getRewardTitle', () => {
+  it('should return the correct title for ENTITY_SCOPE_TEAMS', () => {
+    const scope = 'ENTITY_SCOPE_TEAMS';
+    const expectedTitle = 'Game';
+
+    const result = getRewardTitle(scope);
+
+    expect(result).toEqual(expectedTitle);
+  });
+
+  it('should return the correct title for other scopes', () => {
+    const scope = 'ENTITY_SCOPE_INDIVIDUALS';
+    const expectedTitle = 'Reward metrics';
+
+    const result = getRewardTitle(scope);
+
+    expect(result).toEqual(expectedTitle);
+  });
+});
+
+describe('TransferRewards', () => {
+  it('should render nothing if recurring dispatchStrategy is not provided', () => {
+    const { container } = render(
+      <TransferRewards recurring={null as unknown as Recurring} />
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('should render nothing if recurring.dispatchStrategy is not provided', () => {
+    const { container } = render(
+      <TransferRewards recurring={{} as unknown as Recurring} />
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('should render the reward details correctly', () => {
+    const recurring = {
+      dispatchStrategy: {
+        metric: DispatchMetric.DISPATCH_METRIC_AVERAGE_POSITION,
+        assetForMetric: '123',
+        entityScope: EntityScope.ENTITY_SCOPE_TEAMS,
+        individualScope: IndividualScope.INDIVIDUAL_SCOPE_IN_TEAM,
+        teamScope: [],
+        distributionStrategy:
+          DistributionStrategy.DISTRIBUTION_STRATEGY_PRO_RATA,
+        lockPeriod: 'lockPeriod',
+        markets: ['market1', 'market2'],
+        stakingRequirement: '1',
+        windowLength: 'windowLength',
+        notionalTimeWeightedAveragePositionRequirement:
+          'notionalTimeWeightedAveragePositionRequirement',
+        rankTable: [
+          { startRank: 1, shareRatio: 0.2 },
+          { startRank: 2, shareRatio: 0.3 },
+        ],
+        nTopPerformers: 'nTopPerformers',
+      },
+    };
+
+    const { getByText } = render(
+      <MemoryRouter>
+        <MockedProvider>
+          <TransferRewards recurring={recurring} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+
+    expect(getByText('Game')).toBeInTheDocument();
+    expect(getByText('Scope')).toBeInTheDocument();
+    expect(getByText('Asset for metric')).toBeInTheDocument();
+    expect(getByText('Metric')).toBeInTheDocument();
+    expect(getByText('Reward lock')).toBeInTheDocument();
+    expect(getByText('Markets in scope')).toBeInTheDocument();
+    expect(getByText('Staking requirement')).toBeInTheDocument();
+    expect(getByText('Window length')).toBeInTheDocument();
+    expect(getByText('Notional TWAP')).toBeInTheDocument();
+    expect(getByText('Elligible team members:')).toBeInTheDocument();
+    expect(getByText('Distribution strategy')).toBeInTheDocument();
+    expect(getByText('Start rank')).toBeInTheDocument();
+    expect(getByText('Share of reward pool')).toBeInTheDocument();
+  });
+
+  it('should not render a rank table if recurring.dispatchStrategy.rankTable is not provided', () => {
+    const recurring = {
+      dispatchStrategy: {
+        entityScope: EntityScope.ENTITY_SCOPE_INDIVIDUALS,
+        individualScope: IndividualScope.INDIVIDUAL_SCOPE_ALL,
+        teamScope: ['team1', 'team2', 'team3'],
+        distributionStrategy:
+          DistributionStrategy.DISTRIBUTION_STRATEGY_PRO_RATA,
+        lockPeriod: 'lockPeriod',
+        markets: ['market1', 'market2'],
+        stakingRequirement: 'stakingRequirement',
+        windowLength: 'windowLength',
+        notionalTimeWeightedAveragePositionRequirement:
+          'notionalTimeWeightedAveragePositionRequirement',
+        nTopPerformers: 'nTopPerformers',
+      },
+    };
+
+    const { container } = render(
+      <MemoryRouter>
+        <MockedProvider>
+          <TransferRewards recurring={recurring} />
+        </MockedProvider>
+      </MemoryRouter>
+    );
+    expect(container.querySelector('table')).toBeNull();
+  });
+});

apps/explorer/src/app/components/txs/details/tx-batch-proposal.tsx

@@ -0,0 +1,75 @@
+import type { BlockExplorerTransactionResult } from '../../../routes/types/block-explorer-response';
+import type { TendermintBlocksResponse } from '../../../routes/blocks/tendermint-blocks-response';
+import { sharedHeaderProps, TxDetailsShared } from './shared/tx-details-shared';
+import { TableCell, TableRow, TableWithTbody } from '../../table';
+import type { components } from '../../../../types/explorer';
+import { txSignatureToDeterministicId } from '../lib/deterministic-ids';
+import { ProposalSummary } from './proposal/summary';
+import Hash from '../../links/hash';
+import { t } from '@vegaprotocol/i18n';
+
+export type Proposal = components['schemas']['v1BatchProposalSubmission'];
+export type ProposalTerms = components['schemas']['vegaProposalTerms'];
+
+interface TxBatchProposalProps {
+  txData: BlockExplorerTransactionResult | undefined;
+  pubKey: string | undefined;
+  blockData: TendermintBlocksResponse | undefined;
+}
+
+/**
+ *
+ */
+export const TxBatchProposal = ({
+  txData,
+  pubKey,
+  blockData,
+}: TxBatchProposalProps) => {
+  if (!txData || !txData.command.batchProposalSubmission) {
+    return <>{t('Awaiting Block Explorer transaction details')}</>;
+  }
+  let deterministicId = '';
+
+  const proposal: Proposal = txData.command.batchProposalSubmission;
+  const sig = txData?.signature?.value;
+  if (sig) {
+    deterministicId = txSignatureToDeterministicId(sig);
+  }
+
+  return (
+    <>
+      <TableWithTbody className="mb-8" allowWrap={true}>
+        <TableRow modifier="bordered">
+          <TableCell {...sharedHeaderProps}>{t('Type')}</TableCell>
+          <TableCell>{t('Batch proposal')}</TableCell>
+        </TableRow>
+        <TxDetailsShared
+          txData={txData}
+          pubKey={pubKey}
+          blockData={blockData}
+          hideTypeRow={true}
+        />
+        <TableRow modifier="bordered">
+          <TableCell>{t('Batch size')}</TableCell>
+          <TableCell>
+            {proposal.terms?.changes?.length || t('No changes')}
+          </TableCell>
+        </TableRow>
+        <TableRow modifier="bordered">
+          <TableCell>{t('Proposal ID')}</TableCell>
+          <TableCell>
+            <Hash text={deterministicId} />
+          </TableCell>
+        </TableRow>
+      </TableWithTbody>
+      {proposal && (
+        <ProposalSummary
+          id={deterministicId}
+          rationale={proposal?.rationale}
+          terms={proposal.terms}
+          batch={proposal.terms?.changes}
+        />
+      )}
+    </>
+  );
+};

apps/explorer/src/app/components/txs/details/tx-details-wrapper.tsx

@@ -32,6 +32,8 @@ import { TxDetailsCreateReferralSet } from './tx-create-referral-set';
 import { TxDetailsApplyReferralCode } from './tx-apply-referral-code';
 import { TxDetailsUpdateReferralSet } from './tx-update-referral-set';
 import { TxDetailsJoinTeam } from './tx-join-team';
+import { TxDetailsUpdateMarginMode } from './tx-update-margin-mode';
+import { TxBatchProposal } from './tx-batch-proposal';
 
 interface TxDetailsWrapperProps {
   txData: BlockExplorerTransactionResult | undefined;
@@ -133,6 +135,10 @@ function getTransactionComponent(txData?: BlockExplorerTransactionResult) {
       return TxDetailsApplyReferralCode;
     case 'Join Team':
       return TxDetailsJoinTeam;
+    case 'Update Margin Mode':
+      return TxDetailsUpdateMarginMode;
+    case 'Batch Proposal':
+      return TxBatchProposal;
     default:
       return TxDetailsGeneric;
   }

apps/explorer/src/app/components/txs/details/tx-proposal.tsx

@@ -12,6 +12,8 @@ import { ProposalSignatureBundleNewAsset } from './proposal/signature-bundle-new
 import { ProposalSignatureBundleUpdateAsset } from './proposal/signature-bundle-update';
 import { MarketLink } from '../../links';
 import { formatNumber } from '@vegaprotocol/utils';
+import { TransferDetails } from './transfer/transfer-details';
+import { proposalToTransfer } from '../lib/proposal-to-transfer';
 
 export type Proposal = components['schemas']['v1ProposalSubmission'];
 export type ProposalTerms = components['schemas']['vegaProposalTerms'];
@@ -104,6 +106,12 @@ export const TxProposal = ({ txData, pubKey, blockData }: TxProposalProps) => {
     ? ProposalSignatureBundleNewAsset
     : ProposalSignatureBundleUpdateAsset;
 
+  let transfer, from;
+  if (proposal.terms?.newTransfer?.changes) {
+    transfer = proposalToTransfer(proposal.terms?.newTransfer.changes);
+    from = proposal.terms.newTransfer.changes.source;
+  }
+
   return (
     <>
       <TableWithTbody className="mb-8" allowWrap={true}>
@@ -149,14 +157,26 @@ export const TxProposal = ({ txData, pubKey, blockData }: TxProposalProps) => {
           </>
         ) : null}
       </TableWithTbody>
+
       <ProposalSummary
         id={deterministicId}
         rationale={proposal.rationale}
         terms={proposal?.terms}
       />
+
       {proposalRequiresSignatureBundle(proposal) && (
         <SignatureBundleComponent id={deterministicId} tx={tx} />
       )}
+
+      {transfer && (
+        <div className="mt-8">
+          <TransferDetails
+            transfer={transfer}
+            from={from || ''}
+            id={deterministicId}
+          />
+        </div>
+      )}
     </>
   );
 };

apps/explorer/src/app/components/txs/details/tx-transfer.tsx

@@ -13,6 +13,7 @@ import {
   SPECIAL_CASE_NETWORK_ID,
 } from '../../links/party-link/party-link';
 import { txSignatureToDeterministicId } from '../lib/deterministic-ids';
+import Hash from '../../links/hash';
 
 type Transfer = components['schemas']['commandsv1Transfer'];
 
@@ -60,7 +61,7 @@ export const TxDetailsTransfer = ({
   }
 
   const from = txData.submitter;
-
+  const id = txSignatureToDeterministicId(txData.signature.value);
   return (
     <>
       <TableWithTbody className="mb-8" allowWrap={true}>
@@ -71,7 +72,7 @@ export const TxDetailsTransfer = ({
         <TableRow modifier="bordered" data-testid="id">
           <TableCell {...sharedHeaderProps}>{t('Transfer ID')}</TableCell>
           <TableCell>
-            {txSignatureToDeterministicId(txData.signature.value)}
+            <Hash text={id} />
           </TableCell>
         </TableRow>
         <TxDetailsShared
@@ -105,7 +106,7 @@ export const TxDetailsTransfer = ({
           </TableRow>
         ) : null}
       </TableWithTbody>
-      <TransferDetails from={from} transfer={transfer} />
+      <TransferDetails from={from} transfer={transfer} id={id} />
     </>
   );
 };

apps/explorer/src/app/components/txs/details/tx-update-margin-mode.tsx

@@ -0,0 +1,60 @@
+import { t } from '@vegaprotocol/i18n';
+import type { BlockExplorerTransactionResult } from '../../../routes/types/block-explorer-response';
+import type { TendermintBlocksResponse } from '../../../routes/blocks/tendermint-blocks-response';
+import { TxDetailsShared } from './shared/tx-details-shared';
+import { TableCell, TableRow, TableWithTbody } from '../../table';
+import type { components } from '../../../../types/explorer';
+import { MarketLink } from '../../links';
+
+interface TxDetailsUpdateMarginModeProps {
+  txData: BlockExplorerTransactionResult | undefined;
+  pubKey: string | undefined;
+  blockData: TendermintBlocksResponse | undefined;
+}
+
+type Mode = components['schemas']['UpdateMarginModeMode'];
+
+const MarginModeLabels: Record<Mode, string> = {
+  MODE_CROSS_MARGIN: t('Cross margin'),
+  MODE_ISOLATED_MARGIN: t('Isolated margin'),
+  MODE_UNSPECIFIED: t('Unspecified'),
+};
+
+export const TxDetailsUpdateMarginMode = ({
+  txData,
+  pubKey,
+  blockData,
+}: TxDetailsUpdateMarginModeProps) => {
+  if (!txData || !txData.command.updateMarginMode) {
+    return <>{t('Awaiting Block Explorer transaction details')}</>;
+  }
+
+  const u: components['schemas']['v1UpdateMarginMode'] =
+    txData.command.updateMarginMode;
+
+  return (
+    <TableWithTbody className="mb-8" allowWrap={true}>
+      <TxDetailsShared txData={txData} pubKey={pubKey} blockData={blockData} />
+      {u.marketId && (
+        <TableRow modifier="bordered">
+          <TableCell>{t('Market ID')}</TableCell>
+          <TableCell>
+            <MarketLink id={u.marketId} />
+          </TableCell>
+        </TableRow>
+      )}
+      {u.mode && (
+        <TableRow modifier="bordered">
+          <TableCell>{t('New margin mode')}</TableCell>
+          <TableCell>{MarginModeLabels[u.mode]}</TableCell>
+        </TableRow>
+      )}
+      {u.marginFactor && (
+        <TableRow modifier="bordered">
+          <TableCell>{t('Margin factor')}</TableCell>
+          <TableCell>{u.marginFactor}</TableCell>
+        </TableRow>
+      )}
+    </TableWithTbody>
+  );
+};

apps/explorer/src/app/components/txs/lib/proposal-to-transfer.ts

@@ -0,0 +1,29 @@
+import type { components } from '../../../../types/explorer';
+
+type TransferProposal = components['schemas']['vegaNewTransferConfiguration'];
+type ActualTransfer = components['schemas']['commandsv1Transfer'];
+
+/**
+ * Converts a governance proposal for a transfer in to a transfer command that the
+ * TransferDetails component can then render. The types are very similar, but do not
+ * map precisely to each other due to some missing fields and some different field
+ * names.
+ *
+ * @param proposal Governance proposal for a transfer
+ * @returns transfer a Transfer object as if it had been submitted
+ */
+export function proposalToTransfer(proposal: TransferProposal): ActualTransfer {
+  return {
+    amount: proposal.amount,
+    asset: proposal.asset,
+    // On a transfer, 'from' is determined by the submitter, so there is no 'from' field
+    // fromAccountType does exist and is just named differently on the proposal
+    fromAccountType: proposal.sourceType,
+    oneOff: proposal.oneOff,
+    recurring: proposal.recurring,
+    // There is no reference applied on governance initiated transfers
+    reference: '',
+    to: proposal.destination,
+    toAccountType: proposal.destinationType,
+  };
+}

apps/explorer/src/app/components/txs/tx-filter.tsx

@@ -20,6 +20,7 @@ export type FilterOption =
   | 'Amend Order'
   | 'Apply Referral Code'
   | 'Batch Market Instructions'
+  | 'Batch Proposal'
   | 'Cancel LiquidityProvision Order'
   | 'Cancel Order'
   | 'Cancel Transfer Funds'
@@ -44,6 +45,7 @@ export type FilterOption =
   | 'Transfer Funds'
   | 'Undelegate'
   | 'Update Referral Set'
+  | 'Update Margin Mode'
   | 'Validator Heartbeat'
   | 'Vote on Proposal'
   | 'Withdraw';
@@ -59,13 +61,20 @@ export const filterOptions: Record<string, FilterOption[]> = {
     'Stop Orders Submission',
     'Stop Orders Cancellation',
     'Submit Order',
+    'Update Margin Mode',
   ],
   'Transfers and Withdrawals': [
     'Transfer Funds',
     'Cancel Transfer Funds',
     'Withdraw',
   ],
-  Governance: ['Delegate', 'Undelegate', 'Vote on Proposal', 'Proposal'],
+  Governance: [
+    'Batch Proposal',
+    'Delegate',
+    'Undelegate',
+    'Vote on Proposal',
+    'Proposal',
+  ],
   Referrals: [
     'Apply Referral Code',
     'Create Referral Set',

apps/trading/client-pages/competitions/competitions-create-team.tsx

@@ -31,7 +31,7 @@ export const CompetitionsCreateTeam = () => {
         <div className="mx-auto md:w-2/3 max-w-xl">
           <Box className="flex flex-col gap-4">
             <h1 className="calt text-2xl lg:text-3xl xl:text-4xl">
-              {t('Create a team')}
+              {isSolo ? t('Create solo team') : t('Create a team')}
             </h1>
             {pubKey && !isReadOnly ? (
               <CreateTeamFormContainer isSolo={isSolo} />
@@ -71,18 +71,27 @@ const CreateTeamFormContainer = ({ isSolo }: { isSolo: boolean }) => {
 
   if (status === 'confirmed') {
     return (
-      <div className="flex flex-col items-start gap-2">
+      <div
+        className="flex flex-col items-start gap-2"
+        data-testid="team-creation-success-message"
+      >
         <p className="text-sm">{t('Team creation transaction successful')}</p>
         {code && (
           <>
             <p className="text-sm">
               Your team ID is:{' '}
-              <span className="font-mono break-all">{code}</span>
+              <span
+                className="font-mono break-all"
+                data-testid="team-id-display"
+              >
+                {code}
+              </span>
             </p>
             <TradingAnchorButton
               href={Links.COMPETITIONS_TEAM(code)}
               intent={Intent.Info}
               size="small"
+              data-testid="view-team-button"
             >
               {t('View team')}
             </TradingAnchorButton>
@@ -125,7 +134,7 @@ const CreateTeamFormContainer = ({ isSolo }: { isSolo: boolean }) => {
       onSubmit={onSubmit}
       status={status}
       err={err}
-      isSolo={isSolo}
+      isCreatingSoloTeam={isSolo}
     />
   );
 };

apps/trading/client-pages/competitions/competitions-home.tsx

@@ -16,6 +16,8 @@ import { CompetitionsLeaderboard } from '../../components/competitions/competiti
 import { useTeams } from '../../lib/hooks/use-teams';
 import take from 'lodash/take';
 import { usePageTitle } from '../../lib/hooks/use-page-title';
+import { TeamCard } from '../../components/competitions/team-card';
+import { useMyTeam } from '../../lib/hooks/use-my-team';
 
 export const CompetitionsHome = () => {
   const t = useT();
@@ -31,10 +33,14 @@ export const CompetitionsHome = () => {
     currentEpoch,
   });
 
-  const { data: teamsData, loading: teamsLoading } = useTeams({
-    sortByField: ['totalQuantumRewards'],
-    order: 'desc',
-  });
+  const { data: teamsData, loading: teamsLoading } = useTeams();
+
+  const {
+    team: myTeam,
+    stats: myTeamStats,
+    games: myTeamGames,
+    rank: myTeamRank,
+  } = useMyTeam();
 
   return (
     <ErrorBoundary>
@@ -46,65 +52,83 @@ export const CompetitionsHome = () => {
         </p>
       </CompetitionsHeader>
 
-      {/** Get started */}
-      <h2 className="text-2xl mb-6">{t('Get started')}</h2>
+      {/** Team card */}
+      {myTeam ? (
+        <>
+          <h2 className="text-2xl mb-6">{t('My team')}</h2>
+          <div className="mb-12">
+            <TeamCard
+              team={myTeam}
+              rank={myTeamRank}
+              stats={myTeamStats}
+              games={myTeamGames}
+            />
+          </div>
+        </>
+      ) : (
+        <>
+          {/** Get started */}
+          <h2 className="text-2xl mb-6">{t('Get started')}</h2>
 
-      <CompetitionsActionsContainer>
-        <CompetitionsAction
-          variant="A"
-          title={t('Create a team')}
-          description={t(
-            'Lorem ipsum dolor sit amet, consectetur adipisicing elit placeat ipsum minus nemo error dicta.'
-          )}
-          actionElement={
-            <TradingButton
-              intent={Intent.Primary}
-              onClick={(e) => {
-                e.preventDefault();
-                navigate(Links.COMPETITIONS_CREATE_TEAM());
-              }}
-            >
-              {t('Create a public team')}
-            </TradingButton>
-          }
-        />
-        <CompetitionsAction
-          variant="B"
-          title={t('Solo team / lone wolf')}
-          description={t(
-            'Lorem ipsum dolor sit amet, consectetur adipisicing elit placeat ipsum minus nemo error dicta.'
-          )}
-          actionElement={
-            <TradingButton
-              intent={Intent.Primary}
-              onClick={(e) => {
-                e.preventDefault();
-                navigate(Links.COMPETITIONS_CREATE_TEAM_SOLO());
-              }}
-            >
-              {t('Create a private team')}
-            </TradingButton>
-          }
-        />
-        <CompetitionsAction
-          variant="C"
-          title={t('Join a team')}
-          description={t(
-            'Lorem ipsum dolor sit amet, consectetur adipisicing elit placeat ipsum minus nemo error dicta.'
-          )}
-          actionElement={
-            <TradingButton
-              intent={Intent.Primary}
-              onClick={(e) => {
-                e.preventDefault();
-                navigate(Links.COMPETITIONS_TEAMS());
-              }}
-            >
-              {t('Choose a team')}
-            </TradingButton>
-          }
-        />
-      </CompetitionsActionsContainer>
+          <CompetitionsActionsContainer>
+            <CompetitionsAction
+              variant="A"
+              title={t('Create a team')}
+              description={t(
+                'Lorem ipsum dolor sit amet, consectetur adipisicing elit placeat ipsum minus nemo error dicta.'
+              )}
+              actionElement={
+                <TradingButton
+                  intent={Intent.Primary}
+                  onClick={(e) => {
+                    e.preventDefault();
+                    navigate(Links.COMPETITIONS_CREATE_TEAM());
+                  }}
+                  data-testId="create-public-team-button"
+                >
+                  {t('Create a public team')}
+                </TradingButton>
+              }
+            />
+            <CompetitionsAction
+              variant="B"
+              title={t('Solo team / lone wolf')}
+              description={t(
+                'Lorem ipsum dolor sit amet, consectetur adipisicing elit placeat ipsum minus nemo error dicta.'
+              )}
+              actionElement={
+                <TradingButton
+                  intent={Intent.Primary}
+                  onClick={(e) => {
+                    e.preventDefault();
+                    navigate(Links.COMPETITIONS_CREATE_TEAM_SOLO());
+                  }}
+                >
+                  {t('Create a private team')}
+                </TradingButton>
+              }
+            />
+            <CompetitionsAction
+              variant="C"
+              title={t('Join a team')}
+              description={t(
+                'Lorem ipsum dolor sit amet, consectetur adipisicing elit placeat ipsum minus nemo error dicta.'
+              )}
+              actionElement={
+                <TradingButton
+                  intent={Intent.Primary}
+                  onClick={(e) => {
+                    e.preventDefault();
+                    navigate(Links.COMPETITIONS_TEAMS());
+                  }}
+                >
+                  {t('Choose a team')}
+                </TradingButton>
+              }
+            />
+          </CompetitionsActionsContainer>
+        </>
+      )}
 
       {/** List of available games */}
       <h2 className="text-2xl mb-6">{t('Games')}</h2>

apps/trading/client-pages/competitions/competitions-team.tsx

@@ -38,12 +38,11 @@ export const CompetitionsTeam = () => {
 const TeamPageContainer = ({ teamId }: { teamId: string | undefined }) => {
   const t = useT();
   const { pubKey } = useVegaWallet();
-  const { team, partyTeam, stats, members, games, loading, refetch } = useTeam(
-    teamId,
-    pubKey || undefined
-  );
+  const { data, team, partyTeam, stats, members, games, loading, refetch } =
+    useTeam(teamId, pubKey || undefined);
 
-  if (loading) {
+  // only show spinner on first load so when users join teams its smoother
+  if (!data && loading) {
     return (
       <Splash>
         <Loader />
@@ -100,8 +99,10 @@ const TeamPage = ({
           >
             {team.name}
           </h1>
-          <JoinTeam team={team} partyTeam={partyTeam} refetch={refetch} />
-          <UpdateTeamButton team={team} />
+          <div className="flex gap-2">
+            <JoinTeam team={team} partyTeam={partyTeam} refetch={refetch} />
+            <UpdateTeamButton team={team} />
+          </div>
         </div>
       </header>
       <TeamStats stats={stats} members={members} games={games} />
@@ -184,7 +185,10 @@ const Members = ({ members }: { members?: Member[] }) => {
 
   const data = orderBy(
     members.map((m) => ({
-      referee: <RefereeLink pubkey={m.referee} />,
+      referee: <RefereeLink pubkey={m.referee} isCreator={m.isCreator} />,
+      rewards: formatNumber(m.totalQuantumRewards),
+      volume: formatNumber(m.totalQuantumVolume),
+      gamesPlayed: formatNumber(m.totalGamesPlayed),
       joinedAt: getDateTimeFormat().format(new Date(m.joinedAt)),
       joinedAtEpoch: Number(m.joinedAtEpoch),
     })),
@@ -195,7 +199,10 @@ const Members = ({ members }: { members?: Member[] }) => {
   return (
     <Table
       columns={[
-        { name: 'referee', displayName: t('Referee') },
+        { name: 'referee', displayName: t('Member ID') },
+        { name: 'rewards', displayName: t('Rewards earned') },
+        { name: 'volume', displayName: t('Total volume') },
+        { name: 'gamesPlayed', displayName: t('Games played') },
         {
           name: 'joinedAt',
           displayName: t('Joined at'),
@@ -211,14 +218,24 @@ const Members = ({ members }: { members?: Member[] }) => {
   );
 };
 
-const RefereeLink = ({ pubkey }: { pubkey: string }) => {
+const RefereeLink = ({
+  pubkey,
+  isCreator,
+}: {
+  pubkey: string;
+  isCreator: boolean;
+}) => {
+  const t = useT();
   const linkCreator = useLinks(DApp.Explorer);
   const link = linkCreator(EXPLORER_PARTIES.replace(':id', pubkey));
 
   return (
-    <Link to={link} target="_blank" className="underline underline-offset-4">
-      {truncateMiddle(pubkey)}
-    </Link>
+    <>
+      <Link to={link} target="_blank" className="underline underline-offset-4">
+        {truncateMiddle(pubkey)}
+      </Link>{' '}
+      <span className="text-muted text-xs">{isCreator ? t('Owner') : ''}</span>
+    </>
   );
 };
 

apps/trading/client-pages/competitions/competitions-teams.tsx

@@ -17,10 +17,7 @@ export const CompetitionsTeams = () => {
 
   usePageTitle([t('Competitions'), t('Teams')]);
 
-  const { data: teamsData, loading: teamsLoading } = useTeams({
-    sortByField: ['totalQuantumRewards'],
-    order: 'desc',
-  });
+  const { data: teamsData, loading: teamsLoading } = useTeams();
 
   const inputRef = useRef<HTMLInputElement>(null);
   const [filter, setFilter] = useState<string | null | undefined>(undefined);

apps/trading/client-pages/competitions/competitions-update-team.tsx

@@ -98,7 +98,7 @@ const UpdateTeamFormContainer = ({
       type={TransactionType.UpdateReferralSet}
       status={status}
       err={err}
-      isSolo={team.closed}
+      isCreatingSoloTeam={team.closed}
       onSubmit={onSubmit}
       defaultValues={defaultValues}
     />

apps/trading/client-pages/competitions/join-team.tsx

@@ -6,11 +6,7 @@ import {
   VegaIcon,
   VegaIconNames,
 } from '@vegaprotocol/ui-toolkit';
-import {
-  useSimpleTransaction,
-  useVegaWallet,
-  type Status,
-} from '@vegaprotocol/wallet';
+import { useSimpleTransaction, useVegaWallet } from '@vegaprotocol/wallet';
 import { useT } from '../../lib/use-t';
 import { type Team } from '../../lib/hooks/use-team';
 import { useState } from 'react';
@@ -27,19 +23,8 @@ export const JoinTeam = ({
   refetch: () => void;
 }) => {
   const { pubKey, isReadOnly } = useVegaWallet();
-  const { send, status } = useSimpleTransaction({
-    onSuccess: refetch,
-  });
   const [confirmDialog, setConfirmDialog] = useState<JoinType>();
 
-  const joinTeam = () => {
-    send({
-      joinTeam: {
-        id: team.teamId,
-      },
-    });
-  };
-
   return (
     <>
       <JoinButton
@@ -56,11 +41,10 @@ export const JoinTeam = ({
         {confirmDialog !== undefined && (
           <DialogContent
             type={confirmDialog}
-            status={status}
             team={team}
             partyTeam={partyTeam}
-            onConfirm={joinTeam}
             onCancel={() => setConfirmDialog(undefined)}
+            refetch={refetch}
           />
         )}
       </Dialog>
@@ -110,7 +94,7 @@ export const JoinButton = ({
       // Not creator of the team, but still can't switch because
       // creators cannot leave their own team
       return (
-        <Tooltip description="As a team creator, you cannot switch teams">
+        <Tooltip description={t('As a team creator, you cannot switch teams')}>
           <Button intent={Intent.Primary} disabled={true}>
             {t('Switch team')}{' '}
           </Button>
@@ -121,7 +105,11 @@ export const JoinButton = ({
   // Party is in a team, but not this one
   else if (partyTeam && partyTeam.teamId !== team.teamId) {
     return (
-      <Button onClick={() => onJoin('switch')} intent={Intent.Primary}>
+      <Button
+        onClick={() => onJoin('switch')}
+        intent={Intent.Primary}
+        data-testid="switch-team-button"
+      >
         {t('Switch team')}{' '}
       </Button>
     );
@@ -149,21 +137,39 @@ export const JoinButton = ({
 
 const DialogContent = ({
   type,
-  status,
   team,
   partyTeam,
-  onConfirm,
   onCancel,
+  refetch,
 }: {
   type: JoinType;
-  status: Status;
   team: Team;
   partyTeam?: Team;
-  onConfirm: () => void;
   onCancel: () => void;
+  refetch: () => void;
 }) => {
   const t = useT();
 
+  const { send, status, error } = useSimpleTransaction({
+    onSuccess: refetch,
+  });
+
+  const joinTeam = () => {
+    send({
+      joinTeam: {
+        id: team.teamId,
+      },
+    });
+  };
+
+  if (error) {
+    return (
+      <p className="text-vega-red break-words first-letter:capitalize">
+        {error}
+      </p>
+    );
+  }
+
   if (status === 'requested') {
     return <p>{t('Confirm in wallet...')}</p>;
   }
@@ -213,7 +219,11 @@ const DialogContent = ({
         </>
       )}
       <div className="flex justify-between gap-2">
-        <Button onClick={onConfirm} intent={Intent.Success}>
+        <Button
+          onClick={joinTeam}
+          intent={Intent.Success}
+          data-testid="confirm-switch-button"
+        >
           {t('Confirm')}
         </Button>
         <Button onClick={onCancel} intent={Intent.Danger}>

apps/trading/client-pages/competitions/team-form.tsx

@@ -6,6 +6,8 @@ import {
   TextArea,
   TradingButton,
   Intent,
+  VegaIcon,
+  VegaIconNames,
 } from '@vegaprotocol/ui-toolkit';
 import { URL_REGEX, isValidVegaPublicKey } from '@vegaprotocol/utils';
 
@@ -17,6 +19,8 @@ import type {
   UpdateReferralSet,
   Status,
 } from '@vegaprotocol/wallet';
+import classNames from 'classnames';
+import { useLayoutEffect, useState } from 'react';
 
 export type FormFields = {
   id: string;
@@ -28,8 +32,8 @@ export type FormFields = {
 };
 
 export enum TransactionType {
-  CreateReferralSet,
-  UpdateReferralSet,
+  CreateReferralSet = 'CreateReferralSet',
+  UpdateReferralSet = 'UpdateReferralSet',
 }
 
 const prepareTransaction = (
@@ -75,14 +79,14 @@ export const TeamForm = ({
   type,
   status,
   err,
-  isSolo,
+  isCreatingSoloTeam,
   onSubmit,
   defaultValues,
 }: {
   type: TransactionType;
   status: ReturnType<typeof useReferralSetTransaction>['status'];
   err: ReturnType<typeof useReferralSetTransaction>['err'];
-  isSolo: boolean;
+  isCreatingSoloTeam: boolean;
   onSubmit: ReturnType<typeof useReferralSetTransaction>['onSubmit'];
   defaultValues?: FormFields;
 }) => {
@@ -96,7 +100,7 @@ export const TeamForm = ({
     formState: { errors },
   } = useForm<FormFields>({
     defaultValues: {
-      private: isSolo,
+      private: isCreatingSoloTeam,
       ...defaultValues,
     },
   });
@@ -109,16 +113,14 @@ export const TeamForm = ({
 
   return (
     <form onSubmit={handleSubmit(sendTransaction)}>
-      <input
-        type="hidden"
-        {...register('id', {
-          disabled: true,
-        })}
-      />
+      <input type="hidden" {...register('id')} />
       <TradingFormGroup label={t('Team name')} labelFor="name">
-        <TradingInput {...register('name', { required: t('Required') })} />
+        <TradingInput
+          {...register('name', { required: t('Required') })}
+          data-testid="team-name-input"
+        />
         {errors.name?.message && (
-          <TradingInputError forInput="name">
+          <TradingInputError forInput="name" data-testid="team-name-error">
             {errors.name.message}
           </TradingInputError>
         )}
@@ -134,9 +136,10 @@ export const TeamForm = ({
           {...register('url', {
             pattern: { value: URL_REGEX, message: t('Invalid URL') },
           })}
+          data-testid="team-url-input"
         />
         {errors.url?.message && (
-          <TradingInputError forInput="url">
+          <TradingInputError forInput="url" data-testid="team-url-error">
             {errors.url.message}
           </TradingInputError>
         )}
@@ -153,66 +156,86 @@ export const TeamForm = ({
               message: t('Invalid image URL'),
             },
           })}
+          data-testid="avatar-url-input"
         />
         {errors.avatarUrl?.message && (
-          <TradingInputError forInput="avatarUrl">
+          <TradingInputError
+            forInput="avatarUrl"
+            data-testid="avatar-url-error"
+          >
             {errors.avatarUrl.message}
           </TradingInputError>
         )}
       </TradingFormGroup>
-      <TradingFormGroup
-        label={t('Make team private')}
-        labelFor="private"
-        hideLabel={true}
-      >
-        <Controller
-          name="private"
-          control={control}
-          render={({ field }) => {
-            return (
-              <TradingCheckbox
-                label={t('Make team private')}
-                checked={field.value}
-                onCheckedChange={(value) => {
-                  field.onChange(value);
+      {
+        // allow changing to private/public if editing, but don't show these options if making a solo team
+        (type === TransactionType.UpdateReferralSet || !isCreatingSoloTeam) && (
+          <>
+            <TradingFormGroup
+              label={t('Make team private')}
+              labelFor="private"
+              hideLabel={true}
+            >
+              <Controller
+                name="private"
+                control={control}
+                render={({ field }) => {
+                  return (
+                    <TradingCheckbox
+                      label={t('Make team private')}
+                      checked={field.value}
+                      onCheckedChange={(value) => {
+                        field.onChange(value);
+                      }}
+                      data-testid="team-private-checkbox"
+                    />
+                  );
                 }}
-                disabled={isSolo}
               />
-            );
-          }}
-        />
-      </TradingFormGroup>
-      {isPrivate && (
-        <TradingFormGroup
-          label={t('Public key allow list')}
-          labelFor="allowList"
-          labelDescription={t(
-            'Use a comma separated list to allow only specific public keys to join the team'
-          )}
-        >
-          <TextArea
-            {...register('allowList', {
-              required: t('Required'),
-              disabled: isSolo,
-              validate: {
-                allowList: (value) => {
-                  const publicKeys = parseAllowListText(value);
-                  if (publicKeys.every((pk) => isValidVegaPublicKey(pk))) {
-                    return true;
-                  }
-                  return t('Invalid public key found in allow list');
-                },
-              },
-            })}
-          />
-          {errors.allowList?.message && (
-            <TradingInputError forInput="avatarUrl">
-              {errors.allowList.message}
-            </TradingInputError>
-          )}
-        </TradingFormGroup>
+            </TradingFormGroup>
+            {isPrivate && (
+              <TradingFormGroup
+                label={t('Public key allow list')}
+                labelFor="allowList"
+                labelDescription={t(
+                  'Use a comma separated list to allow only specific public keys to join the team'
+                )}
+              >
+                <TextArea
+                  {...register('allowList', {
+                    required: t('Required'),
+                    validate: {
+                      allowList: (value) => {
+                        const publicKeys = parseAllowListText(value);
+                        if (
+                          publicKeys.every((pk) => isValidVegaPublicKey(pk))
+                        ) {
+                          return true;
+                        }
+                        return t('Invalid public key found in allow list');
+                      },
+                    },
+                  })}
+                  data-testid="team-allow-list-textarea"
+                />
+                {errors.allowList?.message && (
+                  <TradingInputError
+                    forInput="avatarUrl"
+                    data-testid="team-allow-list-error"
+                  >
+                    {errors.allowList.message}
+                  </TradingInputError>
+                )}
+              </TradingFormGroup>
+            )}
+          </>
+        )
+      }
+      {err && (
+        <p className="text-danger text-xs mb-4 first-letter:capitalize">
+          {err}
+        </p>
       )}
-      {err && <p className="text-danger text-xs mb-4 capitalize">{err}</p>}
       <SubmitButton type={type} status={status} />
     </form>
   );
@@ -233,20 +256,61 @@ const SubmitButton = ({
     text = t('Update');
   }
 
+  let confirmedText = t('Created');
+  if (type === TransactionType.UpdateReferralSet) {
+    confirmedText = t('Updated');
+  }
+
   if (status === 'requested') {
     text = t('Confirm in wallet...');
   } else if (status === 'pending') {
     text = t('Confirming transaction...');
   }
 
+  const [showConfirmed, setShowConfirmed] = useState<boolean>(false);
+  useLayoutEffect(() => {
+    let to: ReturnType<typeof setTimeout>;
+    if (status === 'confirmed' && !showConfirmed) {
+      to = setTimeout(() => {
+        setShowConfirmed(true);
+      }, 100);
+    }
+    return () => {
+      clearTimeout(to);
+    };
+  }, [showConfirmed, status]);
+
+  const confirmed = (
+    <span
+      className={classNames('text-sm transition-opacity opacity-0', {
+        'opacity-100': showConfirmed,
+      })}
+    >
+      <VegaIcon
+        name={VegaIconNames.TICK}
+        size={18}
+        className="text-vega-green-500"
+      />{' '}
+      {confirmedText}
+    </span>
+  );
+
   return (
-    <TradingButton type="submit" intent={Intent.Info} disabled={disabled}>
-      {text}
-    </TradingButton>
+    <div className="flex gap-2 items-baseline">
+      <TradingButton
+        type="submit"
+        intent={Intent.Info}
+        disabled={disabled}
+        data-testid="team-form-submit-button"
+      >
+        {text}
+      </TradingButton>
+      {status === 'confirmed' && confirmed}
+    </div>
   );
 };
 
-const parseAllowListText = (str: string) => {
+const parseAllowListText = (str: string = '') => {
   return str
     .split(',')
     .map((v) => v.trim())

apps/trading/client-pages/competitions/update-team-button.tsx

@@ -1,18 +1,30 @@
-import { useVegaWallet } from '@vegaprotocol/wallet';
 import { type Team } from '../../lib/hooks/use-team';
+import { type ComponentProps } from 'react';
+import { useVegaWallet } from '@vegaprotocol/wallet';
 import { Intent, TradingAnchorButton } from '@vegaprotocol/ui-toolkit';
 import { Links } from '../../lib/links';
+import { useT } from '../../lib/use-t';
 
-export const UpdateTeamButton = ({ team }: { team: Team }) => {
+export const UpdateTeamButton = ({
+  team,
+  size = 'medium',
+}: {
+  team: Pick<Team, 'teamId' | 'referrer'>;
+  size?: ComponentProps<typeof TradingAnchorButton>['size'];
+}) => {
+  const t = useT();
   const { pubKey, isReadOnly } = useVegaWallet();
 
   if (pubKey && !isReadOnly && pubKey === team.referrer) {
     return (
       <TradingAnchorButton
+        size={size}
         data-testid="update-team-button"
         href={Links.COMPETITIONS_UPDATE_TEAM(team.teamId)}
         intent={Intent.Info}
-      />
+      >
+        {t('Update team')}
+      </TradingAnchorButton>
     );
   }
 

apps/trading/client-pages/market/market-header-stats.tsx

@@ -19,6 +19,7 @@ import {
   useFundingRate,
   useMarketTradingMode,
   useExternalTwap,
+  getQuoteName,
 } from '@vegaprotocol/markets';
 import { MarketState as State } from '@vegaprotocol/types';
 import { HeaderStat } from '../../components/header';
@@ -41,6 +42,7 @@ export const MarketHeaderStats = ({ market }: MarketHeaderStatsProps) => {
   const { open: openAssetDetailsDialog } = useAssetDetailsDialogStore();
 
   const asset = getAsset(market);
+  const quoteUnit = getQuoteName(market);
 
   return (
     <>
@@ -60,6 +62,8 @@ export const MarketHeaderStats = ({ market }: MarketHeaderStatsProps) => {
         <Last24hVolume
           marketId={market.id}
           positionDecimalPlaces={market.positionDecimalPlaces}
+          marketDecimals={market.decimalPlaces}
+          quoteUnit={quoteUnit}
         />
       </HeaderStat>
       <HeaderStatMarketTradingMode

apps/trading/client-pages/markets/market-list-table.tsx

@@ -5,7 +5,7 @@ import {
   useDataGridEvents,
 } from '@vegaprotocol/datagrid';
 import type { MarketMaybeWithData } from '@vegaprotocol/markets';
-import { useColumnDefs } from './use-column-defs';
+import { useMarketsColumnDefs } from './use-column-defs';
 import type { DataGridStore } from '../../stores/datagrid-store-slice';
 import { type StateCreator, create } from 'zustand';
 import { persist } from 'zustand/middleware';
@@ -50,7 +50,7 @@ export const useMarketsStore = create<DataGridSlice>()(
 );
 
 export const MarketListTable = (props: Props) => {
-  const columnDefs = useColumnDefs();
+  const columnDefs = useMarketsColumnDefs();
   const gridStore = useMarketsStore((store) => store.gridStore);
   const updateGridStore = useMarketsStore((store) => store.updateGridStore);
 

apps/trading/client-pages/markets/use-column-defs.tsx

@@ -7,21 +7,31 @@ import type {
 } from '@vegaprotocol/datagrid';
 import { COL_DEFS, SetFilter } from '@vegaprotocol/datagrid';
 import * as Schema from '@vegaprotocol/types';
-import { addDecimalsFormatNumber, toBigNum } from '@vegaprotocol/utils';
+import {
+  addDecimalsFormatNumber,
+  formatNumber,
+  toBigNum,
+} from '@vegaprotocol/utils';
 import { ButtonLink, Tooltip } from '@vegaprotocol/ui-toolkit';
 import { useAssetDetailsDialogStore } from '@vegaprotocol/assets';
 import type {
+  MarketFieldsFragment,
   MarketMaybeWithData,
   MarketMaybeWithDataAndCandles,
 } from '@vegaprotocol/markets';
 import { MarketActionsDropdown } from './market-table-actions';
-import { calcCandleVolume, getAsset } from '@vegaprotocol/markets';
+import {
+  calcCandleVolume,
+  calcCandleVolumePrice,
+  getAsset,
+  getQuoteName,
+} from '@vegaprotocol/markets';
 import { MarketCodeCell } from './market-code-cell';
 import { useT } from '../../lib/use-t';
 
 const { MarketTradingMode, AuctionTrigger } = Schema;
 
-export const useColumnDefs = () => {
+export const useMarketsColumnDefs = () => {
   const t = useT();
   const { open: openAssetDetailsDialog } = useAssetDetailsDialogStore();
   return useMemo<ColDef[]>(
@@ -158,11 +168,25 @@ export const useColumnDefs = () => {
         }: ValueFormatterParams<MarketMaybeWithDataAndCandles, 'candles'>) => {
           const candles = data?.candles;
           const vol = candles ? calcCandleVolume(candles) : '0';
+          const quoteName = getQuoteName(data as MarketFieldsFragment);
+          const volPrice =
+            candles &&
+            calcCandleVolumePrice(
+              candles,
+              data.decimalPlaces,
+              data.positionDecimalPlaces
+            );
+
           const volume =
             data && vol && vol !== '0'
               ? addDecimalsFormatNumber(vol, data.positionDecimalPlaces)
               : '0.00';
-          return volume;
+          const volumePrice =
+            volPrice && formatNumber(volPrice, data?.decimalPlaces);
+
+          return volumePrice
+            ? `${volume} (${volumePrice} ${quoteName})`
+            : volume;
         },
       },
       {

apps/trading/components/competitions/box.tsx

@@ -5,7 +5,11 @@ export const BORDER_COLOR = 'border-vega-clight-500 dark:border-vega-cdark-500';
 export const GRADIENT =
   'bg-gradient-to-b from-vega-clight-800 dark:from-vega-cdark-800 to-transparent';
 
-export const Box = (props: HTMLAttributes<HTMLDivElement>) => {
+export const Box = ({
+  children,
+  backgroundImage,
+  ...props
+}: HTMLAttributes<HTMLDivElement> & { backgroundImage?: string }) => {
   return (
     <div
       {...props}
@@ -13,9 +17,22 @@ export const Box = (props: HTMLAttributes<HTMLDivElement>) => {
         BORDER_COLOR,
         GRADIENT,
         'border rounded-lg',
-        'p-6',
+        'relative p-6 overflow-hidden',
         props.className
       )}
-    />
+    >
+      {Boolean(backgroundImage?.length) && (
+        <div
+          className={classNames(
+            'pointer-events-none',
+            'bg-no-repeat bg-center bg-[length:500px_500px]',
+            'absolute top-0 left-0 w-full h-full -z-10 opacity-30 blur-lg'
+          )}
+          style={{ backgroundImage: `url("${backgroundImage}")` }}
+        ></div>
+      )}
+
+      {children}
+    </div>
   );
 };

apps/trading/components/competitions/team-avatar.tsx

@@ -3,7 +3,7 @@ import classNames from 'classnames';
 const NUM_AVATARS = 20;
 const AVATAR_PATHNAME_PATTERN = '/team-avatars/{id}.png';
 
-const getFallbackAvatar = (teamId: string) => {
+export const getFallbackAvatar = (teamId: string) => {
   const avatarId = ((parseInt(teamId, 16) % NUM_AVATARS) + 1)
     .toString()
     .padStart(2, '0'); // between 01 - 20

apps/trading/components/competitions/team-card.tsx

@@ -0,0 +1,154 @@
+import { type TeamGame, type TeamStats } from '../../lib/hooks/use-team';
+import { type TeamsFieldsFragment } from '../../lib/hooks/__generated__/Teams';
+import { TeamAvatar, getFallbackAvatar } from './team-avatar';
+import { FavoriteGame, Stat } from './team-stats';
+import { useT } from '../../lib/use-t';
+import { formatNumberRounded } from '@vegaprotocol/utils';
+import BigNumber from 'bignumber.js';
+import { Box } from './box';
+import { Intent, Tooltip, TradingAnchorButton } from '@vegaprotocol/ui-toolkit';
+import { Links } from '../../lib/links';
+import orderBy from 'lodash/orderBy';
+import { take } from 'lodash';
+import { DispatchMetricLabels } from '@vegaprotocol/types';
+import classNames from 'classnames';
+import { UpdateTeamButton } from '../../client-pages/competitions/update-team-button';
+
+export const TeamCard = ({
+  rank,
+  team,
+  stats,
+  games,
+}: {
+  rank: number;
+  team: TeamsFieldsFragment;
+  stats?: TeamStats;
+  games?: TeamGame[];
+}) => {
+  const t = useT();
+
+  const lastGames = take(
+    orderBy(
+      games?.map((g) => ({
+        rank: g.team.rank,
+        metric: g.team.rewardMetric,
+        epoch: g.epoch,
+      })),
+      (i) => i.epoch,
+      'desc'
+    ),
+    5
+  );
+
+  return (
+    <div
+      className={classNames(
+        'gap-6 grid grid-cols-1 grid-rows-1',
+        'md:grid-cols-3'
+      )}
+    >
+      {/** Card */}
+      <Box
+        backgroundImage={team.avatarUrl || getFallbackAvatar(team.teamId)}
+        className="flex flex-col items-center gap-3 min-w-[80px] lg:min-w-[112px]"
+      >
+        <TeamAvatar teamId={team.teamId} imgUrl={team.avatarUrl} />
+        <h1 className="calt lg:text-2xl" data-testid="team-name">
+          {team.name}
+        </h1>
+        {games && <FavoriteGame games={games} noLabel />}
+        <TradingAnchorButton
+          size="extra-small"
+          intent={Intent.Primary}
+          href={Links.COMPETITIONS_TEAM(team.teamId)}
+        >
+          {t('Profile')}
+        </TradingAnchorButton>
+        <UpdateTeamButton team={team} size="extra-small" />
+      </Box>
+
+      {/** Tiles */}
+      <Box className="w-full md:col-span-2">
+        <div
+          className={classNames(
+            'grid gap-3 w-full mb-4',
+            'md:grid-cols-3 md:grid-rows-2',
+            'grid-cols-2 grid-rows-3'
+          )}
+        >
+          <Stat
+            className="flex flex-col-reverse"
+            value={rank}
+            label={t('Rank')}
+            valueTestId="team-rank"
+          />
+          <Stat
+            className="flex flex-col-reverse"
+            value={team.totalMembers || 0}
+            label={t('Members')}
+            valueTestId="members-count-stat"
+          />
+          <Stat
+            className="flex flex-col-reverse"
+            value={stats?.totalGamesPlayed || 0}
+            label={t('Total games')}
+            valueTestId="total-games-stat"
+          />
+          <Stat
+            className="flex flex-col-reverse"
+            value={
+              stats?.totalQuantumVolume
+                ? formatNumberRounded(
+                    new BigNumber(stats.totalQuantumVolume || 0),
+                    '1e3'
+                  )
+                : 0
+            }
+            label={t('Total volume')}
+            valueTestId="total-volume-stat"
+          />
+          <Stat
+            className="flex flex-col-reverse"
+            value={
+              stats?.totalQuantumRewards
+                ? formatNumberRounded(
+                    new BigNumber(stats.totalQuantumRewards || 0),
+                    '1e3'
+                  )
+                : 0
+            }
+            label={t('Rewards paid out')}
+            valueTestId="rewards-paid-stat"
+          />
+        </div>
+
+        <dl className="w-full pt-4 border-t border-vega-clight-700 dark:border-vega-cdark-700">
+          <dt className="mb-1 text-sm text-muted">
+            {t('Last {{games}} games result', {
+              replace: { games: lastGames.length || '' },
+            })}
+          </dt>
+          <dd className="flex flex-row flex-wrap gap-2">
+            {lastGames.length === 0 && t('None available')}
+            {lastGames.map((game, i) => (
+              <Tooltip key={i} description={DispatchMetricLabels[game.metric]}>
+                <button className="cursor-help text-sm bg-vega-clight-700 dark:bg-vega-cdark-700 px-2 py-1 rounded-full">
+                  <RankLabel rank={game.rank} />
+                </button>
+              </Tooltip>
+            ))}
+          </dd>
+        </dl>
+      </Box>
+    </div>
+  );
+};
+
+/**
+ * Sets the english ordinal for given rank only if the current language is set
+ * to english.
+ */
+const RankLabel = ({ rank }: { rank: number }) => {
+  const t = useT();
+  return t('place', { count: rank, ordinal: true });
+};

apps/trading/components/competitions/team-stats.tsx

@@ -15,6 +15,7 @@ import {
 } from '../../lib/hooks/use-team';
 import { useT } from '../../lib/use-t';
 import { DispatchMetricLabels, type DispatchMetric } from '@vegaprotocol/types';
+import classNames from 'classnames';
 
 export const TeamStats = ({
   stats,
@@ -102,7 +103,13 @@ const LatestResults = ({ games }: { games: TeamGame[] }) => {
   );
 };
 
-const FavoriteGame = ({ games }: { games: TeamGame[] }) => {
+export const FavoriteGame = ({
+  games,
+  noLabel = false,
+}: {
+  games: TeamGame[];
+  noLabel?: boolean;
+}) => {
   const t = useT();
 
   const rewardMetrics = games.map(
@@ -128,7 +135,13 @@ const FavoriteGame = ({ games }: { games: TeamGame[] }) => {
 
   return (
     <dl className="flex flex-col gap-1">
-      <dt className="text-muted text-sm">{t('Favorite game')}</dt>
+      <dt
+        className={classNames('text-muted text-sm', {
+          hidden: noLabel,
+        })}
+      >
+        {t('Favorite game')}
+      </dt>
       <dd>
         <Pill className="inline-flex items-center gap-1 bg-transparent text-sm">
           <VegaIcon
@@ -142,7 +155,7 @@ const FavoriteGame = ({ games }: { games: TeamGame[] }) => {
   );
 };
 
-const StatSection = ({ children }: { children: ReactNode }) => {
+export const StatSection = ({ children }: { children: ReactNode }) => {
   return (
     <section className="flex flex-col lg:flex-row gap-4 lg:gap-8">
       {children}
@@ -150,11 +163,11 @@ const StatSection = ({ children }: { children: ReactNode }) => {
   );
 };
 
-const StatSectionSeparator = () => {
+export const StatSectionSeparator = () => {
   return <div className="hidden md:block border-r border-default" />;
 };
 
-const StatList = ({ children }: { children: ReactNode }) => {
+export const StatList = ({ children }: { children: ReactNode }) => {
   return (
     <dl className="grid grid-cols-2 md:flex gap-4 md:gap-6 lg:gap-8 whitespace-nowrap">
       {children}
@@ -162,19 +175,21 @@ const StatList = ({ children }: { children: ReactNode }) => {
   );
 };
 
-const Stat = ({
+export const Stat = ({
   value,
   label,
   tooltip,
   valueTestId,
+  className,
 }: {
   value: ReactNode;
   label: ReactNode;
   tooltip?: string;
   valueTestId?: string;
+  className?: classNames.Argument;
 }) => {
   return (
-    <div>
+    <div className={classNames(className)}>
       <dd className="text-3xl lg:text-4xl" data-testid={valueTestId}>
         {value}
       </dd>

apps/trading/components/rewards-container/active-rewards.tsx

@@ -152,7 +152,11 @@ export const ActiveRewards = ({ currentEpoch }: { currentEpoch: number }) => {
   if (!enrichedTransfers || !enrichedTransfers.length) return null;
 
   return (
-    <Card title={t('Active rewards')} className="lg:col-span-full">
+    <Card
+      title={t('Active rewards')}
+      className="lg:col-span-full"
+      data-testid="active-rewards-card"
+    >
       {enrichedTransfers.length > 1 && (
         <TradingInput
           onChange={(e) =>
@@ -312,49 +316,30 @@ export const ActiveRewardCard = ({
         MarketState.STATE_CLOSED,
       ].includes(m.state)
   );
+
   if (marketSettled) {
     return null;
   }
 
-  const assetInSettledMarket =
+  const assetInActiveMarket =
     allMarkets &&
     Object.values(allMarkets).some((m: MarketFieldsFragment | null) => {
       if (m && getAsset(m).id === dispatchStrategy.dispatchMetricAssetId) {
-        return (
-          m?.state &&
-          [
-            MarketState.STATE_TRADING_TERMINATED,
-            MarketState.STATE_SETTLED,
-            MarketState.STATE_CANCELLED,
-            MarketState.STATE_CLOSED,
-          ].includes(m.state)
-        );
+        return m?.state && MarketState.STATE_ACTIVE === m.state;
       }
       return false;
     });
 
-  // Gray out the cards that are related to suspended markets
-  const suspended = transferNode.markets?.some(
+  const marketSuspended = transferNode.markets?.some(
     (m) =>
       m?.state === MarketState.STATE_SUSPENDED ||
       m?.state === MarketState.STATE_SUSPENDED_VIA_GOVERNANCE
   );
 
-  const assetInSuspendedMarket =
-    allMarkets &&
-    Object.values(allMarkets).some((m: MarketFieldsFragment | null) => {
-      if (m && getAsset(m).id === dispatchStrategy.dispatchMetricAssetId) {
-        return (
-          m?.state === MarketState.STATE_SUSPENDED ||
-          m?.state === MarketState.STATE_SUSPENDED_VIA_GOVERNANCE
-        );
-      }
-      return false;
-    });
-
   // Gray out the cards that are related to suspended markets
+  // Or settlement assets in markets that are not active and eligible for rewards
   const { gradientClassName, mainClassName } =
-    suspended || assetInSuspendedMarket || assetInSettledMarket
+    marketSuspended || !assetInActiveMarket
       ? {
           gradientClassName: 'from-vega-cdark-500 to-vega-clight-400',
           mainClassName: 'from-vega-cdark-400 dark:from-vega-cdark-600 to-20%',
@@ -371,6 +356,7 @@ export const ActiveRewardCard = ({
           'rounded-lg',
           gradientClassName
         )}
+        data-testid="active-rewards-card"
       >
         <div
           className={classNames(
@@ -382,7 +368,7 @@ export const ActiveRewardCard = ({
             <div className="flex flex-col gap-2 items-center text-center">
               <EntityIcon transfer={transfer} />
               {entityScope && (
-                <span className="text-muted text-xs">
+                <span className="text-muted text-xs" data-testid="entity-scope">
                   {EntityScopeLabelMapping[entityScope] || t('Unspecified')}
                 </span>
               )}
@@ -390,7 +376,7 @@ export const ActiveRewardCard = ({
 
             <div className="flex flex-col gap-2 items-center text-center">
               <h3 className="flex flex-col gap-1 text-2xl shrink-1 text-center">
-                <span className="font-glitch">
+                <span className="font-glitch" data-testid="reward-value">
                   {addDecimalsFormatNumber(
                     transferNode.transfer.amount,
                     transferNode.transfer.asset?.decimals || 0,
@@ -411,7 +397,7 @@ export const ActiveRewardCard = ({
                   )}
                   underline={true}
                 >
-                  <span className="text-xs">
+                  <span className="text-xs" data-testid="distribution-strategy">
                     {
                       DistributionStrategyMapping[
                         dispatchStrategy.distributionStrategy
@@ -429,7 +415,10 @@ export const ActiveRewardCard = ({
                   'Number of epochs after distribution to delay vesting of rewards by'
                 )}
               />
-              <span className="text-muted text-xs whitespace-nowrap">
+              <span
+                className="text-muted text-xs whitespace-nowrap"
+                data-testid="locked-for"
+              >
                 {t('numberEpochs', '{{count}} epochs', {
                   count: kind.dispatchStrategy?.lockPeriod,
                 })}
@@ -438,15 +427,15 @@ export const ActiveRewardCard = ({
           </div>
 
           <span className="border-[0.5px] border-gray-700" />
-          <span>
+          <span data-testid="dispatch-metric-info">
             {DispatchMetricLabels[dispatchStrategy.dispatchMetric]} •{' '}
             <Tooltip
-              underline={suspended}
+              underline={marketSuspended}
               description={
-                (suspended || assetInSuspendedMarket) &&
+                (marketSuspended || !assetInActiveMarket) &&
                 (specificMarkets
                   ? t('Eligible market(s) currently suspended')
-                  : assetInSuspendedMarket
+                  : !assetInActiveMarket
                   ? t('Currently no markets eligible for reward')
                   : '')
               }
@@ -458,8 +447,8 @@ export const ActiveRewardCard = ({
           <div className="flex items-center gap-8 flex-wrap">
             {kind.endEpoch && (
               <span className="flex flex-col">
-                <span className="text-muted text-xs">{t('Ends in')}</span>
-                <span>
+                <span className="text-muted text-xs">{t('Ends in')} </span>
+                <span data-testid="ends-in">
                   {t('numberEpochs', '{{count}} epochs', {
                     count: kind.endEpoch - currentEpoch,
                   })}
@@ -470,7 +459,7 @@ export const ActiveRewardCard = ({
             {
               <span className="flex flex-col">
                 <span className="text-muted text-xs">{t('Assessed over')}</span>
-                <span>
+                <span data-testid="assessed-over">
                   {t('numberEpochs', '{{count}} epochs', {
                     count: dispatchStrategy.windowLength,
                   })}
@@ -513,7 +502,7 @@ const RewardRequirements = ({
             entity: EntityScopeLabelMapping[dispatchStrategy.entityScope],
           })}
         </dt>
-        <dd className="flex items-center gap-1">
+        <dd className="flex items-center gap-1" data-testid="scope">
           <RewardEntityScope dispatchStrategy={dispatchStrategy} />
         </dd>
       </div>
@@ -522,7 +511,10 @@ const RewardRequirements = ({
         <dt className="flex items-center gap-1 text-muted">
           {t('Staked VEGA')}
         </dt>
-        <dd className="flex items-center gap-1">
+        <dd
+          className="flex items-center gap-1"
+          data-testid="staking-requirement"
+        >
           {addDecimalsFormatNumber(
             dispatchStrategy?.stakingRequirement || 0,
             assetDecimalPlaces
@@ -534,7 +526,7 @@ const RewardRequirements = ({
         <dt className="flex items-center gap-1 text-muted">
           {t('Average position')}
         </dt>
-        <dd className="flex items-center gap-1">
+        <dd className="flex items-center gap-1" data-testid="average-position">
           {addDecimalsFormatNumber(
             dispatchStrategy?.notionalTimeWeightedAveragePositionRequirement ||
               0,

apps/trading/components/settings/settings.tsx

@@ -81,6 +81,7 @@ export const Settings = () => {
               intent={Intent.Primary}
               onClick={() => {
                 localStorage.clear();
+                sessionStorage.clear();
                 window.location.reload();
               }}
             >

apps/trading/e2e/.env

@@ -1,3 +1,3 @@
 CONSOLE_IMAGE_NAME=vegaprotocol/trading:latest
-VEGA_VERSION=v0.74.0-preview.7
+VEGA_VERSION=v0.74.0-preview.8
 LOCAL_SERVER=false

apps/trading/e2e/tests/deal_ticket/test_isolated_cross_margin.py

@@ -38,7 +38,7 @@ def test_switch_cross_isolated_margin(
     expect(page.get_by_test_id("toast-content")).to_have_text(
         "ConfirmedYour transaction has been confirmedView in block explorerUpdate margin modeBTC:DAI_2023Isolated margin mode, leverage: 1.0x")
     expect(page.locator(margin_row).nth(1)
-           ).to_have_text("11,109.99996Isolated1.0x")
+           ).to_have_text("22,109.99996Isolated1.0x")
     # tbd - tooltip is not visible without this wait
     page.wait_for_timeout(1000)
     page.get_by_test_id(tab_positions).get_by_text("Isolated").hover()

apps/trading/e2e/tests/deal_ticket/test_trading_deal_ticket_submit_account.py

@@ -23,7 +23,6 @@ def continuous_market(vega):
     return setup_continuous_market(vega)
 
 
-@pytest.mark.skip("marked id issue #5681")
 @pytest.mark.usefixtures("auth", "risk_accepted")
 def test_should_display_info_and_button_for_deposit(continuous_market, page: Page):
     page.goto(f"/#/markets/{continuous_market}")
@@ -34,7 +33,7 @@ def test_should_display_info_and_button_for_deposit(continuous_market, page: Pag
         "You may not have enough margin available to open this position.")
     page.get_by_test_id(deal_ticket_warning_margin).hover()
     expect(page.get_by_test_id("tooltip-content").nth(0)).to_have_text(
-        "1,661,896.6317 tDAI is currently required.You have only 1,000,000.00.Deposit tDAI")
+        "1,661,888.12901 tDAI is currently required.You have only 999,991.49731.Deposit tDAI")
     page.get_by_test_id(deal_ticket_deposit_dialog_button).nth(0).click()
     expect(page.get_by_test_id("sidebar-content")
            ).to_contain_text("DepositFrom")

apps/trading/e2e/tests/market_lifecycle/test_market_lifecycle.py

@@ -37,7 +37,7 @@ def test_market_lifecycle(proposed_market, vega: VegaServiceNull, page: Page):
     # 6002-MDET-004
     expect(page.get_by_test_id("market-change")).to_have_text("Change (24h)0.00%0.00")
     # 6002-MDET-005
-    expect(page.get_by_test_id("market-volume")).to_have_text("Volume (24h)-")
+    expect(page.get_by_test_id("market-volume")).to_have_text("Volume (24h)- (- BTC)")
     # 6002-MDET-008
     expect(page.get_by_test_id("market-settlement-asset")).to_have_text(
         "Settlement assettDAI"

apps/trading/e2e/tests/rewards/test_filtered_cards.py

@@ -59,7 +59,7 @@ def test_filtered_cards(continuous_market, vega: VegaServiceNull, page: Page):
     next_epoch(vega=vega)
     
     page.reload()
-    expect(page.locator(".from-vega-cdark-400")).to_be_visible(timeout=15000)
+    expect(page.get_by_test_id("active-rewards-card")).to_be_visible(timeout=15000)
     governance.submit_oracle_data(
         wallet=vega.wallet,
         payload={"trading.terminated": "true"},
@@ -67,4 +67,4 @@ def test_filtered_cards(continuous_market, vega: VegaServiceNull, page: Page):
     )
     next_epoch(vega=vega)
     page.reload()
-    expect(page.locator(".from-vega-cdark-400")).not_to_be_in_viewport()
+    expect(page.get_by_test_id("active-rewards-card")).not_to_be_in_viewport()

apps/trading/e2e/tests/teams/test_teams.py

@@ -3,7 +3,7 @@ from playwright.sync_api import expect, Page
 import vega_sim.proto.vega as vega_protos
 from vega_sim.null_service import VegaServiceNull
 from conftest import init_vega
-from actions.utils import next_epoch
+from actions.utils import next_epoch, change_keys
 from fixtures.market import setup_continuous_market
 from conftest import auth_setup, init_page, init_vega, risk_accepted_setup
 from wallet_config import PARTY_A, PARTY_B, PARTY_C, PARTY_D, MM_WALLET
@@ -14,6 +14,7 @@ def vega(request):
     with init_vega(request) as vega:
         yield vega
 
+
 @pytest.fixture(scope="module")
 def team_page(vega, browser, request, setup_teams_and_games):
     with init_page(vega, browser, request) as page:
@@ -23,9 +24,20 @@ def team_page(vega, browser, request, setup_teams_and_games):
         page.goto(f"/#/competitions/teams/{team_id}")
         yield page
 
+
+@pytest.fixture(scope="module")
+def competitions_page(vega, browser, request, setup_teams_and_games):
+    with init_page(vega, browser, request) as page:
+        risk_accepted_setup(page)
+        auth_setup(vega, page)
+        team_id = setup_teams_and_games["team_id"]
+        page.goto(f"/#/competitions/")
+        yield page
+
+
 @pytest.fixture(scope="module")
 def setup_teams_and_games(vega: VegaServiceNull):
-    tDAI_market = setup_continuous_market(vega)
+    tDAI_market = setup_continuous_market(vega, custom_quantum=100000)
     tDAI_asset_id = vega.find_asset_id(symbol="tDAI")
     vega.mint(key_name=PARTY_B.name, asset=tDAI_asset_id, amount=100000)
     vega.mint(key_name=PARTY_C.name, asset=tDAI_asset_id, amount=100000)
@@ -46,6 +58,18 @@ def setup_teams_and_games(vega: VegaServiceNull):
 
     # list_teams actually returns a dictionary {"team_id": Team}
     team_id = list(teams.keys())[0]
+    vega.create_referral_set(
+        key_name="market_maker",
+        name="test",
+        team_url="https://vega.xyz",
+        avatar_url="http://placekitten.com/200/200",
+        closed=False,
+    )
+    next_epoch(vega)
+    teams = vega.list_teams()
+
+    team_id_2 = list(teams.keys())[0]
+    vega.apply_referral_code("Key 1", team_id_2)
 
     vega.apply_referral_code(PARTY_B.name, team_id)
 
@@ -63,7 +87,7 @@ def setup_teams_and_games(vega: VegaServiceNull):
 
     current_epoch = vega.statistics().epoch_seq
     game_start = current_epoch + 1
-    game_end = current_epoch + 11
+    game_end = current_epoch + 14
 
     current_epoch = vega.statistics().epoch_seq
     print(f"[EPOCH: {current_epoch}] creating recurring transfer")
@@ -84,9 +108,42 @@ def setup_teams_and_games(vega: VegaServiceNull):
         factor=1.0,
         start_epoch=game_start,
         end_epoch=game_end,
-        window_length=10
+        window_length=15,
+    )
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()
+    vega.recurring_transfer(
+        from_key_name=PARTY_B.name,
+        from_account_type=vega_protos.vega.ACCOUNT_TYPE_GENERAL,
+        to_account_type=vega_protos.vega.ACCOUNT_TYPE_REWARD_MAKER_PAID_FEES,
+        asset=tDAI_asset_id,
+        reference="reward",
+        asset_for_metric=tDAI_asset_id,
+        metric=vega_protos.vega.DISPATCH_METRIC_MAKER_FEES_PAID,
+        entity_scope=vega_protos.vega.ENTITY_SCOPE_INDIVIDUALS,
+        individual_scope=vega_protos.vega.INDIVIDUAL_SCOPE_IN_TEAM,
+        n_top_performers=1,
+        amount=100,
+        factor=1.0,
+        window_length=15
+    )
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()
+    vega.recurring_transfer(
+        from_key_name=PARTY_C.name,
+        from_account_type=vega_protos.vega.ACCOUNT_TYPE_GENERAL,
+        to_account_type=vega_protos.vega.ACCOUNT_TYPE_REWARD_MAKER_PAID_FEES,
+        asset=tDAI_asset_id,
+        reference="reward",
+        asset_for_metric=tDAI_asset_id,
+        metric=vega_protos.vega.DISPATCH_METRIC_MAKER_FEES_PAID,
+        entity_scope=vega_protos.vega.ENTITY_SCOPE_INDIVIDUALS,
+        individual_scope=vega_protos.vega.INDIVIDUAL_SCOPE_NOT_IN_TEAM,
+        n_top_performers=1,
+        amount=100,
+        factor=1.0,
+        window_length=15
     )
-
     next_epoch(vega)
     print(f"[EPOCH: {vega.statistics().epoch_seq}] starting order activity")
 
@@ -113,6 +170,22 @@ def setup_teams_and_games(vega: VegaServiceNull):
             side="SIDE_BUY",
             volume=1,
         )
+        vega.submit_order(
+            trading_key="Key 1",
+            market_id=tDAI_market,
+            order_type="TYPE_MARKET",
+            time_in_force="TIME_IN_FORCE_IOC",
+            side="SIDE_BUY",
+            volume=1,
+        )
+        vega.submit_order(
+            trading_key="market_maker",
+            market_id=tDAI_market,
+            order_type="TYPE_MARKET",
+            time_in_force="TIME_IN_FORCE_IOC",
+            side="SIDE_BUY",
+            volume=1,
+        )
         next_epoch(vega)
         print(f"[EPOCH: {vega.statistics().epoch_seq}] {i} epoch passed")
 
@@ -120,6 +193,7 @@ def setup_teams_and_games(vega: VegaServiceNull):
         "market_id": tDAI_market,
         "asset_id": tDAI_asset_id,
         "team_id": team_id,
+        "team_id_2": team_id_2,
         "team_name": team_name,
     }
 
@@ -136,65 +210,109 @@ def create_team(vega: VegaServiceNull):
 
     return team_name
 
+
 def test_team_page_games_table(team_page: Page):
     team_page.get_by_test_id("games-toggle").click()
     expect(team_page.get_by_test_id("games-toggle")).to_have_text("Games (1)")
-    expect(team_page.get_by_test_id("rank-0")).to_have_text("1")
-    expect(team_page.get_by_test_id("epoch-0")).to_have_text("18")
-    expect(team_page.get_by_test_id("type-0")).to_have_text("Price maker fees paid")
-    expect(team_page.get_by_test_id("amount-0")).to_have_text("100,000,000")
-    expect(team_page.get_by_test_id("participatingTeams-0")).to_have_text(
-        "1"
-    )
-    expect(team_page.get_by_test_id("participatingMembers-0")).to_have_text(
-        "2"
-    )
+    expect(team_page.get_by_test_id("rank-0")).to_have_text("2")
+    expect(team_page.get_by_test_id("epoch-0")).to_have_text("19")
+    expect(team_page.get_by_test_id("type-0")
+           ).to_have_text("Price maker fees paid")
+    expect(team_page.get_by_test_id("amount-0")).to_have_text("74")
+    expect(team_page.get_by_test_id("participatingTeams-0")).to_have_text("2")
+    expect(team_page.get_by_test_id("participatingMembers-0")).to_have_text("4")
+
 
 def test_team_page_members_table(team_page: Page):
     team_page.get_by_test_id("members-toggle").click()
-    expect(team_page.get_by_test_id("members-toggle")).to_have_text("Members (3)")
+    expect(team_page.get_by_test_id("members-toggle")
+           ).to_have_text("Members (4)")
     expect(team_page.get_by_test_id("referee-0")).to_be_visible()
     expect(team_page.get_by_test_id("joinedAt-0")).to_be_visible()
-    expect(team_page.get_by_test_id("joinedAtEpoch-0")).to_have_text("8")
+    expect(team_page.get_by_test_id("joinedAtEpoch-0")).to_have_text("9")
 
-def test_team_page_headline(team_page: Page, setup_teams_and_games
-):
+
+def test_team_page_headline(team_page: Page, setup_teams_and_games):
     team_name = setup_teams_and_games["team_name"]
     expect(team_page.get_by_test_id("team-name")).to_have_text(team_name)
-    expect(team_page.get_by_test_id("members-count-stat")).to_have_text("3")
+    expect(team_page.get_by_test_id("members-count-stat")).to_have_text("4")
 
-    expect(team_page.get_by_test_id("total-games-stat")).to_have_text(
-        "1"
-    )
+    expect(team_page.get_by_test_id("total-games-stat")).to_have_text("2")
 
     # TODO this still seems wrong as its always 0
-    expect(team_page.get_by_test_id("total-volume-stat")).to_have_text(
-        "0"
-    )
+    expect(team_page.get_by_test_id("total-volume-stat")).to_have_text("0")
 
-    expect(team_page.get_by_test_id("rewards-paid-stat")).to_have_text(
-        "100m"
-    )
+    expect(team_page.get_by_test_id("rewards-paid-stat")).to_have_text("214")
+
+
+def test_switch_teams(team_page: Page, vega: VegaServiceNull):
+    team_page.get_by_test_id("switch-team-button").click()
+    team_page.get_by_test_id("confirm-switch-button").click()
+    expect(team_page.get_by_test_id("dialog-content").first).to_be_visible()
+    vega.wait_fn(1)
+    vega.wait_for_total_catchup()
+    next_epoch(vega=vega)
+    team_page.reload()
+    expect(team_page.get_by_test_id("members-count-stat")).to_have_text("5")
 
-@pytest.fixture(scope="module")
-def competitions_page(vega, browser, request):
-    with init_page(vega, browser, request) as page:
-        risk_accepted_setup(page)
-        auth_setup(vega, page)
-        yield page
 
 def test_leaderboard(competitions_page: Page, setup_teams_and_games):
     team_name = setup_teams_and_games["team_name"]
-    competitions_page.goto(f"/#/competitions/")
-    expect(competitions_page.get_by_test_id("rank-0").locator(".text-yellow-300")).to_have_count(1)
-    expect(competitions_page.get_by_test_id("team-0")).to_have_text(team_name)
-    expect(competitions_page.get_by_test_id("status-0")).to_have_text("Open")
+    competitions_page.reload()
+    expect(
+        competitions_page.get_by_test_id("rank-0").locator(".text-yellow-300")
+    ).to_have_count(1)
+    expect(
+        competitions_page.get_by_test_id(
+            "rank-1").locator(".text-vega-clight-500")
+    ).to_have_count(1)
+    expect(competitions_page.get_by_test_id("team-1")).to_have_text(team_name)
+    expect(competitions_page.get_by_test_id("status-1")).to_have_text("Open")
 
-    expect(competitions_page.get_by_test_id("earned-0")).to_have_text("100,000,000")
-    expect(competitions_page.get_by_test_id("games-0")).to_have_text("1")
+    #  FIXME: the numbers are different we need to clarify this with the backend
+    # expect(competitions_page.get_by_test_id("earned-1")).to_have_text("160")
+    expect(competitions_page.get_by_test_id("games-1")).to_have_text("2")
 
     # TODO  still odd that this is 0
     expect(competitions_page.get_by_test_id("volume-0")).to_have_text("-")
 
-#TODO def test_games(competitions_page: Page):
-#TODO currently no games appear which i think is a bug
+
+def test_game_card(competitions_page: Page):
+    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("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("distribution-strategy")
+           ).to_have_text("Pro rata")
+    expect(game_1.get_by_test_id("dispatch-metric-info")
+           ).to_have_text("Price maker fees paid • ")
+    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("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")
+
+
+def test_create_team(competitions_page: Page, vega: VegaServiceNull):
+    change_keys(competitions_page, vega, "market_maker_2")
+    competitions_page.get_by_test_id("create-public-team-button").click()
+    competitions_page.get_by_test_id("team-name-input").fill("e2e")
+    competitions_page.get_by_test_id("team-url-input").fill("https://vega.xyz")
+    competitions_page.get_by_test_id("avatar-url-input").fill(
+        "http://placekitten.com/200/200"
+    )
+    competitions_page.get_by_test_id("team-form-submit-button").click()
+    expect(competitions_page.get_by_test_id("team-form-submit-button")).to_have_text(
+        "Confirming transaction..."
+    )
+    vega.wait_fn(2)
+    vega.wait_for_total_catchup()
+    expect(
+        competitions_page.get_by_test_id("team-creation-success-message")
+    ).to_be_visible()
+    expect(competitions_page.get_by_test_id("team-id-display")).to_be_visible()
+    expect(competitions_page.get_by_test_id("team-id-display")).to_be_visible()
+    competitions_page.get_by_test_id("view-team-button").click()
+    expect(competitions_page.get_by_test_id("team-name")).to_have_text("e2e")

apps/trading/lib/hooks/Team.graphql

@@ -17,7 +17,7 @@ fragment TeamStatsFields on TeamStatistics {
   totalGamesPlayed
   quantumRewards {
     epoch
-    total_quantum_rewards
+    totalQuantumRewards
   }
   gamesPlayed
 }
@@ -51,6 +51,13 @@ fragment TeamGameFields on Game {
   }
 }
 
+fragment TeamMemberStatsFields on TeamMemberStatistics {
+  partyId
+  totalQuantumVolume
+  totalQuantumRewards
+  totalGamesPlayed
+}
+
 query Team($teamId: ID!, $partyId: ID, $aggregationEpochs: Int) {
   teams(teamId: $teamId) {
     edges {
@@ -87,4 +94,14 @@ query Team($teamId: ID!, $partyId: ID, $aggregationEpochs: Int) {
       }
     }
   }
+  teamMembersStatistics(
+    teamId: $teamId
+    aggregationEpochs: $aggregationEpochs
+  ) {
+    edges {
+      node {
+        ...TeamMemberStatsFields
+      }
+    }
+  }
 }

apps/trading/lib/hooks/Teams.graphql

@@ -1,15 +1,20 @@
+fragment TeamsFields on Team {
+  teamId
+  referrer
+  name
+  teamUrl
+  avatarUrl
+  createdAt
+  createdAtEpoch
+  closed
+  totalMembers
+}
+
 query Teams($teamId: ID, $partyId: ID) {
   teams(teamId: $teamId, partyId: $partyId) {
     edges {
       node {
-        teamId
-        referrer
-        name
-        teamUrl
-        avatarUrl
-        createdAt
-        createdAtEpoch
-        closed
+        ...TeamsFields
       }
     }
   }

apps/trading/lib/hooks/__generated__/Team.ts

@@ -5,7 +5,7 @@ import * as Apollo from '@apollo/client';
 const defaultOptions = {} as const;
 export type TeamFieldsFragment = { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean, allowList: Array<string> };
 
-export type TeamStatsFieldsFragment = { __typename?: 'TeamStatistics', teamId: string, totalQuantumVolume: string, totalQuantumRewards: string, totalGamesPlayed: number, gamesPlayed: Array<string>, quantumRewards: Array<{ __typename?: 'QuantumRewardsPerEpoch', epoch: number, total_quantum_rewards: string }> };
+export type TeamStatsFieldsFragment = { __typename?: 'TeamStatistics', teamId: string, totalQuantumVolume: string, totalQuantumRewards: string, totalGamesPlayed: number, gamesPlayed: Array<string>, quantumRewards: Array<{ __typename?: 'QuantumRewardsPerEpoch', epoch: number, totalQuantumRewards: string }> };
 
 export type TeamRefereeFieldsFragment = { __typename?: 'TeamReferee', teamId: string, referee: string, joinedAt: any, joinedAtEpoch: number };
 
@@ -13,6 +13,8 @@ export type TeamEntityFragment = { __typename?: 'TeamGameEntity', rank: number,
 
 export type TeamGameFieldsFragment = { __typename?: 'Game', id: string, epoch: number, numberOfParticipants: number, entities: Array<{ __typename?: 'IndividualGameEntity' } | { __typename?: 'TeamGameEntity', rank: number, volume: string, rewardMetric: Types.DispatchMetric, rewardEarned: string, totalRewardsEarned: string, team: { __typename?: 'TeamParticipation', teamId: string } }> };
 
+export type TeamMemberStatsFieldsFragment = { __typename?: 'TeamMemberStatistics', partyId: string, totalQuantumVolume: string, totalQuantumRewards: string, totalGamesPlayed: number };
+
 export type TeamQueryVariables = Types.Exact<{
   teamId: Types.Scalars['ID'];
   partyId?: Types.InputMaybe<Types.Scalars['ID']>;
@@ -20,7 +22,7 @@ export type TeamQueryVariables = Types.Exact<{
 }>;
 
 
-export type TeamQuery = { __typename?: 'Query', teams?: { __typename?: 'TeamConnection', edges: Array<{ __typename?: 'TeamEdge', node: { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean, allowList: Array<string> } }> } | null, partyTeams?: { __typename?: 'TeamConnection', edges: Array<{ __typename?: 'TeamEdge', node: { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean, allowList: Array<string> } }> } | null, teamsStatistics?: { __typename?: 'TeamsStatisticsConnection', edges: Array<{ __typename?: 'TeamStatisticsEdge', node: { __typename?: 'TeamStatistics', teamId: string, totalQuantumVolume: string, totalQuantumRewards: string, totalGamesPlayed: number, gamesPlayed: Array<string>, quantumRewards: Array<{ __typename?: 'QuantumRewardsPerEpoch', epoch: number, total_quantum_rewards: string }> } }> } | null, teamReferees?: { __typename?: 'TeamRefereeConnection', edges: Array<{ __typename?: 'TeamRefereeEdge', node: { __typename?: 'TeamReferee', teamId: string, referee: string, joinedAt: any, joinedAtEpoch: number } }> } | null, games: { __typename?: 'GamesConnection', edges?: Array<{ __typename?: 'GameEdge', node: { __typename?: 'Game', id: string, epoch: number, numberOfParticipants: number, entities: Array<{ __typename?: 'IndividualGameEntity' } | { __typename?: 'TeamGameEntity', rank: number, volume: string, rewardMetric: Types.DispatchMetric, rewardEarned: string, totalRewardsEarned: string, team: { __typename?: 'TeamParticipation', teamId: string } }> } } | null> | null } };
+export type TeamQuery = { __typename?: 'Query', teams?: { __typename?: 'TeamConnection', edges: Array<{ __typename?: 'TeamEdge', node: { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean, allowList: Array<string> } }> } | null, partyTeams?: { __typename?: 'TeamConnection', edges: Array<{ __typename?: 'TeamEdge', node: { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean, allowList: Array<string> } }> } | null, teamsStatistics?: { __typename?: 'TeamsStatisticsConnection', edges: Array<{ __typename?: 'TeamStatisticsEdge', node: { __typename?: 'TeamStatistics', teamId: string, totalQuantumVolume: string, totalQuantumRewards: string, totalGamesPlayed: number, gamesPlayed: Array<string>, quantumRewards: Array<{ __typename?: 'QuantumRewardsPerEpoch', epoch: number, totalQuantumRewards: string }> } }> } | null, teamReferees?: { __typename?: 'TeamRefereeConnection', edges: Array<{ __typename?: 'TeamRefereeEdge', node: { __typename?: 'TeamReferee', teamId: string, referee: string, joinedAt: any, joinedAtEpoch: number } }> } | null, games: { __typename?: 'GamesConnection', edges?: Array<{ __typename?: 'GameEdge', node: { __typename?: 'Game', id: string, epoch: number, numberOfParticipants: number, entities: Array<{ __typename?: 'IndividualGameEntity' } | { __typename?: 'TeamGameEntity', rank: number, volume: string, rewardMetric: Types.DispatchMetric, rewardEarned: string, totalRewardsEarned: string, team: { __typename?: 'TeamParticipation', teamId: string } }> } } | null> | null }, teamMembersStatistics?: { __typename?: 'TeamMembersStatisticsConnection', edges: Array<{ __typename?: 'TeamMemberStatisticsEdge', node: { __typename?: 'TeamMemberStatistics', partyId: string, totalQuantumVolume: string, totalQuantumRewards: string, totalGamesPlayed: number } }> } | null };
 
 export const TeamFieldsFragmentDoc = gql`
     fragment TeamFields on Team {
@@ -43,7 +45,7 @@ export const TeamStatsFieldsFragmentDoc = gql`
   totalGamesPlayed
   quantumRewards {
     epoch
-    total_quantum_rewards
+    totalQuantumRewards
   }
   gamesPlayed
 }
@@ -80,6 +82,14 @@ export const TeamGameFieldsFragmentDoc = gql`
   }
 }
     ${TeamEntityFragmentDoc}`;
+export const TeamMemberStatsFieldsFragmentDoc = gql`
+    fragment TeamMemberStatsFields on TeamMemberStatistics {
+  partyId
+  totalQuantumVolume
+  totalQuantumRewards
+  totalGamesPlayed
+}
+    `;
 export const TeamDocument = gql`
     query Team($teamId: ID!, $partyId: ID, $aggregationEpochs: Int) {
   teams(teamId: $teamId) {
@@ -117,11 +127,19 @@ export const TeamDocument = gql`
       }
     }
   }
+  teamMembersStatistics(teamId: $teamId, aggregationEpochs: $aggregationEpochs) {
+    edges {
+      node {
+        ...TeamMemberStatsFields
+      }
+    }
+  }
 }
     ${TeamFieldsFragmentDoc}
 ${TeamStatsFieldsFragmentDoc}
 ${TeamRefereeFieldsFragmentDoc}
-${TeamGameFieldsFragmentDoc}`;
+${TeamGameFieldsFragmentDoc}
+${TeamMemberStatsFieldsFragmentDoc}`;
 
 /**
  * __useTeamQuery__

apps/trading/lib/hooks/__generated__/Teams.ts

@@ -3,33 +3,40 @@ import * as Types from '@vegaprotocol/types';
 import { gql } from '@apollo/client';
 import * as Apollo from '@apollo/client';
 const defaultOptions = {} as const;
+export type TeamsFieldsFragment = { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean, totalMembers: number };
+
 export type TeamsQueryVariables = Types.Exact<{
   teamId?: Types.InputMaybe<Types.Scalars['ID']>;
   partyId?: Types.InputMaybe<Types.Scalars['ID']>;
 }>;
 
 
-export type TeamsQuery = { __typename?: 'Query', teams?: { __typename?: 'TeamConnection', edges: Array<{ __typename?: 'TeamEdge', node: { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean } }> } | null };
-
+export type TeamsQuery = { __typename?: 'Query', teams?: { __typename?: 'TeamConnection', edges: Array<{ __typename?: 'TeamEdge', node: { __typename?: 'Team', teamId: string, referrer: string, name: string, teamUrl: string, avatarUrl: string, createdAt: any, createdAtEpoch: number, closed: boolean, totalMembers: number } }> } | null };
 
+export const TeamsFieldsFragmentDoc = gql`
+    fragment TeamsFields on Team {
+  teamId
+  referrer
+  name
+  teamUrl
+  avatarUrl
+  createdAt
+  createdAtEpoch
+  closed
+  totalMembers
+}
+    `;
 export const TeamsDocument = gql`
     query Teams($teamId: ID, $partyId: ID) {
   teams(teamId: $teamId, partyId: $partyId) {
     edges {
       node {
-        teamId
-        referrer
-        name
-        teamUrl
-        avatarUrl
-        createdAt
-        createdAtEpoch
-        closed
+        ...TeamsFields
       }
     }
   }
 }
-    `;
+    ${TeamsFieldsFragmentDoc}`;
 
 /**
  * __useTeamsQuery__

apps/trading/lib/hooks/use-games.ts

@@ -1,12 +1,23 @@
 import compact from 'lodash/compact';
 import { useActiveRewardsQuery } from '../../components/rewards-container/__generated__/Rewards';
 import { isActiveReward } from '../../components/rewards-container/active-rewards';
-import { EntityScope, type TransferNode } from '@vegaprotocol/types';
+import {
+  EntityScope,
+  IndividualScope,
+  type TransferNode,
+} from '@vegaprotocol/types';
 
 const isScopedToTeams = (node: TransferNode) =>
   node.transfer.kind.__typename === 'RecurringTransfer' &&
-  node.transfer.kind.dispatchStrategy?.entityScope ===
-    EntityScope.ENTITY_SCOPE_TEAMS;
+  // scoped to teams
+  (node.transfer.kind.dispatchStrategy?.entityScope ===
+    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));
 
 export const useGames = ({
   currentEpoch,

apps/trading/lib/hooks/use-my-team.ts

@@ -0,0 +1,25 @@
+import { useVegaWallet } from '@vegaprotocol/wallet';
+import compact from 'lodash/compact';
+import first from 'lodash/first';
+import { useTeamsQuery } from './__generated__/Teams';
+import { useTeam } from './use-team';
+import { useTeams } from './use-teams';
+
+export const useMyTeam = () => {
+  const { pubKey } = useVegaWallet();
+  const { data: teams } = useTeams();
+
+  const { data: maybeMyTeam } = useTeamsQuery({
+    variables: {
+      partyId: pubKey,
+    },
+    skip: !pubKey,
+    fetchPolicy: 'cache-and-network',
+  });
+
+  const team = first(compact(maybeMyTeam?.teams?.edges.map((n) => n.node)));
+  const rank = teams.findIndex((t) => t.teamId === team?.teamId) + 1;
+  const { games, stats } = useTeam(team?.teamId);
+
+  return { team, stats, games, rank };
+};

apps/trading/lib/hooks/use-team.ts

@@ -6,17 +6,24 @@ import {
   type TeamStatsFieldsFragment,
   type TeamRefereeFieldsFragment,
   type TeamEntityFragment,
+  type TeamMemberStatsFieldsFragment,
 } from './__generated__/Team';
 import { DEFAULT_AGGREGATION_EPOCHS } from './use-teams';
 
 export type Team = TeamFieldsFragment;
 export type TeamStats = TeamStatsFieldsFragment;
-export type Member = TeamRefereeFieldsFragment;
+export type Member = TeamRefereeFieldsFragment & {
+  isCreator: boolean;
+  totalGamesPlayed: number;
+  totalQuantumVolume: string;
+  totalQuantumRewards: string;
+};
 export type TeamEntity = TeamEntityFragment;
 export type TeamGame = ReturnType<typeof useTeam>['games'][number];
+export type MemberStats = TeamMemberStatsFieldsFragment;
 
 export const useTeam = (teamId?: string, partyId?: string) => {
-  const { data, loading, error, refetch } = useTeamQuery({
+  const queryResult = useTeamQuery({
     variables: {
       teamId: teamId || '',
       partyId,
@@ -26,7 +33,11 @@ export const useTeam = (teamId?: string, partyId?: string) => {
     fetchPolicy: 'cache-and-network',
   });
 
+  const { data } = queryResult;
+
   const teamEdge = data?.teams?.edges.find((e) => e.node.teamId === teamId);
+  const team = teamEdge?.node;
+
   const partyTeam = data?.partyTeams?.edges?.length
     ? data.partyTeams.edges[0].node
     : undefined;
@@ -34,9 +45,40 @@ export const useTeam = (teamId?: string, partyId?: string) => {
   const teamStatsEdge = data?.teamsStatistics?.edges.find(
     (e) => e.node.teamId === teamId
   );
-  const members = data?.teamReferees?.edges
-    .filter((e) => e.node.teamId === teamId)
-    .map((e) => e.node);
+
+  const memberStats = data?.teamMembersStatistics?.edges.length
+    ? data.teamMembersStatistics.edges.map((e) => e.node)
+    : [];
+
+  const members: Member[] = data?.teamReferees?.edges.length
+    ? data.teamReferees.edges
+        .filter((e) => e.node.teamId === teamId)
+        .map((e) => {
+          const member = e.node;
+          const stats = memberStats.find((m) => m.partyId === member.referee);
+          return {
+            ...member,
+            isCreator: false,
+            totalQuantumVolume: stats ? stats.totalQuantumVolume : '0',
+            totalQuantumRewards: stats ? stats.totalQuantumRewards : '0',
+            totalGamesPlayed: stats ? stats.totalGamesPlayed : 0,
+          };
+        })
+    : [];
+
+  if (team) {
+    const ownerStats = memberStats.find((m) => m.partyId === team.referrer);
+    members.unshift({
+      teamId: team.teamId,
+      referee: team.referrer,
+      joinedAt: team?.createdAt,
+      joinedAtEpoch: team?.createdAtEpoch,
+      isCreator: true,
+      totalQuantumVolume: ownerStats ? ownerStats.totalQuantumVolume : '0',
+      totalQuantumRewards: ownerStats ? ownerStats.totalQuantumRewards : '0',
+      totalGamesPlayed: ownerStats ? ownerStats.totalGamesPlayed : 0,
+    });
+  }
 
   // Find games where the current team participated in
   const gamesWithTeam = compact(data?.games.edges).map((edge) => {
@@ -60,12 +102,9 @@ export const useTeam = (teamId?: string, partyId?: string) => {
   const games = orderBy(compact(gamesWithTeam), 'epoch', 'desc');
 
   return {
-    data,
-    loading,
-    error,
-    refetch,
+    ...queryResult,
     stats: teamStatsEdge?.node,
-    team: teamEdge?.node,
+    team,
     members,
     games,
     partyTeam,

apps/trading/lib/hooks/use-teams.tsx

@@ -1,34 +1,13 @@
+import orderBy from 'lodash/orderBy';
 import { useMemo } from 'react';
-import { type TeamsQuery, useTeamsQuery } from './__generated__/Teams';
-import {
-  type TeamsStatisticsQuery,
-  useTeamsStatisticsQuery,
-} from './__generated__/TeamsStatistics';
+import { useTeamsQuery } from './__generated__/Teams';
+import { useTeamsStatisticsQuery } from './__generated__/TeamsStatistics';
 import compact from 'lodash/compact';
-import sortBy from 'lodash/sortBy';
-import { type ArrayElement } from 'type-fest/source/internal';
 
-type SortableField = keyof Omit<
-  ArrayElement<NonNullable<TeamsQuery['teams']>['edges']>['node'] &
-    ArrayElement<
-      NonNullable<TeamsStatisticsQuery['teamsStatistics']>['edges']
-    >['node'],
-  '__typename'
->;
+// 192
+export const DEFAULT_AGGREGATION_EPOCHS = 192;
 
-type UseTeamsArgs = {
-  aggregationEpochs?: number;
-  sortByField?: SortableField[];
-  order?: 'asc' | 'desc';
-};
-
-export const DEFAULT_AGGREGATION_EPOCHS = 10;
-
-export const useTeams = ({
-  aggregationEpochs = DEFAULT_AGGREGATION_EPOCHS,
-  sortByField = ['createdAtEpoch'],
-  order = 'asc',
-}: UseTeamsArgs) => {
+export const useTeams = (aggregationEpochs = DEFAULT_AGGREGATION_EPOCHS) => {
   const {
     data: teamsData,
     loading: teamsLoading,
@@ -57,12 +36,8 @@ export const useTeams = ({
       ...stats.find((s) => s.teamId === t.teamId),
     }));
 
-    const sorted = sortBy(data, sortByField);
-    if (order === 'desc') {
-      return sorted.reverse();
-    }
-    return sorted;
-  }, [teams, sortByField, order, stats]);
+    return orderBy(data, (d) => Number(d.totalQuantumRewards || 0), 'desc');
+  }, [teams, stats]);
 
   return {
     data,

libs/accounts/src/lib/get-market-account.ts

@@ -1,15 +0,0 @@
-import type { Account } from './accounts-data-provider';
-import * as Schema from '@vegaprotocol/types';
-
-interface Props {
-  accounts: Account[] | null;
-  marketId: string;
-}
-
-export const getMarketAccount = ({ accounts, marketId }: Props) =>
-  accounts?.find((account) => {
-    return (
-      account.market?.id === marketId &&
-      account.type === Schema.AccountType.ACCOUNT_TYPE_MARGIN
-    );
-  }) || null;

libs/accounts/src/lib/index.ts

@@ -6,8 +6,7 @@ export * from './accounts-manager';
 export * from './breakdown-table';
 export * from './use-account-balance';
 export * from './get-settlement-account';
-export * from './use-market-account-balance';
+export * from './use-margin-account-balance';
 export * from './__generated__/Margins';
-export { MarginHealthChart } from './margin-health-chart';
 export * from './margin-data-provider';
 export * from './transfer-container';

libs/accounts/src/lib/margin-data-provider.ts

@@ -83,3 +83,25 @@ export const marketMarginDataProvider = makeDerivedDataProvider<
       (margin) => margin.market.id === marketId
     ) || null
 );
+
+export type MarginModeData = Pick<
+  MarginFieldsFragment,
+  'marginMode' | 'marginFactor'
+>;
+
+export const marginModeDataProvider = makeDerivedDataProvider<
+  MarginModeData,
+  never,
+  MarginsQueryVariables & { marketId: string }
+>([marketMarginDataProvider], ([data], variables, previousData) =>
+  produce(previousData, (draft) => {
+    if (!data) {
+      return data;
+    }
+    const newData = {
+      marginMode: (data as MarginFieldsFragment).marginMode,
+      marginFactor: (data as MarginFieldsFragment).marginFactor,
+    };
+    return draft ? Object.assign(draft, newData) : newData;
+  })
+);

libs/accounts/src/lib/margin-health-chart.tsx

@@ -1,253 +0,0 @@
-import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
-import { useVegaWallet } from '@vegaprotocol/wallet';
-import { Tooltip, ExternalLink } from '@vegaprotocol/ui-toolkit';
-import { useDataProvider } from '@vegaprotocol/data-provider';
-import { marketMarginDataProvider } from './margin-data-provider';
-import { useAssetsMapProvider } from '@vegaprotocol/assets';
-import { useT, ns } from './use-t';
-import { useAccountBalance } from './use-account-balance';
-import { useMarketAccountBalance } from './use-market-account-balance';
-import { Trans } from 'react-i18next';
-
-const MarginHealthChartTooltipRow = ({
-  label,
-  value,
-  decimals,
-  href,
-}: {
-  label: string;
-  value: string;
-  decimals: number;
-  href?: string;
-}) => (
-  <>
-    <div
-      className="float-left clear-left"
-      key="label"
-      data-testid="margin-health-tooltip-label"
-    >
-      {href ? (
-        <ExternalLink href={href} target="_blank">
-          {label}
-        </ExternalLink>
-      ) : (
-        label
-      )}
-    </div>
-    <div
-      className="float-right"
-      key="value"
-      data-testid="margin-health-tooltip-value"
-    >
-      {addDecimalsFormatNumber(value, decimals)}
-    </div>
-  </>
-);
-
-export const MarginHealthChartTooltip = ({
-  maintenanceLevel,
-  searchLevel,
-  initialLevel,
-  collateralReleaseLevel,
-  decimals,
-  marginAccountBalance,
-}: {
-  maintenanceLevel: string;
-  searchLevel: string;
-  initialLevel: string;
-  collateralReleaseLevel: string;
-  decimals: number;
-  marginAccountBalance?: string;
-}) => {
-  const t = useT();
-  const tooltipContent = [
-    <MarginHealthChartTooltipRow
-      key={'maintenance'}
-      label={t('maintenance level')}
-      href="https://docs.vega.xyz/testnet/concepts/trading-on-vega/positions-margin#margin-level-maintenance"
-      value={maintenanceLevel}
-      decimals={decimals}
-    />,
-    <MarginHealthChartTooltipRow
-      key={'search'}
-      label={t('search level')}
-      href="https://docs.vega.xyz/testnet/concepts/trading-on-vega/positions-margin#margin-level-searching-for-collateral"
-      value={searchLevel}
-      decimals={decimals}
-    />,
-    <MarginHealthChartTooltipRow
-      key={'initial'}
-      label={t('initial level')}
-      href="https://docs.vega.xyz/testnet/concepts/trading-on-vega/positions-margin#margin-level-initial"
-      value={initialLevel}
-      decimals={decimals}
-    />,
-    <MarginHealthChartTooltipRow
-      key={'release'}
-      label={t('release level')}
-      href="https://docs.vega.xyz/testnet/concepts/trading-on-vega/positions-margin#margin-level-releasing-collateral"
-      value={collateralReleaseLevel}
-      decimals={decimals}
-    />,
-  ];
-
-  if (marginAccountBalance) {
-    const balance = (
-      <MarginHealthChartTooltipRow
-        key={'balance'}
-        label={t('balance')}
-        value={marginAccountBalance}
-        decimals={decimals}
-      />
-    );
-    if (BigInt(marginAccountBalance) < BigInt(searchLevel)) {
-      tooltipContent.splice(1, 0, balance);
-    } else if (BigInt(marginAccountBalance) < BigInt(initialLevel)) {
-      tooltipContent.splice(2, 0, balance);
-    } else if (BigInt(marginAccountBalance) < BigInt(collateralReleaseLevel)) {
-      tooltipContent.splice(3, 0, balance);
-    } else {
-      tooltipContent.push(balance);
-    }
-  }
-  return (
-    <div className="overflow-hidden" data-testid="margin-health-tooltip">
-      {tooltipContent}
-    </div>
-  );
-};
-
-export const MarginHealthChart = ({
-  marketId,
-  assetId,
-}: {
-  marketId: string;
-  assetId: string;
-}) => {
-  const { data: assetsMap } = useAssetsMapProvider();
-  const { pubKey: partyId } = useVegaWallet();
-  const { data } = useDataProvider({
-    dataProvider: marketMarginDataProvider,
-    variables: { marketId, partyId: partyId ?? '' },
-    skip: !partyId,
-  });
-  const { accountBalance: rawGeneralAccountBalance } =
-    useAccountBalance(assetId);
-  const { accountBalance: rawMarginAccountBalance } =
-    useMarketAccountBalance(marketId);
-  const asset = assetsMap && assetsMap[assetId];
-  if (!data || !asset) {
-    return null;
-  }
-  const { decimals } = asset;
-
-  const collateralReleaseLevel = Number(data.collateralReleaseLevel);
-  const initialLevel = Number(data.initialLevel);
-  const maintenanceLevel = Number(data.maintenanceLevel);
-  const searchLevel = Number(data.searchLevel);
-  const marginAccountBalance = Number(rawMarginAccountBalance);
-  const generalAccountBalance = Number(rawGeneralAccountBalance);
-  const max = Math.max(
-    marginAccountBalance + generalAccountBalance,
-    collateralReleaseLevel
-  );
-
-  const red = maintenanceLevel / max;
-  const orange = (searchLevel - maintenanceLevel) / max;
-  const yellow = ((searchLevel + initialLevel) / 2 - searchLevel) / max;
-  const green = (collateralReleaseLevel - initialLevel) / max + yellow;
-  const balanceMarker = marginAccountBalance / max;
-
-  const tooltip = (
-    <MarginHealthChartTooltip
-      maintenanceLevel={data.maintenanceLevel}
-      searchLevel={data.searchLevel}
-      initialLevel={data.initialLevel}
-      collateralReleaseLevel={data.collateralReleaseLevel}
-      marginAccountBalance={rawMarginAccountBalance}
-      decimals={decimals}
-    />
-  );
-
-  return (
-    <div data-testid="margin-health-chart">
-      <Trans
-        defaults="{{balance}} above <0>maintenance level</0>"
-        components={[
-          <ExternalLink href="https://docs.vega.xyz/testnet/concepts/trading-on-vega/positions-margin#margin-level-maintenance">
-            maintenance level
-          </ExternalLink>,
-        ]}
-        values={{
-          balance: addDecimalsFormatNumber(
-            (
-              BigInt(marginAccountBalance) - BigInt(maintenanceLevel)
-            ).toString(),
-            decimals
-          ),
-        }}
-        ns={ns}
-      />
-      <Tooltip description={tooltip}>
-        <div
-          data-testid="margin-health-chart-track"
-          className="relative bg-vega-green-650"
-          style={{
-            height: '6px',
-            marginBottom: '1px',
-            display: 'flex',
-          }}
-        >
-          <div
-            data-testid="margin-health-chart-red"
-            className="bg-vega-red-550"
-            style={{
-              height: '100%',
-              width: `${red * 100}%`,
-            }}
-          ></div>
-          <div
-            data-testid="margin-health-chart-orange"
-            className="bg-vega-orange"
-            style={{
-              height: '100%',
-              width: `${orange * 100}%`,
-            }}
-          ></div>
-          <div
-            data-testid="margin-health-chart-yellow"
-            className="bg-vega-yellow"
-            style={{
-              height: '100%',
-              width: `${yellow * 100}%`,
-            }}
-          ></div>
-          <div
-            data-testid="margin-health-chart-green"
-            className="bg-vega-green-600"
-            style={{
-              height: '100%',
-              width: `${green * 100}%`,
-            }}
-          ></div>
-          {balanceMarker > 0 && balanceMarker < 100 && (
-            <div
-              data-testid="margin-health-chart-balance"
-              className="absolute bg-vega-blue"
-              style={{
-                height: '8px',
-                width: '8px',
-                top: '-1px',
-                transform: 'translate(-4px, 0px)',
-                borderRadius: '50%',
-                border: '1px solid white',
-                backgroundColor: 'blue',
-                left: `${balanceMarker * 100}%`,
-              }}
-            ></div>
-          )}
-        </div>
-      </Tooltip>
-    </div>
-  );
-};

libs/accounts/src/lib/margin-heath-chart.spec.tsx

@@ -1,158 +0,0 @@
-import {
-  MarginHealthChart,
-  MarginHealthChartTooltip,
-} from './margin-health-chart';
-import { act, render, screen } from '@testing-library/react';
-import type { MarginFieldsFragment } from './__generated__/Margins';
-import type { AssetFieldsFragment } from '@vegaprotocol/assets';
-import { MarginMode } from '@vegaprotocol/types';
-
-const asset: AssetFieldsFragment = {
-  id: 'assetId',
-  decimals: 2,
-} as AssetFieldsFragment;
-const margins: MarginFieldsFragment = {
-  asset: {
-    id: 'assetId',
-  },
-  collateralReleaseLevel: '1000',
-  initialLevel: '800',
-  searchLevel: '600',
-  maintenanceLevel: '400',
-  marginFactor: '',
-  marginMode: MarginMode.MARGIN_MODE_CROSS_MARGIN,
-  orderMarginLevel: '',
-  market: {
-    id: 'marketId',
-  },
-};
-
-const mockGetMargins = jest.fn(() => margins);
-const mockGetBalance = jest.fn(() => '0');
-
-jest.mock('./margin-data-provider', () => ({}));
-
-jest.mock('@vegaprotocol/assets', () => ({
-  useAssetsMapProvider: () => {
-    return {
-      data: {
-        assetId: asset,
-      },
-    };
-  },
-}));
-
-jest.mock('@vegaprotocol/wallet', () => ({
-  useVegaWallet: () => {
-    return {
-      pubKey: 'partyId',
-    };
-  },
-}));
-
-jest.mock('@vegaprotocol/data-provider', () => ({
-  useDataProvider: () => {
-    return {
-      data: mockGetMargins(),
-    };
-  },
-}));
-
-jest.mock('./use-account-balance', () => ({
-  useAccountBalance: () => {
-    return {
-      accountBalance: mockGetBalance(),
-    };
-  },
-}));
-
-jest.mock('./use-market-account-balance', () => ({
-  useMarketAccountBalance: () => {
-    return {
-      accountBalance: '700',
-    };
-  },
-}));
-
-describe('MarginHealthChart', () => {
-  it('should render correct values', async () => {
-    render(<MarginHealthChart marketId="marketId" assetId="assetId" />);
-    const chart = screen.getByTestId('margin-health-chart');
-    expect(chart).toHaveTextContent('3.00 above maintenance level');
-    const red = screen.getByTestId('margin-health-chart-red');
-    const orange = screen.getByTestId('margin-health-chart-orange');
-    const yellow = screen.getByTestId('margin-health-chart-yellow');
-    const green = screen.getByTestId('margin-health-chart-green');
-    const balance = screen.getByTestId('margin-health-chart-balance');
-    expect(parseInt(red.style.width)).toBe(40);
-    expect(parseInt(orange.style.width)).toBe(20);
-    expect(parseInt(yellow.style.width)).toBe(10);
-    expect(parseInt(green.style.width)).toBe(30);
-    expect(parseInt(balance.style.left)).toBe(70);
-  });
-
-  it('should use correct scale', async () => {
-    mockGetBalance.mockReturnValueOnce('1300');
-    await act(async () => {
-      render(<MarginHealthChart marketId="marketId" assetId="assetId" />);
-    });
-    await screen.findByTestId('margin-health-chart');
-    const red = screen.getByTestId('margin-health-chart-red');
-    expect(parseInt(red.style.width)).toBe(20);
-  });
-});
-
-describe('MarginHealthChartTooltip', () => {
-  it('renders correct values and labels', async () => {
-    await act(async () => {
-      render(
-        <MarginHealthChartTooltip
-          {...margins}
-          decimals={asset.decimals}
-          marginAccountBalance="500"
-        />
-      );
-    });
-    const labels = await screen.findAllByTestId('margin-health-tooltip-label');
-    const expectedLabels = [
-      'maintenance level',
-      'balance',
-      'search level',
-      'initial level',
-      'release level',
-    ];
-    labels.forEach((value, i) => {
-      expect(value).toHaveTextContent(expectedLabels[i]);
-    });
-    const values = await screen.findAllByTestId('margin-health-tooltip-value');
-    const expectedValues = ['4.00', '5.00', '6.00', '8.00', '10.00'];
-    values.forEach((value, i) => {
-      expect(value).toHaveTextContent(expectedValues[i]);
-    });
-  });
-
-  it('renders balance in correct place', async () => {
-    const { rerender } = render(
-      <MarginHealthChartTooltip
-        {...margins}
-        decimals={asset.decimals}
-        marginAccountBalance="700"
-      />
-    );
-
-    let values = await screen.findAllByTestId('margin-health-tooltip-value');
-    expect(values[2]).toHaveTextContent('7.00');
-
-    rerender(
-      <MarginHealthChartTooltip
-        {...margins}
-        decimals={asset.decimals}
-        marginAccountBalance="900"
-      />
-    );
-
-    values = await screen.findAllByTestId('margin-health-tooltip-value');
-    expect(values.length).toBe(5);
-    expect(values[3]).toHaveTextContent('9.00');
-  });
-});

libs/accounts/src/lib/transfer-form.spec.tsx

@@ -96,11 +96,6 @@ describe('TransferForm', () => {
   });
 
   it.each([
-    {
-      targetText: 'Include transfer fee',
-      tooltipText:
-        'The fee will be taken from the amount you are transferring.',
-    },
     {
       targetText: 'Transfer fee',
       tooltipText: /transfer\.fee\.factor/,
@@ -276,9 +271,6 @@ describe('TransferForm', () => {
 
     const amountInput = screen.getByLabelText('Amount');
 
-    const checkbox = screen.getByTestId('include-transfer-fee');
-    expect(checkbox).not.toBeChecked();
-
     await userEvent.clear(amountInput);
     await userEvent.type(amountInput, '50');
 
@@ -288,10 +280,7 @@ describe('TransferForm', () => {
     await userEvent.click(screen.getByRole('button', { name: 'Use max' }));
     expect(amountInput).toHaveValue('100.00');
 
-    // If transfering from a vested account 'include fees' checkbox should
-    // be disabled and fees should be 0
-    expect(checkbox).not.toBeChecked();
-    expect(checkbox).toBeDisabled();
+    // If transfering from a vested account  fees should be 0
     const expectedFee = '0';
     const total = new BigNumber(amount).plus(expectedFee).toFixed();
 
@@ -396,78 +385,7 @@ describe('TransferForm', () => {
       });
     });
   });
-
   describe('IncludeFeesCheckbox', () => {
-    it('validates fields and submits when checkbox is checked', async () => {
-      const mockSubmit = jest.fn();
-      renderComponent({ ...props, submitTransfer: mockSubmit });
-
-      // check current pubkey not shown
-      const keySelect = screen.getByLabelText<HTMLSelectElement>('To Vega key');
-      const pubKeyOptions = ['', pubKey, props.pubKeys[1]];
-      expect(keySelect.children).toHaveLength(pubKeyOptions.length);
-      expect(Array.from(keySelect.options).map((o) => o.value)).toEqual(
-        pubKeyOptions
-      );
-
-      await submit();
-      expect(await screen.findAllByText('Required')).toHaveLength(2); // pubkey set as default value
-
-      // Select a pubkey
-      await userEvent.selectOptions(
-        screen.getByLabelText('To Vega key'),
-        props.pubKeys[1]
-      );
-
-      // Select asset
-      await selectAsset(asset);
-
-      await userEvent.selectOptions(
-        screen.getByLabelText('From account'),
-        `${AccountType.ACCOUNT_TYPE_GENERAL}-${asset.id}`
-      );
-
-      const amountInput = screen.getByLabelText('Amount');
-      const checkbox = screen.getByTestId('include-transfer-fee');
-
-      // 1003-TRAN-022
-      expect(checkbox).not.toBeChecked();
-
-      await userEvent.clear(amountInput);
-      await userEvent.type(amountInput, amount);
-      await userEvent.click(checkbox);
-
-      expect(checkbox).toBeChecked();
-      const expectedFee = new BigNumber(amount)
-        .times(props.feeFactor)
-        .toFixed();
-      const expectedAmount = new BigNumber(amount).minus(expectedFee).toFixed();
-
-      // 1003-TRAN-020
-      expect(screen.getByTestId('transfer-fee')).toHaveTextContent(expectedFee);
-      expect(screen.getByTestId('transfer-amount')).toHaveTextContent(
-        expectedAmount
-      );
-      expect(screen.getByTestId('total-transfer-fee')).toHaveTextContent(
-        amount
-      );
-
-      await submit();
-
-      await waitFor(() => {
-        // 1003-TRAN-023
-        expect(mockSubmit).toHaveBeenCalledTimes(1);
-        expect(mockSubmit).toHaveBeenCalledWith({
-          fromAccountType: AccountType.ACCOUNT_TYPE_GENERAL,
-          toAccountType: AccountType.ACCOUNT_TYPE_GENERAL,
-          to: props.pubKeys[1],
-          asset: asset.id,
-          amount: removeDecimal(expectedAmount, asset.decimals),
-          oneOff: {},
-        });
-      });
-    });
-
     it('validates fields when checkbox is not checked', async () => {
       renderComponent(props);
 
@@ -497,11 +415,8 @@ describe('TransferForm', () => {
       );
 
       const amountInput = screen.getByLabelText('Amount');
-      const checkbox = screen.getByTestId('include-transfer-fee');
-      expect(checkbox).not.toBeChecked();
 
       await userEvent.type(amountInput, amount);
-      expect(checkbox).not.toBeChecked();
       const expectedFee = new BigNumber(amount)
         .times(props.feeFactor)
         .toFixed();

libs/accounts/src/lib/transfer-form.tsx

@@ -15,7 +15,6 @@ import {
   TradingRichSelect,
   TradingSelect,
   Tooltip,
-  TradingCheckbox,
   TradingButton,
 } from '@vegaprotocol/ui-toolkit';
 import type { Transfer } from '@vegaprotocol/wallet';
@@ -135,32 +134,17 @@ export const TransferForm = ({
   const accountBalance =
     account && addDecimal(account.balance, account.asset.decimals);
 
-  const [includeFee, setIncludeFee] = useState(false);
-
   // Max amount given selected asset and from account
   const max = accountBalance ? new BigNumber(accountBalance) : new BigNumber(0);
 
-  const transferAmount = useMemo(() => {
-    if (!amount) return undefined;
-    if (includeFee && feeFactor) {
-      return new BigNumber(1).minus(feeFactor).times(amount).toString();
-    }
-    return amount;
-  }, [amount, includeFee, feeFactor]);
-
-  const fee = useMemo(() => {
-    if (!transferAmount) return undefined;
-    if (includeFee) {
-      return new BigNumber(amount).minus(transferAmount).toString();
-    }
-    return (
-      feeFactor && new BigNumber(feeFactor).times(transferAmount).toString()
-    );
-  }, [amount, includeFee, transferAmount, feeFactor]);
+  const fee = useMemo(
+    () => feeFactor && new BigNumber(feeFactor).times(amount).toString(),
+    [amount, feeFactor]
+  );
 
   const onSubmit = useCallback(
     (fields: FormFields) => {
-      if (!transferAmount) {
+      if (!amount) {
         throw new Error('Submitted transfer with no amount selected');
       }
 
@@ -173,7 +157,7 @@ export const TransferForm = ({
 
       const transfer = normalizeTransfer(
         fields.toVegaKey,
-        transferAmount,
+        amount,
         type,
         AccountType.ACCOUNT_TYPE_GENERAL, // field is readonly in the form
         {
@@ -183,7 +167,7 @@ export const TransferForm = ({
       );
       submitTransfer(transfer);
     },
-    [submitTransfer, transferAmount, assets]
+    [submitTransfer, amount, assets]
   );
 
   // reset for placeholder workaround https://github.com/radix-ui/primitives/issues/1569
@@ -279,7 +263,6 @@ export const TransferForm = ({
                   ) {
                     setValue('toVegaKey', pubKey);
                     setToVegaKeyMode('select');
-                    setIncludeFee(false);
                   }
                 }}
               >
@@ -449,27 +432,9 @@ export const TransferForm = ({
           </TradingInputError>
         )}
       </TradingFormGroup>
-      <div className="mb-4">
-        <Tooltip
-          description={t(
-            `The fee will be taken from the amount you are transferring.`
-          )}
-        >
-          <div>
-            <TradingCheckbox
-              name="include-transfer-fee"
-              disabled={!transferAmount || fromVested}
-              label={t('Include transfer fee')}
-              checked={includeFee}
-              onCheckedChange={() => setIncludeFee((x) => !x)}
-            />
-          </div>
-        </Tooltip>
-      </div>
-      {transferAmount && fee && (
+      {amount && fee && (
         <TransferFee
-          amount={transferAmount}
-          transferAmount={transferAmount}
+          amount={amount}
           feeFactor={feeFactor}
           fee={fromVested ? '0' : fee}
           decimals={asset?.decimals}
@@ -484,29 +449,22 @@ export const TransferForm = ({
 
 export const TransferFee = ({
   amount,
-  transferAmount,
   feeFactor,
   fee,
   decimals,
 }: {
   amount: string;
-  transferAmount: string;
   feeFactor: string | null;
   fee?: string;
   decimals?: number;
 }) => {
   const t = useT();
-  if (!feeFactor || !amount || !transferAmount || !fee) return null;
-  if (
-    isNaN(Number(feeFactor)) ||
-    isNaN(Number(amount)) ||
-    isNaN(Number(transferAmount)) ||
-    isNaN(Number(fee))
-  ) {
+  if (!feeFactor || !amount || !fee) return null;
+  if (isNaN(Number(feeFactor)) || isNaN(Number(amount)) || isNaN(Number(fee))) {
     return null;
   }
 
-  const totalValue = new BigNumber(transferAmount).plus(fee).toString();
+  const totalValue = new BigNumber(amount).plus(fee).toString();
 
   return (
     <div className="mb-4 flex flex-col gap-2 text-xs">

libs/accounts/src/lib/use-margin-account-balance.tsx

@@ -0,0 +1,68 @@
+import { useCallback, useMemo, useState } from 'react';
+import { useVegaWallet } from '@vegaprotocol/wallet';
+import { useDataProvider } from '@vegaprotocol/data-provider';
+import { accountsDataProvider } from './accounts-data-provider';
+import type { Account } from './accounts-data-provider';
+import { AccountType } from '@vegaprotocol/types';
+
+export const useMarginAccountBalance = (marketId: string) => {
+  const { pubKey } = useVegaWallet();
+  const [marginAccountBalance, setMarginAccountBalance] = useState<string>('');
+  const [orderMarginAccountBalance, setOrderMarginAccountBalance] =
+    useState<string>('');
+  const [accountDecimals, setAccountDecimals] = useState<number | null>(null);
+  const update = useCallback(
+    ({ data }: { data: Account[] | null }) => {
+      const marginAccount = data?.find((account) => {
+        return (
+          account.market?.id === marketId &&
+          account.type === AccountType.ACCOUNT_TYPE_MARGIN
+        );
+      });
+      const orderMarginAccount = data?.find((account) => {
+        return (
+          account.market?.id === marketId &&
+          account.type === AccountType.ACCOUNT_TYPE_ORDER_MARGIN
+        );
+      });
+      if (marginAccount?.balance) {
+        setMarginAccountBalance(marginAccount?.balance || '');
+      }
+      if (orderMarginAccount?.balance) {
+        setOrderMarginAccountBalance(orderMarginAccount?.balance || '');
+      }
+
+      const decimals =
+        orderMarginAccount?.asset.decimals || marginAccount?.asset.decimals;
+      if (decimals) {
+        setAccountDecimals(decimals);
+      }
+      return true;
+    },
+    [marketId]
+  );
+  const { loading, error } = useDataProvider({
+    dataProvider: accountsDataProvider,
+    variables: { partyId: pubKey || '' },
+    skip: !pubKey || !marketId,
+    update,
+  });
+
+  return useMemo(
+    () => ({
+      marginAccountBalance: pubKey ? marginAccountBalance : '',
+      orderMarginAccountBalance: pubKey ? orderMarginAccountBalance : '',
+      accountDecimals: pubKey ? accountDecimals : null,
+      loading,
+      error,
+    }),
+    [
+      marginAccountBalance,
+      orderMarginAccountBalance,
+      accountDecimals,
+      pubKey,
+      loading,
+      error,
+    ]
+  );
+};

libs/accounts/src/lib/use-market-account-balance.tsx

@@ -1,41 +0,0 @@
-import { useCallback, useMemo, useState } from 'react';
-import { useVegaWallet } from '@vegaprotocol/wallet';
-import { useDataProvider } from '@vegaprotocol/data-provider';
-import { accountsDataProvider } from './accounts-data-provider';
-import type { Account } from './accounts-data-provider';
-import { getMarketAccount } from './get-market-account';
-
-export const useMarketAccountBalance = (marketId: string) => {
-  const { pubKey } = useVegaWallet();
-  const [accountBalance, setAccountBalance] = useState<string>('');
-  const [accountDecimals, setAccountDecimals] = useState<number | null>(null);
-  const update = useCallback(
-    ({ data }: { data: Account[] | null }) => {
-      const account = getMarketAccount({ accounts: data, marketId });
-      if (account?.balance) {
-        setAccountBalance(account?.balance || '');
-      }
-      if (account?.asset.decimals) {
-        setAccountDecimals(account?.asset.decimals || null);
-      }
-      return true;
-    },
-    [marketId]
-  );
-  const { loading, error } = useDataProvider({
-    dataProvider: accountsDataProvider,
-    variables: { partyId: pubKey || '' },
-    skip: !pubKey || !marketId,
-    update,
-  });
-
-  return useMemo(
-    () => ({
-      accountBalance: pubKey ? accountBalance : '',
-      accountDecimals: pubKey ? accountDecimals : null,
-      loading,
-      error,
-    }),
-    [accountBalance, accountDecimals, pubKey, loading, error]
-  );
-};

libs/assets/src/lib/assets-data-provider.ts

@@ -7,6 +7,7 @@ import { AssetsDocument, type AssetsQuery } from './__generated__/Assets';
 import { AssetStatus } from '@vegaprotocol/types';
 import { type Asset } from './asset-data-provider';
 import { DENY_LIST } from './constants';
+import { type AssetFieldsFragment } from './__generated__/Asset';
 
 export interface BuiltinAssetSource {
   __typename: 'BuiltinAsset';
@@ -89,3 +90,24 @@ export const useEnabledAssets = () => {
     variables: undefined,
   });
 };
+
+/** Wrapped ETH symbol */
+const WETH = 'WETH';
+type WETHDetails = Pick<AssetFieldsFragment, 'symbol' | 'decimals' | 'quantum'>;
+/**
+ * Tries to find WETH asset configuration on Vega in order to provide its
+ * details, otherwise it returns hardcoded values.
+ */
+export const useWETH = (): WETHDetails => {
+  const { data } = useAssetsDataProvider();
+  if (data) {
+    const weth = data.find((a) => a.symbol.toUpperCase() === WETH);
+    if (weth) return weth;
+  }
+
+  return {
+    symbol: WETH,
+    decimals: 18,
+    quantum: '500000000000000', // 1 WETH ~= 2000 qUSD
+  };
+};

libs/deal-ticket/src/components/deal-ticket/deal-ticket-fee-details.tsx

@@ -1,47 +1,14 @@
-import { useCallback, useState } from 'react';
-import { getAsset, getQuoteName } from '@vegaprotocol/markets';
+import { getAsset } from '@vegaprotocol/markets';
 import type { OrderSubmissionBody } from '@vegaprotocol/wallet';
-import { useVegaWallet } from '@vegaprotocol/wallet';
-
 import type { Market } from '@vegaprotocol/markets';
-import type { EstimatePositionQuery } from '@vegaprotocol/positions';
-import { AccountBreakdownDialog } from '@vegaprotocol/accounts';
-
-import {
-  formatNumberPercentage,
-  formatRange,
-  formatValue,
-} from '@vegaprotocol/utils';
-import { marketMarginDataProvider } from '@vegaprotocol/accounts';
-import { useDataProvider } from '@vegaprotocol/data-provider';
-import * as AccordionPrimitive from '@radix-ui/react-accordion';
-import * as Schema from '@vegaprotocol/types';
-
-import {
-  MARGIN_DIFF_TOOLTIP_TEXT,
-  DEDUCTION_FROM_COLLATERAL_TOOLTIP_TEXT,
-  TOTAL_MARGIN_AVAILABLE,
-  LIQUIDATION_PRICE_ESTIMATE_TOOLTIP_TEXT,
-  EST_TOTAL_MARGIN_TOOLTIP_TEXT,
-  MARGIN_ACCOUNT_TOOLTIP_TEXT,
-} from '../../constants';
+import { formatNumberPercentage, formatValue } from '@vegaprotocol/utils';
 import { useEstimateFees } from '../../hooks/use-estimate-fees';
 import { KeyValue } from './key-value';
-import {
-  Accordion,
-  AccordionChevron,
-  AccordionPanel,
-  Intent,
-  ExternalLink,
-  Pill,
-  Tooltip,
-} from '@vegaprotocol/ui-toolkit';
-import classNames from 'classnames';
+import { Intent, Pill } from '@vegaprotocol/ui-toolkit';
 import BigNumber from 'bignumber.js';
 import { FeesBreakdown } from '../fees-breakdown';
 import { getTotalDiscountFactor, getDiscountedFee } from '../discounts';
-import { useT, ns } from '../../use-t';
-import { Trans } from 'react-i18next';
+import { useT } from '../../use-t';
 
 export const emptyValue = '-';
 
@@ -119,337 +86,3 @@ export const DealTicketFeeDetails = ({
     />
   );
 };
-
-export interface DealTicketMarginDetailsProps {
-  generalAccountBalance?: string;
-  marginAccountBalance?: string;
-  market: Market;
-  onMarketClick?: (marketId: string, metaKey?: boolean) => void;
-  assetSymbol: string;
-  positionEstimate: EstimatePositionQuery['estimatePosition'];
-  side: Schema.Side;
-}
-
-export const DealTicketMarginDetails = ({
-  marginAccountBalance,
-  generalAccountBalance,
-  assetSymbol,
-  market,
-  onMarketClick,
-  positionEstimate,
-  side,
-}: DealTicketMarginDetailsProps) => {
-  const t = useT();
-  const [breakdownDialog, setBreakdownDialog] = useState(false);
-  const { pubKey: partyId } = useVegaWallet();
-  const { data: currentMargins } = useDataProvider({
-    dataProvider: marketMarginDataProvider,
-    variables: { marketId: market.id, partyId: partyId || '' },
-    skip: !partyId,
-  });
-  const liquidationEstimate = positionEstimate?.liquidation;
-  const marginEstimate = positionEstimate?.margin;
-  const totalBalance =
-    BigInt(generalAccountBalance || '0') + BigInt(marginAccountBalance || '0');
-  const asset = getAsset(market);
-  const { decimals: assetDecimals, quantum } = asset;
-  let marginRequiredBestCase: string | undefined = undefined;
-  let marginRequiredWorstCase: string | undefined = undefined;
-  if (marginEstimate) {
-    if (currentMargins) {
-      marginRequiredBestCase = (
-        BigInt(marginEstimate.bestCase.initialLevel) -
-        BigInt(currentMargins.initialLevel)
-      ).toString();
-      if (marginRequiredBestCase.startsWith('-')) {
-        marginRequiredBestCase = '0';
-      }
-      marginRequiredWorstCase = (
-        BigInt(marginEstimate.worstCase.initialLevel) -
-        BigInt(currentMargins.initialLevel)
-      ).toString();
-      if (marginRequiredWorstCase.startsWith('-')) {
-        marginRequiredWorstCase = '0';
-      }
-    } else {
-      marginRequiredBestCase = marginEstimate.bestCase.initialLevel;
-      marginRequiredWorstCase = marginEstimate.worstCase.initialLevel;
-    }
-  }
-
-  const totalMarginAvailable = (
-    currentMargins
-      ? totalBalance - BigInt(currentMargins.maintenanceLevel)
-      : totalBalance
-  ).toString();
-
-  let deductionFromCollateral = null;
-  let projectedMargin = null;
-  if (marginAccountBalance) {
-    const deductionFromCollateralBestCase =
-      BigInt(marginEstimate?.bestCase.initialLevel ?? 0) -
-      BigInt(marginAccountBalance);
-
-    const deductionFromCollateralWorstCase =
-      BigInt(marginEstimate?.worstCase.initialLevel ?? 0) -
-      BigInt(marginAccountBalance);
-
-    deductionFromCollateral = (
-      <KeyValue
-        indent
-        label={t('Deduction from collateral')}
-        value={formatRange(
-          deductionFromCollateralBestCase > 0
-            ? deductionFromCollateralBestCase.toString()
-            : '0',
-          deductionFromCollateralWorstCase > 0
-            ? deductionFromCollateralWorstCase.toString()
-            : '0',
-          assetDecimals
-        )}
-        formattedValue={formatValue(
-          deductionFromCollateralWorstCase > 0
-            ? deductionFromCollateralWorstCase.toString()
-            : '0',
-          assetDecimals,
-          quantum
-        )}
-        symbol={assetSymbol}
-        labelDescription={t(
-          'DEDUCTION_FROM_COLLATERAL_TOOLTIP_TEXT',
-          DEDUCTION_FROM_COLLATERAL_TOOLTIP_TEXT,
-          { assetSymbol }
-        )}
-      />
-    );
-    projectedMargin = (
-      <KeyValue
-        label={t('Projected margin')}
-        value={formatRange(
-          marginEstimate?.bestCase.initialLevel,
-          marginEstimate?.worstCase.initialLevel,
-          assetDecimals
-        )}
-        formattedValue={formatValue(
-          marginEstimate?.worstCase.initialLevel,
-          assetDecimals,
-          quantum
-        )}
-        symbol={assetSymbol}
-        labelDescription={t(
-          'EST_TOTAL_MARGIN_TOOLTIP_TEXT',
-          EST_TOTAL_MARGIN_TOOLTIP_TEXT
-        )}
-      />
-    );
-  }
-
-  let liquidationPriceEstimate = emptyValue;
-  let liquidationPriceEstimateRange = emptyValue;
-
-  if (liquidationEstimate) {
-    const liquidationEstimateBestCaseIncludingBuyOrders = BigInt(
-      liquidationEstimate.bestCase.including_buy_orders.replace(/\..*/, '')
-    );
-    const liquidationEstimateBestCaseIncludingSellOrders = BigInt(
-      liquidationEstimate.bestCase.including_sell_orders.replace(/\..*/, '')
-    );
-    const liquidationEstimateBestCase =
-      side === Schema.Side.SIDE_BUY
-        ? liquidationEstimateBestCaseIncludingBuyOrders
-        : liquidationEstimateBestCaseIncludingSellOrders;
-
-    const liquidationEstimateWorstCaseIncludingBuyOrders = BigInt(
-      liquidationEstimate.worstCase.including_buy_orders.replace(/\..*/, '')
-    );
-    const liquidationEstimateWorstCaseIncludingSellOrders = BigInt(
-      liquidationEstimate.worstCase.including_sell_orders.replace(/\..*/, '')
-    );
-    const liquidationEstimateWorstCase =
-      side === Schema.Side.SIDE_BUY
-        ? liquidationEstimateWorstCaseIncludingBuyOrders
-        : liquidationEstimateWorstCaseIncludingSellOrders;
-
-    liquidationPriceEstimate = formatValue(
-      liquidationEstimateWorstCase.toString(),
-      market.decimalPlaces,
-      undefined,
-      market.decimalPlaces
-    );
-    liquidationPriceEstimateRange = formatRange(
-      (liquidationEstimateBestCase < liquidationEstimateWorstCase
-        ? liquidationEstimateBestCase
-        : liquidationEstimateWorstCase
-      ).toString(),
-      (liquidationEstimateBestCase > liquidationEstimateWorstCase
-        ? liquidationEstimateBestCase
-        : liquidationEstimateWorstCase
-      ).toString(),
-      market.decimalPlaces,
-      undefined,
-      market.decimalPlaces
-    );
-  }
-
-  const onAccountBreakdownDialogClose = useCallback(
-    () => setBreakdownDialog(false),
-    []
-  );
-
-  const quoteName = getQuoteName(market);
-
-  return (
-    <div className="flex flex-col w-full gap-2 pt-2">
-      <Accordion>
-        <AccordionPanel
-          itemId="margin"
-          trigger={
-            <AccordionPrimitive.Trigger
-              data-testid="accordion-toggle"
-              className={classNames(
-                'w-full',
-                'flex items-center gap-2 text-xs',
-                'group'
-              )}
-            >
-              <div
-                data-testid={`deal-ticket-fee-margin-required`}
-                key={'value-dropdown'}
-                className="flex items-center justify-between w-full gap-2"
-              >
-                <div className="flex items-center text-left gap-1">
-                  <Tooltip
-                    description={t(
-                      'MARGIN_DIFF_TOOLTIP_TEXT',
-                      MARGIN_DIFF_TOOLTIP_TEXT,
-                      { assetSymbol }
-                    )}
-                  >
-                    <span className="text-muted">{t('Margin required')}</span>
-                  </Tooltip>
-
-                  <AccordionChevron size={10} />
-                </div>
-                <Tooltip
-                  description={
-                    formatRange(
-                      marginRequiredBestCase,
-                      marginRequiredWorstCase,
-                      assetDecimals
-                    ) ?? '-'
-                  }
-                >
-                  <div className="font-mono text-right">
-                    {formatValue(
-                      marginRequiredWorstCase,
-                      assetDecimals,
-                      quantum
-                    )}{' '}
-                    {assetSymbol || ''}
-                  </div>
-                </Tooltip>
-              </div>
-            </AccordionPrimitive.Trigger>
-          }
-        >
-          <div className="flex flex-col w-full gap-2">
-            <KeyValue
-              label={t('Total margin available')}
-              indent
-              value={formatValue(totalMarginAvailable, assetDecimals)}
-              formattedValue={formatValue(
-                totalMarginAvailable,
-                assetDecimals,
-                quantum
-              )}
-              symbol={assetSymbol}
-              labelDescription={t(
-                'TOTAL_MARGIN_AVAILABLE',
-                TOTAL_MARGIN_AVAILABLE,
-                {
-                  generalAccountBalance: formatValue(
-                    generalAccountBalance,
-                    assetDecimals,
-                    quantum
-                  ),
-                  marginAccountBalance: formatValue(
-                    marginAccountBalance,
-                    assetDecimals,
-                    quantum
-                  ),
-                  marginMaintenance: formatValue(
-                    currentMargins?.maintenanceLevel,
-                    assetDecimals,
-                    quantum
-                  ),
-                  assetSymbol,
-                }
-              )}
-            />
-            {deductionFromCollateral}
-            <KeyValue
-              label={t('Current margin allocation')}
-              indent
-              onClick={
-                generalAccountBalance
-                  ? () => setBreakdownDialog(true)
-                  : undefined
-              }
-              value={formatValue(marginAccountBalance, assetDecimals)}
-              symbol={assetSymbol}
-              labelDescription={t(
-                'MARGIN_ACCOUNT_TOOLTIP_TEXT',
-                MARGIN_ACCOUNT_TOOLTIP_TEXT
-              )}
-              formattedValue={formatValue(
-                marginAccountBalance,
-                assetDecimals,
-                quantum
-              )}
-            />
-          </div>
-        </AccordionPanel>
-      </Accordion>
-      {projectedMargin}
-      <KeyValue
-        label={t('Liquidation')}
-        value={liquidationPriceEstimateRange}
-        formattedValue={liquidationPriceEstimate}
-        symbol={quoteName}
-        labelDescription={
-          <>
-            <span>
-              {t(
-                'LIQUIDATION_PRICE_ESTIMATE_TOOLTIP_TEXT',
-                LIQUIDATION_PRICE_ESTIMATE_TOOLTIP_TEXT
-              )}
-            </span>{' '}
-            <span>
-              <Trans
-                defaults="For full details please see <0>liquidation price estimate documentation</0>."
-                components={[
-                  <ExternalLink
-                    href={
-                      'https://github.com/vegaprotocol/specs/blob/master/non-protocol-specs/0012-NP-LIPE-liquidation-price-estimate.md'
-                    }
-                  >
-                    liquidation price estimate documentation
-                  </ExternalLink>,
-                ]}
-                ns={ns}
-              />
-            </span>
-          </>
-        }
-      />
-      {partyId && (
-        <AccountBreakdownDialog
-          assetId={breakdownDialog ? asset.id : undefined}
-          partyId={partyId}
-          onMarketClick={onMarketClick}
-          onClose={onAccountBreakdownDialogClose}
-        />
-      )}
-    </div>
-  );
-};

libs/deal-ticket/src/components/deal-ticket/deal-ticket-margin-details.tsx

@@ -3,35 +3,34 @@ import { getAsset, getQuoteName } from '@vegaprotocol/markets';
 import { useVegaWallet } from '@vegaprotocol/wallet';
 import { AccountBreakdownDialog } from '@vegaprotocol/accounts';
 import { formatRange, formatValue } from '@vegaprotocol/utils';
-import { marketMarginDataProvider } from '@vegaprotocol/accounts';
-import { useDataProvider } from '@vegaprotocol/data-provider';
-import * as AccordionPrimitive from '@radix-ui/react-accordion';
 import * as Schema from '@vegaprotocol/types';
 import {
-  MARGIN_DIFF_TOOLTIP_TEXT,
-  DEDUCTION_FROM_COLLATERAL_TOOLTIP_TEXT,
-  TOTAL_MARGIN_AVAILABLE,
   LIQUIDATION_PRICE_ESTIMATE_TOOLTIP_TEXT,
-  EST_TOTAL_MARGIN_TOOLTIP_TEXT,
   MARGIN_ACCOUNT_TOOLTIP_TEXT,
 } from '../../constants';
 import { KeyValue } from './key-value';
-import {
-  Accordion,
-  AccordionChevron,
-  AccordionPanel,
-  ExternalLink,
-  Tooltip,
-} from '@vegaprotocol/ui-toolkit';
-import classNames from 'classnames';
+import { ExternalLink } from '@vegaprotocol/ui-toolkit';
 import { useT, ns } from '../../use-t';
 import { Trans } from 'react-i18next';
-import type { DealTicketMarginDetailsProps } from './deal-ticket-fee-details';
+import type { Market } from '@vegaprotocol/markets';
 import { emptyValue } from './deal-ticket-fee-details';
+import type { EstimatePositionQuery } from '@vegaprotocol/positions';
+
+export interface DealTicketMarginDetailsProps {
+  generalAccountBalance: string;
+  marginAccountBalance: string;
+  orderMarginAccountBalance: string;
+  market: Market;
+  onMarketClick?: (marketId: string, metaKey?: boolean) => void;
+  assetSymbol: string;
+  positionEstimate: EstimatePositionQuery['estimatePosition'];
+  side: Schema.Side;
+}
 
 export const DealTicketMarginDetails = ({
   marginAccountBalance,
   generalAccountBalance,
+  orderMarginAccountBalance,
   assetSymbol,
   market,
   onMarketClick,
@@ -41,107 +40,20 @@ export const DealTicketMarginDetails = ({
   const t = useT();
   const [breakdownDialog, setBreakdownDialog] = useState(false);
   const { pubKey: partyId } = useVegaWallet();
-  const { data: currentMargins } = useDataProvider({
-    dataProvider: marketMarginDataProvider,
-    variables: { marketId: market.id, partyId: partyId || '' },
-    skip: !partyId,
-  });
   const liquidationEstimate = positionEstimate?.liquidation;
-  const marginEstimate = positionEstimate?.margin;
-  const totalBalance =
-    BigInt(generalAccountBalance || '0') + BigInt(marginAccountBalance || '0');
+  const totalMarginAccountBalance =
+    BigInt(marginAccountBalance || '0') +
+    BigInt(orderMarginAccountBalance || '0');
+
   const asset = getAsset(market);
   const { decimals: assetDecimals, quantum } = asset;
-  let marginRequiredBestCase: string | undefined = undefined;
-  let marginRequiredWorstCase: string | undefined = undefined;
-  if (marginEstimate) {
-    if (currentMargins) {
-      marginRequiredBestCase = (
-        BigInt(marginEstimate.bestCase.initialLevel) -
-        BigInt(currentMargins.initialLevel)
-      ).toString();
-      if (marginRequiredBestCase.startsWith('-')) {
-        marginRequiredBestCase = '0';
-      }
-      marginRequiredWorstCase = (
-        BigInt(marginEstimate.worstCase.initialLevel) -
-        BigInt(currentMargins.initialLevel)
-      ).toString();
-      if (marginRequiredWorstCase.startsWith('-')) {
-        marginRequiredWorstCase = '0';
-      }
-    } else {
-      marginRequiredBestCase = marginEstimate.bestCase.initialLevel;
-      marginRequiredWorstCase = marginEstimate.worstCase.initialLevel;
-    }
-  }
 
-  const totalMarginAvailable = (
-    currentMargins
-      ? totalBalance - BigInt(currentMargins.maintenanceLevel)
-      : totalBalance
-  ).toString();
-
-  let deductionFromCollateral = null;
-  let projectedMargin = null;
-  if (marginAccountBalance) {
-    const deductionFromCollateralBestCase =
-      BigInt(marginEstimate?.bestCase.initialLevel ?? 0) -
-      BigInt(marginAccountBalance);
-
-    const deductionFromCollateralWorstCase =
-      BigInt(marginEstimate?.worstCase.initialLevel ?? 0) -
-      BigInt(marginAccountBalance);
-
-    deductionFromCollateral = (
-      <KeyValue
-        indent
-        label={t('Deduction from collateral')}
-        value={formatRange(
-          deductionFromCollateralBestCase > 0
-            ? deductionFromCollateralBestCase.toString()
-            : '0',
-          deductionFromCollateralWorstCase > 0
-            ? deductionFromCollateralWorstCase.toString()
-            : '0',
-          assetDecimals
-        )}
-        formattedValue={formatValue(
-          deductionFromCollateralWorstCase > 0
-            ? deductionFromCollateralWorstCase.toString()
-            : '0',
-          assetDecimals,
-          quantum
-        )}
-        symbol={assetSymbol}
-        labelDescription={t(
-          'DEDUCTION_FROM_COLLATERAL_TOOLTIP_TEXT',
-          DEDUCTION_FROM_COLLATERAL_TOOLTIP_TEXT,
-          { assetSymbol }
-        )}
-      />
-    );
-    projectedMargin = (
-      <KeyValue
-        label={t('Projected margin')}
-        value={formatRange(
-          marginEstimate?.bestCase.initialLevel,
-          marginEstimate?.worstCase.initialLevel,
-          assetDecimals
-        )}
-        formattedValue={formatValue(
-          marginEstimate?.worstCase.initialLevel,
-          assetDecimals,
-          quantum
-        )}
-        symbol={assetSymbol}
-        labelDescription={t(
-          'EST_TOTAL_MARGIN_TOOLTIP_TEXT',
-          EST_TOTAL_MARGIN_TOOLTIP_TEXT
-        )}
-      />
-    );
-  }
+  const collateralIncreaseEstimateBestCase = BigInt(
+    positionEstimate?.collateralIncreaseEstimate.bestCase ?? '0'
+  );
+  const collateralIncreaseEstimateWorstCase = BigInt(
+    positionEstimate?.collateralIncreaseEstimate.worstCase ?? '0'
+  );
 
   let liquidationPriceEstimate = emptyValue;
   let liquidationPriceEstimateRange = emptyValue;
@@ -198,120 +110,50 @@ export const DealTicketMarginDetails = ({
   const quoteName = getQuoteName(market);
 
   return (
-    <div className="flex flex-col w-full gap-2">
-      <Accordion>
-        <AccordionPanel
-          itemId="margin"
-          trigger={
-            <AccordionPrimitive.Trigger
-              data-testid="accordion-toggle"
-              className={classNames(
-                'w-full pt-2',
-                'flex items-center gap-2 text-xs',
-                'group'
-              )}
-            >
-              <div
-                data-testid={`deal-ticket-fee-margin-required`}
-                key={'value-dropdown'}
-                className="flex items-center justify-between w-full gap-2"
-              >
-                <div className="flex items-center text-left gap-1">
-                  <Tooltip
-                    description={t(
-                      'MARGIN_DIFF_TOOLTIP_TEXT',
-                      MARGIN_DIFF_TOOLTIP_TEXT,
-                      { assetSymbol }
-                    )}
-                  >
-                    <span className="text-muted">{t('Margin required')}</span>
-                  </Tooltip>
-
-                  <AccordionChevron size={10} />
-                </div>
-                <Tooltip
-                  description={
-                    formatRange(
-                      marginRequiredBestCase,
-                      marginRequiredWorstCase,
-                      assetDecimals
-                    ) ?? '-'
-                  }
-                >
-                  <div className="font-mono text-right">
-                    {formatValue(
-                      marginRequiredWorstCase,
-                      assetDecimals,
-                      quantum
-                    )}{' '}
-                    {assetSymbol || ''}
-                  </div>
-                </Tooltip>
-              </div>
-            </AccordionPrimitive.Trigger>
-          }
-        >
-          <div className="flex flex-col w-full gap-2">
-            <KeyValue
-              label={t('Total margin available')}
-              indent
-              value={formatValue(totalMarginAvailable, assetDecimals)}
-              formattedValue={formatValue(
-                totalMarginAvailable,
-                assetDecimals,
-                quantum
-              )}
-              symbol={assetSymbol}
-              labelDescription={t(
-                'TOTAL_MARGIN_AVAILABLE',
-                TOTAL_MARGIN_AVAILABLE,
-                {
-                  generalAccountBalance: formatValue(
-                    generalAccountBalance,
-                    assetDecimals,
-                    quantum
-                  ),
-                  marginAccountBalance: formatValue(
-                    marginAccountBalance,
-                    assetDecimals,
-                    quantum
-                  ),
-                  marginMaintenance: formatValue(
-                    currentMargins?.maintenanceLevel,
-                    assetDecimals,
-                    quantum
-                  ),
-                  assetSymbol,
-                }
-              )}
-            />
-            {deductionFromCollateral}
-            <KeyValue
-              label={t('Current margin allocation')}
-              indent
-              onClick={
-                generalAccountBalance
-                  ? () => setBreakdownDialog(true)
-                  : undefined
-              }
-              value={formatValue(marginAccountBalance, assetDecimals)}
-              symbol={assetSymbol}
-              labelDescription={t(
-                'MARGIN_ACCOUNT_TOOLTIP_TEXT',
-                MARGIN_ACCOUNT_TOOLTIP_TEXT
-              )}
-              formattedValue={formatValue(
-                marginAccountBalance,
-                assetDecimals,
-                quantum
-              )}
-            />
-          </div>
-        </AccordionPanel>
-      </Accordion>
-      {projectedMargin}
+    <div className="flex flex-col w-full gap-2 mt-2">
       <KeyValue
-        label={t('Liquidation')}
+        label={t('Current margin')}
+        onClick={
+          generalAccountBalance ? () => setBreakdownDialog(true) : undefined
+        }
+        value={formatValue(totalMarginAccountBalance.toString(), assetDecimals)}
+        symbol={assetSymbol}
+        labelDescription={t(
+          'MARGIN_ACCOUNT_TOOLTIP_TEXT',
+          MARGIN_ACCOUNT_TOOLTIP_TEXT
+        )}
+        formattedValue={formatValue(
+          totalMarginAccountBalance.toString(),
+          assetDecimals,
+          quantum
+        )}
+      />
+      <KeyValue
+        label={t('Available collateral')}
+        value={formatValue(generalAccountBalance, assetDecimals)}
+        formattedValue={formatValue(
+          generalAccountBalance.toString(),
+          assetDecimals,
+          quantum
+        )}
+        symbol={assetSymbol}
+      />
+      <KeyValue
+        label={t('Additional margin required')}
+        value={formatRange(
+          collateralIncreaseEstimateBestCase.toString(),
+          collateralIncreaseEstimateWorstCase.toString(),
+          assetDecimals
+        )}
+        formattedValue={formatValue(
+          collateralIncreaseEstimateBestCase.toString(),
+          assetDecimals,
+          quantum
+        )}
+        symbol={assetSymbol}
+      />
+      <KeyValue
+        label={t('Liquidation estimate')}
         value={liquidationPriceEstimateRange}
         formattedValue={liquidationPriceEstimate}
         symbol={quoteName}

libs/deal-ticket/src/components/deal-ticket/deal-ticket.tsx

@@ -58,8 +58,9 @@ import type {
 } from '@vegaprotocol/markets';
 import { MarginWarning } from '../deal-ticket-validation/margin-warning';
 import {
-  useMarketAccountBalance,
+  useMarginAccountBalance,
   useAccountBalance,
+  marginModeDataProvider,
 } from '@vegaprotocol/accounts';
 import { useDataProvider } from '@vegaprotocol/data-provider';
 import { type OrderFormValues } from '../../hooks';
@@ -72,7 +73,7 @@ import {
 } from '../../hooks';
 import { DealTicketSizeIceberg } from './deal-ticket-size-iceberg';
 import noop from 'lodash/noop';
-import { isNonPersistentOrder } from '../../utils/time-in-force-persistance';
+import { isNonPersistentOrder } from '../../utils/time-in-force-persistence';
 import { KeyValue } from './key-value';
 import { DocsLinks } from '@vegaprotocol/environment';
 import { useT } from '../../use-t';
@@ -166,19 +167,16 @@ export const DealTicket = ({
 
   const asset = getAsset(market);
   const {
-    accountBalance: marginAccountBalance,
+    orderMarginAccountBalance,
+    marginAccountBalance,
     loading: loadingMarginAccountBalance,
-  } = useMarketAccountBalance(market.id);
+  } = useMarginAccountBalance(market.id);
 
   const {
     accountBalance: generalAccountBalance,
     loading: loadingGeneralAccountBalance,
   } = useAccountBalance(asset.id);
 
-  const balance = (
-    BigInt(marginAccountBalance) + BigInt(generalAccountBalance)
-  ).toString();
-
   const { marketState, marketTradingMode } = marketData;
   const timeInForce = watch('timeInForce');
 
@@ -241,7 +239,19 @@ export const DealTicket = ({
     variables: { partyId: pubKey || '', marketId: market.id },
     skip: !pubKey,
   });
-  const openVolume = useOpenVolume(pubKey, market.id) ?? '0';
+  const { data: margin } = useDataProvider({
+    dataProvider: marginModeDataProvider,
+    variables: { partyId: pubKey || '', marketId: market.id },
+    skip: !pubKey,
+  });
+
+  const { openVolume, averageEntryPrice } = useOpenVolume(
+    pubKey,
+    market.id
+  ) || {
+    openVolume: '0',
+    averageEntryPrice: '0',
+  };
   const orders = activeOrders
     ? activeOrders.map<Schema.OrderInfo>((order) => ({
         isMarketOrder: order.type === Schema.OrderType.TYPE_MARKET,
@@ -259,21 +269,25 @@ export const DealTicket = ({
     });
   }
 
-  const positionEstimate = usePositionEstimate({
-    marketId: market.id,
-    openVolume,
-    orders,
-    marginAccountBalance: marginAccountBalance,
-    generalAccountBalance: generalAccountBalance,
-    orderMarginAccountBalance: '0', // TODO: Get real balance
-    marginMode: Schema.MarginMode.MARGIN_MODE_CROSS_MARGIN, // TODO: unhardcode this and get users margin mode for the market
-    averageEntryPrice: marketPrice || '0', // TODO: This assumes the order will be entirely filled at the current market price
-    skip:
-      !normalizedOrder ||
+  const positionEstimate = usePositionEstimate(
+    {
+      marketId: market.id,
+      openVolume,
+      averageEntryPrice,
+      orders,
+      marginAccountBalance: marginAccountBalance || '0',
+      generalAccountBalance: generalAccountBalance || '0',
+      orderMarginAccountBalance: orderMarginAccountBalance || '0',
+      marginFactor: margin?.marginFactor || '1',
+      marginMode:
+        margin?.marginMode || Schema.MarginMode.MARGIN_MODE_CROSS_MARGIN,
+      includeCollateralIncreaseInAvailableCollateral: true,
+    },
+    !normalizedOrder ||
       (normalizedOrder.type !== Schema.OrderType.TYPE_MARKET &&
         (!normalizedOrder.price || normalizedOrder.price === '0')) ||
-      normalizedOrder.size === '0',
-  });
+      normalizedOrder.size === '0'
+  );
 
   const assetSymbol = getAsset(market).symbol;
 
@@ -319,7 +333,9 @@ export const DealTicket = ({
     }
 
     const hasNoBalance =
-      !BigInt(generalAccountBalance) && !BigInt(marginAccountBalance);
+      !BigInt(generalAccountBalance) &&
+      !BigInt(marginAccountBalance) &&
+      !BigInt(orderMarginAccountBalance);
     if (
       hasNoBalance &&
       !(loadingMarginAccountBalance || loadingGeneralAccountBalance)
@@ -349,6 +365,7 @@ export const DealTicket = ({
     marketTradingMode,
     generalAccountBalance,
     marginAccountBalance,
+    orderMarginAccountBalance,
     loadingMarginAccountBalance,
     loadingGeneralAccountBalance,
     pubKey,
@@ -706,10 +723,10 @@ export const DealTicket = ({
         error={summaryError}
         asset={asset}
         marketTradingMode={marketData.marketTradingMode}
-        balance={balance}
+        balance={generalAccountBalance}
         margin={
-          positionEstimate?.estimatePosition?.margin.bestCase.initialLevel ||
-          '0'
+          positionEstimate?.estimatePosition?.collateralIncreaseEstimate
+            .bestCase || '0'
         }
         isReadOnly={isReadOnly}
         pubKey={pubKey}
@@ -743,6 +760,7 @@ export const DealTicket = ({
         onMarketClick={onMarketClick}
         assetSymbol={asset.symbol}
         marginAccountBalance={marginAccountBalance}
+        orderMarginAccountBalance={orderMarginAccountBalance}
         generalAccountBalance={generalAccountBalance}
         positionEstimate={positionEstimate?.estimatePosition}
         market={market}
@@ -768,8 +786,20 @@ interface SummaryMessageProps {
 
 export const NoWalletWarning = ({
   isReadOnly,
-}: Pick<SummaryMessageProps, 'isReadOnly'>) => {
+  noWalletConnected,
+}: Pick<SummaryMessageProps, 'isReadOnly'> & {
+  noWalletConnected?: boolean;
+}) => {
   const t = useT();
+  if (noWalletConnected) {
+    return (
+      <div className="mb-2">
+        <InputError testId="deal-ticket-error-message-summary">
+          {t('You need a Vega wallet to start trading on this market')}
+        </InputError>
+      </div>
+    );
+  }
   if (isReadOnly) {
     return (
       <div className="mb-2">

libs/deal-ticket/src/components/deal-ticket/key-value.tsx

@@ -1,5 +1,4 @@
 import { Tooltip } from '@vegaprotocol/ui-toolkit';
-import classnames from 'classnames';
 import type { ReactNode } from 'react';
 
 export interface KeyValuePros {
@@ -19,7 +18,6 @@ export const KeyValue = ({
   value,
   labelDescription,
   symbol,
-  indent,
   onClick,
   formattedValue,
 }: KeyValuePros) => {
@@ -43,10 +41,7 @@ export const KeyValue = ({
           : id
       }`}
       key={typeof label === 'string' ? label : 'value-dropdown'}
-      className={classnames(
-        'text-xs flex justify-between items-center gap-4 flex-wrap text-right',
-        { 'ml-2': indent }
-      )}
+      className="text-xs flex justify-between items-center gap-4 flex-wrap text-right"
     >
       <Tooltip description={labelDescription}>
         <div className="text-muted text-left">{label}</div>

libs/deal-ticket/src/components/deal-ticket/margin-mode-selector.tsx

@@ -1,9 +1,12 @@
 import { useDataProvider } from '@vegaprotocol/data-provider';
+import * as Schema from '@vegaprotocol/types';
 import {
   TradingButton as Button,
   TradingInput as Input,
   FormGroup,
   LeverageSlider,
+  Notification,
+  Intent,
 } from '@vegaprotocol/ui-toolkit';
 import { MarginMode, useVegaWallet } from '@vegaprotocol/wallet';
 import * as Types from '@vegaprotocol/types';
@@ -15,15 +18,164 @@ import { Dialog } from '@vegaprotocol/ui-toolkit';
 import { useEffect, useState } from 'react';
 import { useT } from '../../use-t';
 import classnames from 'classnames';
-import { marketMarginDataProvider } from '@vegaprotocol/accounts';
-import { useMaxLeverage } from '@vegaprotocol/positions';
+import {
+  marginModeDataProvider,
+  useAccountBalance,
+  useMarginAccountBalance,
+} from '@vegaprotocol/accounts';
+import { useMaxLeverage, useOpenVolume } from '@vegaprotocol/positions';
+import { activeOrdersProvider } from '@vegaprotocol/orders';
+import { usePositionEstimate } from '../../hooks/use-position-estimate';
+import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
+import { getAsset, useMarket } from '@vegaprotocol/markets';
+import { NoWalletWarning } from './deal-ticket';
+import { DealTicketMarginDetails } from './deal-ticket-margin-details';
 
 const defaultLeverage = 10;
+
+export const MarginChange = ({
+  partyId,
+  marketId,
+  marginMode,
+  marginFactor,
+}: {
+  partyId: string | null;
+  marketId: string;
+  marginMode: Types.MarginMode;
+  marginFactor: string;
+}) => {
+  const t = useT();
+  const { data: market } = useMarket(marketId);
+  const asset = market && getAsset(market);
+  const {
+    marginAccountBalance,
+    orderMarginAccountBalance,
+    loading: marginAccountBalanceLoading,
+  } = useMarginAccountBalance(marketId);
+  const {
+    accountBalance: generalAccountBalance,
+    loading: generalAccountBalanceLoading,
+  } = useAccountBalance(asset?.id);
+  const { openVolume, averageEntryPrice } = useOpenVolume(
+    partyId,
+    marketId
+  ) || {
+    openVolume: '0',
+    averageEntryPrice: '0',
+  };
+  const { data: activeOrders } = useDataProvider({
+    dataProvider: activeOrdersProvider,
+    variables: { partyId: partyId || '', marketId },
+  });
+  const orders = activeOrders
+    ? activeOrders.map<Schema.OrderInfo>((order) => ({
+        isMarketOrder: order.type === Schema.OrderType.TYPE_MARKET,
+        price: order.price,
+        remaining: order.remaining,
+        side: order.side,
+      }))
+    : [];
+  const skip =
+    (!orders?.length && openVolume === '0') ||
+    marginAccountBalanceLoading ||
+    generalAccountBalanceLoading;
+  const estimateMargin = usePositionEstimate(
+    {
+      generalAccountBalance: generalAccountBalance || '0',
+      marginAccountBalance: marginAccountBalance || '0',
+      marginFactor,
+      marginMode,
+      averageEntryPrice,
+      openVolume,
+      marketId,
+      orderMarginAccountBalance: orderMarginAccountBalance || '0',
+      includeCollateralIncreaseInAvailableCollateral: true,
+      orders,
+    },
+    skip
+  );
+  if (!asset || !estimateMargin?.estimatePosition) {
+    return null;
+  }
+  const collateralIncreaseEstimate = BigInt(
+    estimateMargin.estimatePosition.collateralIncreaseEstimate.worstCase
+  );
+
+  let positionWarning = '';
+  let marginChangeWarning = '';
+  if (collateralIncreaseEstimate) {
+    if (orders?.length && openVolume !== '0') {
+      positionWarning = t(
+        'youHaveOpenPositionAndOrders',
+        'You have an existing position and open orders on this market.',
+        {
+          count: orders.length,
+        }
+      );
+    } else if (!orders?.length) {
+      positionWarning = t('You have an existing position on this market.');
+    } else {
+      positionWarning = t(
+        'youHaveOpenOrders',
+        'You have open orders on this market.',
+        {
+          count: orders.length,
+        }
+      );
+    }
+
+    const amount = addDecimalsFormatNumber(
+      collateralIncreaseEstimate.toString(),
+      asset?.decimals
+    );
+    const { symbol } = asset;
+    const interpolation = { amount, symbol };
+    if (marginMode === Schema.MarginMode.MARGIN_MODE_CROSS_MARGIN) {
+      marginChangeWarning = t(
+        'Changing the margin mode will move {{amount}} {{symbol}} from your general account to fund the position.',
+        interpolation
+      );
+    } else {
+      marginChangeWarning = t(
+        'Changing the margin mode and leverage will move {{amount}} {{symbol}} from your general account to fund the position.',
+        interpolation
+      );
+    }
+  }
+  return (
+    <div className="mb-2">
+      {positionWarning && marginChangeWarning && (
+        <Notification
+          intent={Intent.Warning}
+          message={
+            <>
+              <p>{positionWarning}</p>
+              <p>{marginChangeWarning}</p>
+            </>
+          }
+        />
+      )}
+      <DealTicketMarginDetails
+        marginAccountBalance={marginAccountBalance}
+        generalAccountBalance={generalAccountBalance}
+        orderMarginAccountBalance={orderMarginAccountBalance}
+        assetSymbol={asset.symbol}
+        market={market}
+        positionEstimate={estimateMargin.estimatePosition}
+        side={
+          openVolume.startsWith('-')
+            ? Schema.Side.SIDE_SELL
+            : Schema.Side.SIDE_BUY
+        }
+      />
+    </div>
+  );
+};
+
 interface MarginDialogProps {
   open: boolean;
   onClose: () => void;
   marketId: string;
-  partyId: string;
   create: VegaTransactionStore['create'];
 }
 
@@ -33,6 +185,7 @@ const CrossMarginModeDialog = ({
   marketId,
   create,
 }: MarginDialogProps) => {
+  const { pubKey: partyId, isReadOnly } = useVegaWallet();
   const t = useT();
   return (
     <Dialog
@@ -60,15 +213,24 @@ const CrossMarginModeDialog = ({
           )}
         </p>
       </div>
+      <MarginChange
+        marketId={marketId}
+        partyId={partyId}
+        marginMode={Types.MarginMode.MARGIN_MODE_CROSS_MARGIN}
+        marginFactor="1"
+      />
+      <NoWalletWarning noWalletConnected={!partyId} isReadOnly={isReadOnly} />
       <Button
         className="w-full"
         onClick={() => {
-          create({
-            updateMarginMode: {
-              marketId,
-              mode: MarginMode.MARGIN_MODE_CROSS_MARGIN,
-            },
-          });
+          partyId &&
+            !isReadOnly &&
+            create({
+              updateMarginMode: {
+                marketId,
+                mode: MarginMode.MARGIN_MODE_CROSS_MARGIN,
+              },
+            });
           onClose();
         }}
       >
@@ -82,10 +244,10 @@ const IsolatedMarginModeDialog = ({
   open,
   onClose,
   marketId,
-  partyId,
   marginFactor,
   create,
 }: MarginDialogProps & { marginFactor: string }) => {
+  const { pubKey: partyId, isReadOnly } = useVegaWallet();
   const [leverage, setLeverage] = useState(
     Number((1 / Number(marginFactor)).toFixed(1))
   );
@@ -129,13 +291,15 @@ const IsolatedMarginModeDialog = ({
       </div>
       <form
         onSubmit={() => {
-          create({
-            updateMarginMode: {
-              marketId,
-              mode: MarginMode.MARGIN_MODE_ISOLATED_MARGIN,
-              marginFactor: `${1 / leverage}`,
-            },
-          });
+          partyId &&
+            !isReadOnly &&
+            create({
+              updateMarginMode: {
+                marketId,
+                mode: MarginMode.MARGIN_MODE_ISOLATED_MARGIN,
+                marginFactor: `${1 / leverage}`,
+              },
+            });
           onClose();
         }}
       >
@@ -144,7 +308,7 @@ const IsolatedMarginModeDialog = ({
             <LeverageSlider
               max={max}
               step={0.1}
-              value={[leverage]}
+              value={[leverage || 1]}
               onValueChange={([value]) => setLeverage(value)}
             />
           </div>
@@ -154,10 +318,17 @@ const IsolatedMarginModeDialog = ({
             min={1}
             max={max}
             step={0.1}
-            value={leverage}
+            value={leverage || ''}
             onChange={(e) => setLeverage(Number(e.target.value))}
           />
         </FormGroup>
+        <MarginChange
+          marketId={marketId}
+          partyId={partyId}
+          marginMode={Types.MarginMode.MARGIN_MODE_ISOLATED_MARGIN}
+          marginFactor={`${1 / leverage}`}
+        />
+        <NoWalletWarning noWalletConnected={!partyId} isReadOnly={isReadOnly} />
         <Button className="w-full" type="submit">
           {t('Confirm')}
         </Button>
@@ -169,27 +340,21 @@ const IsolatedMarginModeDialog = ({
 export const MarginModeSelector = ({ marketId }: { marketId: string }) => {
   const t = useT();
   const [dialog, setDialog] = useState<'cross' | 'isolated' | ''>();
-  const { pubKey: partyId, isReadOnly } = useVegaWallet();
+  const { pubKey: partyId } = useVegaWallet();
   const { data: margin } = useDataProvider({
-    dataProvider: marketMarginDataProvider,
+    dataProvider: marginModeDataProvider,
     variables: {
       partyId: partyId || '',
       marketId,
     },
     skip: !partyId,
   });
-  useEffect(() => {
-    if (!partyId) {
-      setDialog('');
-    }
-  }, [partyId]);
   const create = useVegaTransactionStore((state) => state.create);
   const marginMode = margin?.marginMode;
   const marginFactor =
     margin?.marginFactor && margin?.marginFactor !== '0'
       ? margin?.marginFactor
       : undefined;
-  const disabled = isReadOnly;
   const onClose = () => setDialog(undefined);
   const enabledModeClassName = 'bg-vega-clight-500 dark:bg-vega-cdark-500';
 
@@ -197,8 +362,8 @@ export const MarginModeSelector = ({ marketId }: { marketId: string }) => {
     <>
       <div className="mb-4 grid h-8 leading-8 font-alpha text-xs grid-cols-2">
         <button
-          disabled={disabled}
-          onClick={() => partyId && setDialog('cross')}
+          type="button"
+          onClick={() => setDialog('cross')}
           className={classnames('rounded', {
             [enabledModeClassName]:
               !marginMode ||
@@ -208,8 +373,8 @@ export const MarginModeSelector = ({ marketId }: { marketId: string }) => {
           {t('Cross')}
         </button>
         <button
-          disabled={disabled}
-          onClick={() => partyId && setDialog('isolated')}
+          type="button"
+          onClick={() => setDialog('isolated')}
           className={classnames('rounded', {
             [enabledModeClassName]:
               marginMode === Types.MarginMode.MARGIN_MODE_ISOLATED_MARGIN,
@@ -222,25 +387,23 @@ export const MarginModeSelector = ({ marketId }: { marketId: string }) => {
           })}
         </button>
       </div>
-      {partyId && (
+      {
         <CrossMarginModeDialog
-          partyId={partyId}
           open={dialog === 'cross'}
           onClose={onClose}
           marketId={marketId}
           create={create}
         />
-      )}
-      {partyId && (
+      }
+      {
         <IsolatedMarginModeDialog
-          partyId={partyId}
           open={dialog === 'isolated'}
           onClose={onClose}
           marketId={marketId}
           create={create}
           marginFactor={marginFactor || `${1 / defaultLeverage}`}
         />
-      )}
+      }
     </>
   );
 };

libs/deal-ticket/src/constants.ts

@@ -8,7 +8,7 @@ export const DEDUCTION_FROM_COLLATERAL_TOOLTIP_TEXT =
   'To cover the required margin, this amount will be drawn from your general ({{assetSymbol}}) account.';
 
 export const TOTAL_MARGIN_AVAILABLE =
-  'Total margin available = general {{assetSymbol}} balance ({{generalAccountBalance}} {{assetSymbol}}) + margin balance ({{marginAccountBalance}} {{assetSymbol}}) - maintenance level ({{marginMaintenance}} {{assetSymbol}}).';
+  'Total margin available = general {{assetSymbol}} balance ({{generalAccountBalance}} {{assetSymbol}}) + margin balance ({{marginAccountBalance}} {{assetSymbol}}) + order margin balance ({{orderMarginAccountBalance}} {{assetSymbol}}) - maintenance level ({{marginMaintenance}} {{assetSymbol}}).';
 
 export const CONTRACTS_MARGIN_TOOLTIP_TEXT =
   'The number of contracts determines how many units of the futures contract to buy or sell. For example, this is similar to buying one share of a listed company. The value of 1 contract is equivalent to the price of the contract. For example, if the current price is $50, then one contract is worth $50.';

libs/deal-ticket/src/hooks/use-position-estimate.ts

@@ -5,37 +5,15 @@ import {
 import { useEstimatePositionQuery } from '@vegaprotocol/positions';
 import { useEffect, useState } from 'react';
 
-interface PositionEstimateProps extends EstimatePositionQueryVariables {
-  skip: boolean;
-}
-
-export const usePositionEstimate = ({
-  marketId,
-  openVolume,
-  orders,
-  generalAccountBalance,
-  marginAccountBalance,
-  orderMarginAccountBalance,
-  averageEntryPrice,
-  marginMode,
-  marginFactor,
-  skip,
-}: PositionEstimateProps) => {
+export const usePositionEstimate = (
+  variables: EstimatePositionQueryVariables,
+  skip: boolean
+) => {
   const [estimates, setEstimates] = useState<EstimatePositionQuery | undefined>(
     undefined
   );
   const { data } = useEstimatePositionQuery({
-    variables: {
-      marketId,
-      openVolume,
-      orders,
-      generalAccountBalance,
-      marginAccountBalance,
-      orderMarginAccountBalance,
-      averageEntryPrice,
-      marginMode,
-      marginFactor,
-    },
+    variables,
     skip,
     fetchPolicy: 'no-cache',
   });

libs/deal-ticket/src/utils/map-form-values-to-submission.ts

@@ -9,7 +9,7 @@ import type {
 } from '../hooks/use-form-values';
 import * as Schema from '@vegaprotocol/types';
 import { removeDecimal, toNanoSeconds } from '@vegaprotocol/utils';
-import { isPersistentOrder } from './time-in-force-persistance';
+import { isPersistentOrder } from './time-in-force-persistence';
 
 export const mapFormValuesToOrderSubmission = (
   order: OrderFormValues,

libs/deal-ticket/src/utils/time-in-force-persistence.spec.ts

@@ -2,9 +2,9 @@ import { OrderTimeInForce } from '@vegaprotocol/types';
 import {
   isNonPersistentOrder,
   isPersistentOrder,
-} from './time-in-force-persistance';
+} from './time-in-force-persistence';
 
-it('isNonPeristentOrder', () => {
+it('isNonPersistentOrder', () => {
   expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_FOK)).toBe(true);
   expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_IOC)).toBe(true);
   expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GTC)).toBe(false);
@@ -13,7 +13,7 @@ it('isNonPeristentOrder', () => {
   expect(isNonPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GFN)).toBe(false);
 });
 
-it('isPeristentOrder', () => {
+it('isPersistentOrder', () => {
   expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_FOK)).toBe(false);
   expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_IOC)).toBe(false);
   expect(isPersistentOrder(OrderTimeInForce.TIME_IN_FORCE_GTC)).toBe(true);

libs/environment/src/components/node-switcher/row-data.spec.tsx

@@ -23,7 +23,6 @@ import {
   SUBSCRIPTION_TIMEOUT,
   useNodeBasicStatus,
   useNodeSubscriptionStatus,
-  useResponseTime,
 } from './row-data';
 import { BLOCK_THRESHOLD, RowData } from './row-data';
 import { CUSTOM_NODE_KEY } from '../../types';
@@ -162,19 +161,6 @@ describe('useNodeBasicStatus', () => {
   });
 });
 
-describe('useResponseTime', () => {
-  it('returns response time when url is valid', () => {
-    const { result } = renderHook(() =>
-      useResponseTime('https://localhost:1234')
-    );
-    expect(result.current.responseTime).toBe(50);
-  });
-  it('does not return response time when url is invalid', () => {
-    const { result } = renderHook(() => useResponseTime('nope'));
-    expect(result.current.responseTime).toBeUndefined();
-  });
-});
-
 describe('RowData', () => {
   const props = {
     id: '0',

libs/environment/src/components/node-switcher/row-data.tsx

@@ -1,4 +1,3 @@
-import { isValidUrl } from '@vegaprotocol/utils';
 import { TradingRadio } from '@vegaprotocol/ui-toolkit';
 import { useEffect, useState } from 'react';
 import { CUSTOM_NODE_KEY } from '../../types';
@@ -8,6 +7,7 @@ import {
 } from '../../utils/__generated__/NodeCheck';
 import { LayoutCell } from './layout-cell';
 import { useT } from '../../use-t';
+import { useResponseTime } from '../../utils/time';
 
 export const POLL_INTERVAL = 1000;
 export const SUBSCRIPTION_TIMEOUT = 3000;
@@ -108,20 +108,6 @@ export const useNodeBasicStatus = () => {
   };
 };
 
-export const useResponseTime = (url: string, trigger?: unknown) => {
-  const [responseTime, setResponseTime] = useState<number>();
-  useEffect(() => {
-    if (!isValidUrl(url)) return;
-    if (typeof window.performance.getEntriesByName !== 'function') return; // protection for test environment
-    const requestUrl = new URL(url);
-    const requests = window.performance.getEntriesByName(requestUrl.href);
-    const { duration } =
-      (requests.length && requests[requests.length - 1]) || {};
-    setResponseTime(duration);
-  }, [url, trigger]);
-  return { responseTime };
-};
-
 export const RowData = ({
   id,
   url,

libs/environment/src/hooks/use-environment.spec.ts

@@ -10,6 +10,7 @@ import {
   getUserEnabledFeatureFlags,
   setUserEnabledFeatureFlag,
 } from './use-environment';
+import { canMeasureResponseTime, measureResponseTime } from '../utils/time';
 
 const noop = () => {
   /* no op*/
@@ -17,6 +18,10 @@ const noop = () => {
 
 jest.mock('@vegaprotocol/apollo-client');
 jest.mock('zustand');
+jest.mock('../utils/time');
+
+const mockCanMeasureResponseTime = canMeasureResponseTime as jest.Mock;
+const mockMeasureResponseTime = measureResponseTime as jest.Mock;
 
 const mockCreateClient = createClient as jest.Mock;
 const createDefaultMockClient = () => {
@@ -155,6 +160,14 @@ describe('useEnvironment', () => {
     const fastNode = 'https://api.n01.foo.vega.xyz';
     const fastWait = 1000;
     const nodes = [slowNode, fastNode];
+
+    mockCanMeasureResponseTime.mockImplementation(() => true);
+    mockMeasureResponseTime.mockImplementation((url: string) => {
+      if (url === slowNode) return slowWait;
+      if (url === fastNode) return fastWait;
+      return Infinity;
+    });
+
     // @ts-ignore: typscript doesn't recognise the mock implementation
     global.fetch.mockImplementation(setupFetch({ hosts: nodes }));
 
@@ -168,7 +181,7 @@ describe('useEnvironment', () => {
                 statistics: {
                   chainId: 'chain-id',
                   blockHeight: '100',
-                  vegaTime: new Date().toISOString(),
+                  vegaTime: new Date(1).toISOString(),
                 },
               },
             });
@@ -196,7 +209,8 @@ describe('useEnvironment', () => {
       expect(result.current.nodes).toEqual(nodes);
     });
 
-    jest.runAllTimers();
+    jest.advanceTimersByTime(2000);
+    // jest.runAllTimers();
 
     await waitFor(() => {
       expect(result.current.status).toEqual('success');

libs/environment/src/hooks/use-environment.ts

@@ -19,6 +19,9 @@ import { compileErrors } from '../utils/compile-errors';
 import { envSchema } from '../utils/validate-environment';
 import { tomlConfigSchema } from '../utils/validate-configuration';
 import uniq from 'lodash/uniq';
+import orderBy from 'lodash/orderBy';
+import first from 'lodash/first';
+import { canMeasureResponseTime, measureResponseTime } from '../utils/time';
 
 type Client = ReturnType<typeof createClient>;
 type ClientCollection = {
@@ -38,8 +41,17 @@ export type EnvStore = Env & Actions;
 
 const VERSION = 1;
 export const STORAGE_KEY = `vega_url_${VERSION}`;
+
+const QUERY_TIMEOUT = 3000;
 const SUBSCRIPTION_TIMEOUT = 3000;
 
+const raceAgainst = (timeout: number): Promise<false> =>
+  new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(false);
+    }, timeout);
+  });
+
 /**
  * Fetch and validate a vega node configuration
  */
@@ -64,53 +76,88 @@ const fetchConfig = async (url?: string) => {
 const findNode = async (clients: ClientCollection): Promise<string | null> => {
   const tests = Object.entries(clients).map((args) => testNode(...args));
   try {
-    const url = await Promise.any(tests);
-    return url;
-  } catch {
+    const nodes = await Promise.all(tests);
+    const responsiveNodes = nodes
+      .filter(([, q, s]) => q && s)
+      .map(([url, q]) => {
+        return {
+          url,
+          ...q,
+        };
+      });
+
+    // more recent and faster at the top
+    const ordered = orderBy(
+      responsiveNodes,
+      [(n) => n.blockHeight, (n) => n.vegaTime, (n) => n.responseTime],
+      ['desc', 'desc', 'asc']
+    );
+
+    const best = first(ordered);
+    return best ? best.url : null;
+  } catch (err) {
     // All tests rejected, no suitable node found
     return null;
   }
 };
 
+type Maybe<T> = T | false;
+type QueryTestResult = {
+  blockHeight: number;
+  vegaTime: Date;
+  responseTime: number;
+};
+type SubscriptionTestResult = true;
+type NodeTestResult = [
+  /** url */
+  string,
+  Maybe<QueryTestResult>,
+  Maybe<SubscriptionTestResult>
+];
 /**
  * Test a node for suitability for connection
  */
 const testNode = async (
   url: string,
   client: Client
-): Promise<string | null> => {
+): Promise<NodeTestResult> => {
   const results = await Promise.all([
-    // these promises will only resolve with true/false
-    testQuery(client),
+    testQuery(client, url),
     testSubscription(client),
   ]);
-  if (results[0] && results[1]) {
-    return url;
-  }
-
-  const message = `Tests failed for node: ${url}`;
-  console.warn(message);
-
-  // throwing here will mean this tests is ignored and a different
-  // node that hopefully does resolve will fulfill the Promise.any
-  throw new Error(message);
+  return [url, ...results];
 };
 
 /**
  * Run a test query on a client
  */
-const testQuery = async (client: Client) => {
-  try {
-    const result = await client.query<NodeCheckQuery>({
-      query: NodeCheckDocument,
-    });
-    if (!result || result.error) {
-      return false;
-    }
-    return true;
-  } catch (err) {
-    return false;
-  }
+const testQuery = (
+  client: Client,
+  url: string
+): Promise<Maybe<QueryTestResult>> => {
+  const test: Promise<Maybe<QueryTestResult>> = new Promise((resolve) =>
+    client
+      .query<NodeCheckQuery>({
+        query: NodeCheckDocument,
+      })
+      .then((result) => {
+        if (result && !result.error) {
+          const res = {
+            blockHeight: Number(result.data.statistics.blockHeight),
+            vegaTime: new Date(result.data.statistics.vegaTime),
+            // only after a request has been sent we can retrieve the response time
+            responseTime: canMeasureResponseTime(url)
+              ? measureResponseTime(url) || Infinity
+              : Infinity,
+          } as QueryTestResult;
+          resolve(res);
+        } else {
+          resolve(false);
+        }
+      })
+      .catch(() => resolve(false))
+  );
+  return Promise.race([test, raceAgainst(QUERY_TIMEOUT)]);
 };
 
 /**
@@ -118,7 +165,9 @@ const testQuery = async (client: Client) => {
  * that takes longer than SUBSCRIPTION_TIMEOUT ms to respond
  * is deemed a failure
  */
-const testSubscription = (client: Client) => {
+const testSubscription = (
+  client: Client
+): Promise<Maybe<SubscriptionTestResult>> => {
   return new Promise((resolve) => {
     const sub = client
       .subscribe<NodeCheckTimeUpdateSubscription>({

libs/environment/src/utils/time.spec.ts

@@ -0,0 +1,22 @@
+import { renderHook } from '@testing-library/react';
+import { useResponseTime } from './time';
+
+const mockResponseTime = 50;
+global.performance.getEntriesByName = jest.fn().mockReturnValue([
+  {
+    duration: mockResponseTime,
+  },
+]);
+
+describe('useResponseTime', () => {
+  it('returns response time when url is valid', () => {
+    const { result } = renderHook(() =>
+      useResponseTime('https://localhost:1234')
+    );
+    expect(result.current.responseTime).toBe(50);
+  });
+  it('does not return response time when url is invalid', () => {
+    const { result } = renderHook(() => useResponseTime('nope'));
+    expect(result.current.responseTime).toBeUndefined();
+  });
+});

libs/environment/src/utils/time.ts

@@ -0,0 +1,25 @@
+import { isValidUrl } from '@vegaprotocol/utils';
+import { useEffect, useState } from 'react';
+
+export const useResponseTime = (url: string, trigger?: unknown) => {
+  const [responseTime, setResponseTime] = useState<number>();
+  useEffect(() => {
+    if (!canMeasureResponseTime(url)) return;
+    const duration = measureResponseTime(url);
+    setResponseTime(duration);
+  }, [url, trigger]);
+  return { responseTime };
+};
+
+export const canMeasureResponseTime = (url: string) => {
+  if (!isValidUrl(url)) return false;
+  if (typeof window.performance.getEntriesByName !== 'function') return false;
+  return true;
+};
+
+export const measureResponseTime = (url: string) => {
+  const requestUrl = new URL(url);
+  const requests = window.performance.getEntriesByName(requestUrl.href);
+  const { duration } = (requests.length && requests[requests.length - 1]) || {};
+  return duration;
+};

libs/i18n/src/locales/en/accounts.json

@@ -21,7 +21,6 @@
   "Deposited on the network, but not allocated to a market. Free to use for placing orders or providing liquidity.": "Deposited on the network, but not allocated to a market. Free to use for placing orders or providing liquidity.",
   "Enter manually": "Enter manually",
   "From account": "From account",
-  "Include transfer fee": "Include transfer fee",
   "initial level": "initial level",
   "maintenance level": "maintenance level",
   "Margin health": "Margin health",
@@ -33,7 +32,6 @@
   "release level": "release level",
   "search level": "search level",
   "Select from wallet": "Select from wallet",
-  "The fee will be taken from the amount you are transferring.": "The fee will be taken from the amount you are transferring.",
   "The total amount of each asset on this key. Includes used and available collateral.": "The total amount of each asset on this key. Includes used and available collateral.",
   "The total amount taken from your account. The amount to be transferred plus the fee.": "The total amount taken from your account. The amount to be transferred plus the fee.",
   "The total amount to be transferred (without the fee)": "The total amount to be transferred (without the fee)",

libs/i18n/src/locales/en/deal-ticket.json

@@ -13,6 +13,8 @@
   "Any orders placed now will not trade until the auction ends": "Any orders placed now will not trade until the auction ends",
   "below": "below",
   "Cancel": "Cancel",
+  "Changing the margin mode will move {{amount}} {{symbol}} from your general account to fund the position.": "Changing the margin mode will move {{amount}} {{symbol}} from your general account to fund the position.",
+  "Changing the margin mode and leverage will move {{amount}} {{symbol}} from your general account to fund the position.": "Changing the margin mode and leverage will move {{amount}} {{symbol}} from your general account to fund the position.",
   "Closed": "Closed",
   "Closing on {{time}}": "Closing on {{time}}",
   "Confirm": "Confirm",
@@ -67,6 +69,13 @@
   "One cancels another": "One cancels another",
   "Only limit orders are permitted when market is in auction": "Only limit orders are permitted when market is in auction",
   "Only your allocated margin will be used to fund this position, and if the maintenance margin is breached you will be closed out.": "Only your allocated margin will be used to fund this position, and if the maintenance margin is breached you will be closed out.",
+  "You have an existing position on this market.": "You have an existing position on this market.",
+  "youHaveOpenOrders_one": "You have an open order on this market.",
+  "youHaveOpenOrders_other": "You have open orders on this market.",
+  "youHaveOpenOrders": "You have open orders on this market.",
+  "youHaveOpenPositionAndOrders_one": "You have an existing position and and open order on this market.",
+  "youHaveOpenPositionAndOrders_other": "You have an existing position and open orders on this market.",
+  "youHaveOpenPositionAndOrders": "You have an existing position and open orders on this market.",
   "Peak size": "Peak size",
   "Peak size cannot be greater than the size ({{size}})": "Peak size cannot be greater than the size ({{size}})",
   "Peak size cannot be lower than {{stepSize}}": "Peak size cannot be lower than {{stepSize}}",
@@ -124,7 +133,7 @@
   "Total": "Total",
   "Total fees": "Total fees",
   "Total margin available": "Total margin available",
-  "TOTAL_MARGIN_AVAILABLE": "Total margin available = general {{assetSymbol}} balance ({{generalAccountBalance}} {{assetSymbol}}) + margin balance ({{marginAccountBalance}} {{assetSymbol}}) - maintenance level ({{marginMaintenance}} {{assetSymbol}}).",
+  "TOTAL_MARGIN_AVAILABLE": "Total margin available = general {{assetSymbol}} balance ({{generalAccountBalance}} {{assetSymbol}}) + margin balance ({{marginAccountBalance}} {{assetSymbol}}) + order margin balance ({{orderMarginAccountBalance}} {{assetSymbol}}) - maintenance level ({{marginMaintenance}} {{assetSymbol}}).",
   "No trading": "No trading",
   "Trailing percent offset cannot be higher than 99.9": "Trailing percent offset cannot be higher than 99.9",
   "Trailing percent offset cannot be lower than {{trailingPercentOffsetStep}}": "Trailing percent offset cannot be lower than {{trailingPercentOffsetStep}}",
@@ -140,8 +149,10 @@
   "You are setting this market to cross-margin mode.": "You are setting this market to cross-margin mode.",
   "You are setting this market to isolated margin mode.": "You are setting this market to isolated margin mode.",
   "You have only {{amount}}.": "You have only {{amount}}.",
+  "You have an existing position and open orders on this market": "You have an existing position and open orders on this market",
   "You may not have enough margin available to open this position.": "You may not have enough margin available to open this position.",
   "You need {{symbol}} in your wallet to trade in this market.": "You need {{symbol}} in your wallet to trade in this market.",
+  "You need a Vega wallet to start trading on this market": "You need a Vega wallet to start trading on this market",
   "You need provide a expiry time/date": "You need provide a expiry time/date",
   "You need provide a price": "You need provide a price",
   "You need provide a trailing percent offset": "You need provide a trailing percent offset",

libs/i18n/src/locales/en/trading.json

@@ -63,6 +63,7 @@
   "Create": "Create",
   "Create a team": "Create a team",
   "Create a simple referral code to enjoy the referrer commission outlined in the current referral program": "Create a simple referral code to enjoy the referrer commission outlined in the current referral program",
+  "Create solo team": "Create solo team",
   "Make your referral code a Team to compete in Competitions with your friends, appear in leaderboards on the <0>Competitions Homepage</0>, and earn rewards": "Make your referral code a Team to compete in Competitions with your friends, appear in leaderboards on the <0>Competitions Homepage</0>, and earn rewards",
   "Current tier": "Current tier",
   "DISCLAIMER_P1": "Vega is a decentralised peer-to-peer protocol that can be used to trade derivatives with cryptoassets. The Vega Protocol is an implementation layer (layer one) protocol made of free, public, open-source or source-available software. Use of the Vega Protocol involves various risks, including but not limited to, losses while digital assets are supplied to the Vega Protocol and losses due to the fluctuation of prices of assets.",
@@ -181,6 +182,7 @@
   "Markets": "Markets",
   "Members": "Members",
   "Members ({{count}})": "Members ({{count}})",
+  "Member ID": "Member ID",
   "Menu": "Menu",
   "Metamask Snap <0>quick start</0>": "Metamask Snap <0>quick start</0>",
   "Min. epochs": "Min. epochs",
@@ -363,11 +365,13 @@
   "Type": "Type",
   "Unknown": "Unknown",
   "Unknown settlement date": "Unknown settlement date",
+  "Update team": "Update team",
   "URL": "URL",
   "Use a comma separated list to allow only specific public keys to join the team": "Use a comma separated list to allow only specific public keys to join the team",
   "Vega chart": "Vega chart",
   "Vega Reward pot": "Vega Reward pot",
-  "Vega Wallet <0>full featured<0>": "Vega Wallet <0>full featured<0>",
+  "Vega Wallet <0>full featured</0>": "Vega Wallet <0>full featured</0>",
+  "Vega chart": "Vega chart",
   "Vesting": "Vesting",
   "Vesting multiplier": "Vesting multiplier",
   "Vesting {{assetSymbol}}": "Vesting {{assetSymbol}}",
@@ -413,6 +417,7 @@
   "myVolume_other": "My volume (last {{count}} epochs)",
   "numberEpochs": "{{count}} epochs",
   "numberEpochs_one": "{{count}} epoch",
+  "Rewards earned": "Rewards earned",
   "Rewards paid out": "Rewards paid out",
   "{{reward}}x": "{{reward}}x",
   "userActive": "{{active}} trader: {{count}} epochs so far",
@@ -427,5 +432,19 @@
   "{{assetSymbol}} Reward pot": "{{assetSymbol}} Reward pot",
   "{{checkedAssets}} Assets": "{{checkedAssets}} Assets",
   "{{distance}} ago": "{{distance}} ago",
-  "{{instrumentCode}} liquidity provision": "{{instrumentCode}} liquidity provision"
+  "{{instrumentCode}} liquidity provision": "{{instrumentCode}} liquidity provision",
+  "My team": "My team",
+  "Profile": "Profile",
+  "Last {{games}} games result_one": "Last game result",
+  "Last {{games}} games result_other": "Last {{games}} games result",
+  "Leaderboard": "Leaderboard",
+  "View all teams": "View all teams",
+  "Competitions": "Competitions",
+  "Be a team player! Participate in games and work together to rake in as much profit to win.": "Be a team player! Participate in games and work together to rake in as much profit to win.",
+  "Create a public team": "Create a public team",
+  "Create a private team": "Create a private team",
+  "Choose a team": "Choose a team",
+  "Join a team": "Join a team",
+  "Solo team / lone wolf": "Solo team / lone wolf",
+  "Choose a team to get involved": "Choose a team to get involved"
 }

libs/i18n/src/locales/en/withdraws.json

@@ -47,5 +47,11 @@
   "Withdrawals of {{threshold}} {{symbol}} or more will be delayed for {{delay}}.": "Withdrawals of {{threshold}} {{symbol}} or more will be delayed for {{delay}}.",
   "Withdrawals ready": "Withdrawals ready",
   "You have no assets to withdraw": "You have no assets to withdraw",
-  "Your funds have been unlocked for withdrawal - <0>View in block explorer<0>": "Your funds have been unlocked for withdrawal - <0>View in block explorer<0>"
+  "Your funds have been unlocked for withdrawal - <0>View in block explorer<0>": "Your funds have been unlocked for withdrawal - <0>View in block explorer<0>",
+  "Gas fee": "Gas fee",
+  "Estimated gas fee for the withdrawal transaction (refreshes each 15 seconds)": "Estimated gas fee for the withdrawal transaction (refreshes each 15 seconds)",
+  "It seems that the current gas prices are exceeding the amount you're trying to withdraw": "It seems that the current gas prices are exceeding the amount you're trying to withdraw",
+  "The current gas price range": "The current gas price range",
+  "min": "min",
+  "max": "max"
 }

libs/markets/src/lib/components/last-24h-volume/last-24h-volume.tsx

@@ -1,5 +1,9 @@
-import { calcCandleVolume } from '../../market-utils';
-import { addDecimalsFormatNumber, isNumeric } from '@vegaprotocol/utils';
+import { calcCandleVolume, calcCandleVolumePrice } from '../../market-utils';
+import {
+  addDecimalsFormatNumber,
+  formatNumber,
+  isNumeric,
+} from '@vegaprotocol/utils';
 import { Tooltip } from '@vegaprotocol/ui-toolkit';
 import { useCandles } from '../../hooks';
 import { useT } from '../../use-t';
@@ -9,13 +13,17 @@ interface Props {
   positionDecimalPlaces?: number;
   formatDecimals?: number;
   initialValue?: string;
+  marketDecimals?: number;
+  quoteUnit?: string;
 }
 
 export const Last24hVolume = ({
   marketId,
+  marketDecimals,
   positionDecimalPlaces,
   formatDecimals,
   initialValue,
+  quoteUnit,
 }: Props) => {
   const t = useT();
   const { oneDayCandles, fiveDaysCandles } = useCandles({
@@ -28,6 +36,11 @@ export const Last24hVolume = ({
     (!oneDayCandles || oneDayCandles?.length === 0)
   ) {
     const candleVolume = calcCandleVolume(fiveDaysCandles);
+    const candleVolumePrice = calcCandleVolumePrice(
+      fiveDaysCandles,
+      marketDecimals,
+      positionDecimalPlaces
+    );
     const candleVolumeValue =
       candleVolume && isNumeric(positionDecimalPlaces)
         ? addDecimalsFormatNumber(
@@ -42,8 +55,8 @@ export const Last24hVolume = ({
           <div>
             <span className="flex flex-col">
               {t(
-                '24 hour change is unavailable at this time. The volume change in the last 120 hours is {{candleVolumeValue}}',
-                { candleVolumeValue }
+                '24 hour change is unavailable at this time. The volume change in the last 120 hours is {{candleVolumeValue}} ({{candleVolumePrice}} {{quoteUnit}})',
+                { candleVolumeValue, candleVolumePrice, quoteUnit }
               )}
             </span>
           </div>
@@ -57,10 +70,18 @@ export const Last24hVolume = ({
     ? calcCandleVolume(oneDayCandles)
     : initialValue;
 
+  const candleVolumePrice = oneDayCandles
+    ? calcCandleVolumePrice(
+        oneDayCandles,
+        marketDecimals,
+        positionDecimalPlaces
+      )
+    : initialValue;
+
   return (
     <Tooltip
       description={t(
-        'The total number of contracts traded in the last 24 hours.'
+        'The total number of contracts traded in the last 24 hours. (Total value of contracts traded in the last 24 hours)'
       )}
     >
       <span>
@@ -70,7 +91,12 @@ export const Last24hVolume = ({
               positionDecimalPlaces,
               formatDecimals
             )
-          : '-'}
+          : '-'}{' '}
+        (
+        {candleVolumePrice && isNumeric(positionDecimalPlaces)
+          ? formatNumber(candleVolumePrice, formatDecimals)
+          : '-'}{' '}
+        {quoteUnit})
       </span>
     </Tooltip>
   );

libs/markets/src/lib/components/market-info/market-info-panels.tsx

@@ -155,6 +155,7 @@ export const MarketVolumeInfoPanel = ({ market }: MarketInfoProps) => {
           <Last24hVolume
             marketId={market.id}
             positionDecimalPlaces={market.positionDecimalPlaces}
+            marketDecimals={market.decimalPlaces}
           />
         ),
         openInterest: dash(data?.openInterest),

libs/markets/src/lib/market-utils.spec.tsx

@@ -1,6 +1,7 @@
 import * as Schema from '@vegaprotocol/types';
 import type { Market, MarketMaybeWithDataAndCandles } from './markets-provider';
 import {
+  calcCandleVolumePrice,
   calcTradedFactor,
   filterAndSortMarkets,
   sumFeesFactors,
@@ -145,3 +146,31 @@ describe('sumFeesFactors', () => {
     ).toEqual(0.6);
   });
 });
+
+describe('calcCandleVolumePrice', () => {
+  it('calculates the volume price', () => {
+    const candles = [
+      {
+        volume: '1000',
+        high: '100',
+        low: '10',
+        open: '15',
+        close: '90',
+        periodStart: '2022-05-18T13:08:27.693537312Z',
+      },
+      {
+        volume: '1000',
+        high: '100',
+        low: '10',
+        open: '15',
+        close: '90',
+        periodStart: '2022-05-18T14:08:27.693537312Z',
+      },
+    ];
+    const marketDecimals = 3;
+    const positionDecimalPlaces = 2;
+    expect(
+      calcCandleVolumePrice(candles, marketDecimals, positionDecimalPlaces)
+    ).toEqual('2');
+  });
+});

libs/markets/src/lib/market-utils.ts

@@ -1,4 +1,8 @@
-import { formatNumberPercentage, toBigNum } from '@vegaprotocol/utils';
+import {
+  addDecimal,
+  formatNumberPercentage,
+  toBigNum,
+} from '@vegaprotocol/utils';
 import { MarketState, MarketTradingMode } from '@vegaprotocol/types';
 import BigNumber from 'bignumber.js';
 import orderBy from 'lodash/orderBy';
@@ -113,6 +117,8 @@ export const filterAndSortClosedMarkets = (markets: MarketMaybeWithData[]) => {
     return [
       MarketState.STATE_SETTLED,
       MarketState.STATE_TRADING_TERMINATED,
+      MarketState.STATE_CLOSED,
+      MarketState.STATE_CANCELLED,
     ].includes(m.data?.marketState || m.state);
   });
 };
@@ -145,10 +151,51 @@ export const calcCandleHigh = (candles: Candle[]): string | undefined => {
     .toString();
 };
 
+/**
+ * The total number of contracts traded in the last 24 hours.
+ *
+ * @param candles
+ * @returns the volume of a given set of candles
+ */
 export const calcCandleVolume = (candles: Candle[]): string | undefined =>
   candles &&
   candles.reduce((acc, c) => new BigNumber(acc).plus(c.volume).toString(), '0');
 
+/**
+ * The total number of contracts traded in the last 24 hours. (Total value of contracts traded in the last 24 hours)
+ * The volume is calculated as the sum of the product of the volume and the high price of each candle.
+ * The result is formatted using positionDecimalPlaces to account for the position size.
+ * The result is formatted using marketDecimals to account for the market precision.
+ *
+ * @param candles
+ * @param marketDecimals
+ * @param positionDecimalPlaces
+ * @returns the volume (in quote price) of a given set of candles
+ */
+export const calcCandleVolumePrice = (
+  candles: Candle[],
+  marketDecimals: number = 1,
+  positionDecimalPlaces: number = 1
+): string | undefined =>
+  candles &&
+  candles.reduce(
+    (acc, c) =>
+      new BigNumber(acc)
+        .plus(
+          BigNumber(addDecimal(c.volume, positionDecimalPlaces)).times(
+            addDecimal(c.high, marketDecimals)
+          )
+        )
+        .toString(),
+    '0'
+  );
+
+/**
+ * Calculates the traded factor of a given market.
+ *
+ * @param m
+ * @returns
+ */
 export const calcTradedFactor = (m: MarketMaybeWithDataAndCandles) => {
   const volume = Number(calcCandleVolume(m.candles || []) || 0);
   const price = m.data?.markPrice ? Number(m.data.markPrice) : 0;

libs/positions/src/lib/Positions.graphql

@@ -41,43 +41,35 @@ subscription PositionsSubscription($partyId: ID!) {
 query EstimatePosition(
   $marketId: ID!
   $openVolume: String!
-  $orders: [OrderInfo!]
   $averageEntryPrice: String!
+  $orders: [OrderInfo!]
   $marginAccountBalance: String!
   $generalAccountBalance: String!
   $orderMarginAccountBalance: String!
   $marginMode: MarginMode!
   $marginFactor: String
+  $includeCollateralIncreaseInAvailableCollateral: Boolean
 ) {
   estimatePosition(
     marketId: $marketId
     openVolume: $openVolume
-    orders: $orders
     averageEntryPrice: $averageEntryPrice
+    orders: $orders
     marginAccountBalance: $marginAccountBalance
     generalAccountBalance: $generalAccountBalance
     orderMarginAccountBalance: $orderMarginAccountBalance
     marginMode: $marginMode
     marginFactor: $marginFactor
+    includeCollateralIncreaseInAvailableCollateral: $includeCollateralIncreaseInAvailableCollateral
     # Everywhere in the codebase we expect price values of the underlying to have the right
     # number of digits for formatting with market.decimalPlaces. By default the estimatePosition
     # query will return a full value requiring formatting using asset.decimals. For consistency
     # we can set this variable to true so that we can format with market.decimalPlaces
     scaleLiquidationPriceToMarketDecimals: true
   ) {
-    margin {
-      worstCase {
-        maintenanceLevel
-        searchLevel
-        initialLevel
-        collateralReleaseLevel
-      }
-      bestCase {
-        maintenanceLevel
-        searchLevel
-        initialLevel
-        collateralReleaseLevel
-      }
+    collateralIncreaseEstimate {
+      worstCase
+      bestCase
     }
     liquidation {
       worstCase {

libs/positions/src/lib/__generated__/Positions.ts

@@ -22,17 +22,18 @@ export type PositionsSubscriptionSubscription = { __typename?: 'Subscription', p
 export type EstimatePositionQueryVariables = Types.Exact<{
   marketId: Types.Scalars['ID'];
   openVolume: Types.Scalars['String'];
-  orders?: Types.InputMaybe<Array<Types.OrderInfo> | Types.OrderInfo>;
   averageEntryPrice: Types.Scalars['String'];
+  orders?: Types.InputMaybe<Array<Types.OrderInfo> | Types.OrderInfo>;
   marginAccountBalance: Types.Scalars['String'];
   generalAccountBalance: Types.Scalars['String'];
   orderMarginAccountBalance: Types.Scalars['String'];
   marginMode: Types.MarginMode;
   marginFactor?: Types.InputMaybe<Types.Scalars['String']>;
+  includeCollateralIncreaseInAvailableCollateral?: Types.InputMaybe<Types.Scalars['Boolean']>;
 }>;
 
 
-export type EstimatePositionQuery = { __typename?: 'Query', estimatePosition?: { __typename?: 'PositionEstimate', margin: { __typename?: 'MarginEstimate', worstCase: { __typename?: 'MarginLevels', maintenanceLevel: string, searchLevel: string, initialLevel: string, collateralReleaseLevel: string }, bestCase: { __typename?: 'MarginLevels', maintenanceLevel: string, searchLevel: string, initialLevel: string, collateralReleaseLevel: string } }, liquidation?: { __typename?: 'LiquidationEstimate', worstCase: { __typename?: 'LiquidationPrice', open_volume_only: string, including_buy_orders: string, including_sell_orders: string }, bestCase: { __typename?: 'LiquidationPrice', open_volume_only: string, including_buy_orders: string, including_sell_orders: string } } | null } | null };
+export type EstimatePositionQuery = { __typename?: 'Query', estimatePosition?: { __typename?: 'PositionEstimate', collateralIncreaseEstimate: { __typename?: 'CollateralIncreaseEstimate', worstCase: string, bestCase: string }, liquidation?: { __typename?: 'LiquidationEstimate', worstCase: { __typename?: 'LiquidationPrice', open_volume_only: string, including_buy_orders: string, including_sell_orders: string }, bestCase: { __typename?: 'LiquidationPrice', open_volume_only: string, including_buy_orders: string, including_sell_orders: string } } | null } | null };
 
 export const PositionFieldsFragmentDoc = gql`
     fragment PositionFields on Position {
@@ -129,32 +130,23 @@ export function usePositionsSubscriptionSubscription(baseOptions: Apollo.Subscri
 export type PositionsSubscriptionSubscriptionHookResult = ReturnType<typeof usePositionsSubscriptionSubscription>;
 export type PositionsSubscriptionSubscriptionResult = Apollo.SubscriptionResult<PositionsSubscriptionSubscription>;
 export const EstimatePositionDocument = gql`
-    query EstimatePosition($marketId: ID!, $openVolume: String!, $orders: [OrderInfo!], $averageEntryPrice: String!, $marginAccountBalance: String!, $generalAccountBalance: String!, $orderMarginAccountBalance: String!, $marginMode: MarginMode!, $marginFactor: String) {
+    query EstimatePosition($marketId: ID!, $openVolume: String!, $averageEntryPrice: String!, $orders: [OrderInfo!], $marginAccountBalance: String!, $generalAccountBalance: String!, $orderMarginAccountBalance: String!, $marginMode: MarginMode!, $marginFactor: String, $includeCollateralIncreaseInAvailableCollateral: Boolean) {
   estimatePosition(
     marketId: $marketId
     openVolume: $openVolume
-    orders: $orders
     averageEntryPrice: $averageEntryPrice
+    orders: $orders
     marginAccountBalance: $marginAccountBalance
     generalAccountBalance: $generalAccountBalance
     orderMarginAccountBalance: $orderMarginAccountBalance
     marginMode: $marginMode
     marginFactor: $marginFactor
+    includeCollateralIncreaseInAvailableCollateral: $includeCollateralIncreaseInAvailableCollateral
     scaleLiquidationPriceToMarketDecimals: true
   ) {
-    margin {
-      worstCase {
-        maintenanceLevel
-        searchLevel
-        initialLevel
-        collateralReleaseLevel
-      }
-      bestCase {
-        maintenanceLevel
-        searchLevel
-        initialLevel
-        collateralReleaseLevel
-      }
+    collateralIncreaseEstimate {
+      worstCase
+      bestCase
     }
     liquidation {
       worstCase {
@@ -186,13 +178,14 @@ export const EstimatePositionDocument = gql`
  *   variables: {
  *      marketId: // value for 'marketId'
  *      openVolume: // value for 'openVolume'
- *      orders: // value for 'orders'
  *      averageEntryPrice: // value for 'averageEntryPrice'
+ *      orders: // value for 'orders'
  *      marginAccountBalance: // value for 'marginAccountBalance'
  *      generalAccountBalance: // value for 'generalAccountBalance'
  *      orderMarginAccountBalance: // value for 'orderMarginAccountBalance'
  *      marginMode: // value for 'marginMode'
  *      marginFactor: // value for 'marginFactor'
+ *      includeCollateralIncreaseInAvailableCollateral: // value for 'includeCollateralIncreaseInAvailableCollateral'
  *   },
  * });
  */

libs/positions/src/lib/estimate-position.mock.ts

@@ -8,19 +8,9 @@ export const estimatePositionQuery = (
   const defaultResult: EstimatePositionQuery = {
     estimatePosition: {
       __typename: 'PositionEstimate',
-      margin: {
-        bestCase: {
-          collateralReleaseLevel: '1000000',
-          initialLevel: '500000',
-          maintenanceLevel: '200000',
-          searchLevel: '300000',
-        },
-        worstCase: {
-          collateralReleaseLevel: '1100000',
-          initialLevel: '600000',
-          maintenanceLevel: '300000',
-          searchLevel: '400000',
-        },
+      collateralIncreaseEstimate: {
+        bestCase: '0',
+        worstCase: '0',
       },
       liquidation: {
         bestCase: {

libs/positions/src/lib/liquidation-price.spec.tsx

@@ -9,49 +9,30 @@ import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
 import { MarginMode } from '@vegaprotocol/types';
 
 describe('LiquidationPrice', () => {
-  const props = {
+  const variables = {
     marketId: 'market-id',
     openVolume: '100',
-    decimalPlaces: 2,
-    averageEntryPrice: '100',
-    generalAccountBalance: '100',
-    marginAccountBalance: '100',
-    orderMarginAccountBalance: '100',
+    averageEntryPrice: '10',
+    marginAccountBalance: '500',
+    generalAccountBalance: '500',
+    orderMarginAccountBalance: '0',
     marginMode: MarginMode.MARGIN_MODE_CROSS_MARGIN,
     marginFactor: '1',
   };
+  const props = { ...variables, decimalPlaces: 2 };
   const worstCaseOpenVolume = '200';
   const bestCaseOpenVolume = '100';
   const mock: MockedResponse<EstimatePositionQuery> = {
     request: {
       query: EstimatePositionDocument,
-      variables: {
-        marketId: props.marketId,
-        openVolume: props.openVolume,
-        averageEntryPrice: props.averageEntryPrice,
-        generalAccountBalance: props.generalAccountBalance,
-        marginAccountBalance: props.marginAccountBalance,
-        orderMarginAccountBalance: props.orderMarginAccountBalance,
-        marginMode: props.marginMode,
-        marginFactor: props.marginFactor,
-      },
+      variables,
     },
     result: {
       data: {
         estimatePosition: {
-          margin: {
-            worstCase: {
-              maintenanceLevel: '100',
-              searchLevel: '100',
-              initialLevel: '100',
-              collateralReleaseLevel: '100',
-            },
-            bestCase: {
-              maintenanceLevel: '100',
-              searchLevel: '100',
-              initialLevel: '100',
-              collateralReleaseLevel: '100',
-            },
+          collateralIncreaseEstimate: {
+            bestCase: '0',
+            worstCase: '0',
           },
           liquidation: {
             worstCase: {

libs/positions/src/lib/liquidation-price.tsx

@@ -1,47 +1,35 @@
 import { Tooltip } from '@vegaprotocol/ui-toolkit';
-import { useEstimatePositionQuery } from './__generated__/Positions';
+import {
+  type EstimatePositionQueryVariables,
+  useEstimatePositionQuery,
+} from './__generated__/Positions';
 import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
 import { useT } from '../use-t';
-import { MarginMode } from '@vegaprotocol/types';
 
 export const LiquidationPrice = ({
-  marketId,
-  openVolume,
-  averageEntryPrice,
-  generalAccountBalance,
-  marginAccountBalance,
-  orderMarginAccountBalance,
-  marginMode = MarginMode.MARGIN_MODE_CROSS_MARGIN,
-  marginFactor,
   decimalPlaces,
   className,
-}: {
-  marketId: string;
-  openVolume: string;
-  averageEntryPrice: string;
-  generalAccountBalance: string;
-  marginAccountBalance: string;
-  orderMarginAccountBalance: string;
-  marginMode: MarginMode;
-  marginFactor: string;
+  ...variables
+}: Pick<
+  EstimatePositionQueryVariables,
+  | 'marketId'
+  | 'openVolume'
+  | 'orderMarginAccountBalance'
+  | 'generalAccountBalance'
+  | 'averageEntryPrice'
+  | 'marginAccountBalance'
+  | 'marginMode'
+  | 'marginFactor'
+> & {
   decimalPlaces: number;
   className?: string;
 }) => {
   const t = useT();
 
   const { data: currentData, previousData } = useEstimatePositionQuery({
-    variables: {
-      marketId,
-      openVolume,
-      averageEntryPrice,
-      generalAccountBalance,
-      marginAccountBalance,
-      orderMarginAccountBalance,
-      marginMode,
-      marginFactor,
-    },
+    variables,
     fetchPolicy: 'no-cache',
-    skip: !openVolume || openVolume === '0',
+    skip: !variables.openVolume || variables.openVolume === '0',
   });
 
   const data = currentData || previousData;

libs/positions/src/lib/positions-data-providers.ts

@@ -52,7 +52,7 @@ export interface Position {
   quantum: string;
   lossSocializationAmount: string;
   marginAccountBalance: string;
-  orderAccountBalance: string;
+  orderMarginAccountBalance: string;
   generalAccountBalance: string;
   marketDecimalPlaces: number;
   marketId: string;
@@ -67,6 +67,7 @@ export interface Position {
   realisedPNL: string;
   status: PositionStatus;
   totalBalance: string;
+  totalMarginAccountBalance: string;
   unrealisedPNL: string;
   updatedAt: string | null;
   productType: ProductType;
@@ -119,7 +120,7 @@ export const getMetrics = (
       marginAccount?.balance ?? 0,
       asset.decimals
     );
-    const orderAccountBalance = toBigNum(
+    const orderMarginAccountBalance = toBigNum(
       orderAccount?.balance ?? 0,
       asset.decimals
     );
@@ -137,12 +138,14 @@ export const getMetrics = (
           : openVolume.multipliedBy(-1)
         ).multipliedBy(markPrice)
       : undefined;
-    const totalBalance = marginAccountBalance
-      .plus(generalAccountBalance)
-      .plus(orderAccountBalance);
+    const totalMarginAccountBalance = marginAccountBalance.plus(
+      orderMarginAccountBalance
+    );
+    const totalBalance = totalMarginAccountBalance.plus(generalAccountBalance);
+
     const marginMode =
       margin?.marginMode || MarginMode.MARGIN_MODE_CROSS_MARGIN;
-    const marginFactor = margin?.marginFactor;
+    const marginFactor = margin?.marginFactor || '1';
     const currentLeverage =
       marginMode === MarginMode.MARGIN_MODE_ISOLATED_MARGIN
         ? (marginFactor && 1 / Number(marginFactor)) || undefined
@@ -153,7 +156,7 @@ export const getMetrics = (
         : undefined;
     metrics.push({
       marginMode,
-      marginFactor: marginFactor || '0',
+      marginFactor,
       maintenanceLevel: margin?.maintenanceLevel,
       assetId: asset.id,
       assetSymbol: asset.symbol,
@@ -163,7 +166,7 @@ export const getMetrics = (
       quantum: asset.quantum,
       lossSocializationAmount: position.lossSocializationAmount || '0',
       marginAccountBalance: marginAccount?.balance ?? '0',
-      orderAccountBalance: orderAccount?.balance ?? '0',
+      orderMarginAccountBalance: orderAccount?.balance ?? '0',
       generalAccountBalance: generalAccount?.balance ?? '0',
       marketDecimalPlaces,
       marketId: market.id,
@@ -180,6 +183,9 @@ export const getMetrics = (
       realisedPNL: position.realisedPNL,
       status: position.positionStatus,
       totalBalance: totalBalance.multipliedBy(10 ** asset.decimals).toFixed(),
+      totalMarginAccountBalance: totalMarginAccountBalance
+        .multipliedBy(10 ** asset.decimals)
+        .toFixed(),
       unrealisedPNL: position.unrealisedPNL,
       updatedAt: position.updatedAt || null,
       productType: market?.tradableInstrument.instrument.product
@@ -269,13 +275,26 @@ const positionDataProvider = makeDerivedDataProvider<
   }
 );
 
+export type OpenVolumeData = Pick<
+  PositionFieldsFragment,
+  'openVolume' | 'averageEntryPrice'
+>;
+
 export const openVolumeDataProvider = makeDerivedDataProvider<
-  string,
+  OpenVolumeData,
   never,
   PositionsQueryVariables & MarketDataQueryVariables
->(
-  [positionDataProvider],
-  (data) => (data[0] as PositionFieldsFragment | null)?.openVolume || null
+>([positionDataProvider], ([data], variables, previousData) =>
+  produce(previousData, (draft) => {
+    if (!data) {
+      return data;
+    }
+    const newData = {
+      openVolume: (data as PositionFieldsFragment).openVolume,
+      averageEntryPrice: (data as PositionFieldsFragment).averageEntryPrice,
+    };
+    return draft ? Object.assign(draft, newData) : newData;
+  })
 );
 
 export const rejoinPositionData = (
@@ -376,6 +395,31 @@ export const positionsMetricsProvider = makeDerivedDataProvider<
     })
 );
 
+const getMaxLeverage = (market: MarketInfo | null) => {
+  if (!market || !market?.riskFactors) {
+    return 1;
+  }
+  const maxLeverage =
+    1 /
+    (Math.max(
+      Number(market.riskFactors.long),
+      Number(market.riskFactors.short)
+    ) || 1);
+  return maxLeverage;
+};
+
+export const maxMarketLeverageProvider = makeDerivedDataProvider<
+  number,
+  never,
+  { marketId: string }
+>(
+  [
+    (callback, client, { marketId }) =>
+      marketInfoProvider(callback, client, { marketId }),
+  ],
+  (parts) => getMaxLeverage(parts[0])
+);
+
 export const maxLeverageProvider = makeDerivedDataProvider<
   number,
   never,
@@ -392,15 +436,7 @@ export const maxLeverageProvider = makeDerivedDataProvider<
     const market: MarketInfo | null = parts[0];
     const position: PositionFieldsFragment | null = parts[1];
     const margin: MarginFieldsFragment | null = parts[2];
-    if (!market || !market?.riskFactors) {
-      return 1;
-    }
-    const maxLeverage =
-      1 /
-      (Math.max(
-        Number(market.riskFactors.long),
-        Number(market.riskFactors.short)
-      ) || 1);
+    const maxLeverage = getMaxLeverage(market);
 
     if (
       market &&
@@ -432,10 +468,9 @@ export const maxLeverageProvider = makeDerivedDataProvider<
   }
 );
 
-export const useMaxLeverage = (marketId: string, partyId?: string) => {
+export const useMaxLeverage = (marketId: string, partyId: string | null) => {
   return useDataProvider({
-    dataProvider: maxLeverageProvider,
+    dataProvider: partyId ? maxLeverageProvider : maxMarketLeverageProvider,
     variables: { marketId, partyId: partyId || '' },
-    skip: !partyId,
   });
 };

libs/positions/src/lib/positions-table.tsx

@@ -137,58 +137,61 @@ const PositionMargin = ({ data }: { data: Position }) => {
       ? (
           BigInt(data.marginAccountBalance) + BigInt(data.generalAccountBalance)
         ).toString()
-      : BigInt(data.marginAccountBalance) > BigInt(data.orderAccountBalance)
+      : BigInt(data.marginAccountBalance) >
+        BigInt(data.orderMarginAccountBalance)
       ? data.marginAccountBalance
-      : data.orderAccountBalance;
+      : data.orderMarginAccountBalance;
   const getWidth = (balance: string) =>
     BigNumber(balance).multipliedBy(100).dividedBy(max).toNumber();
   const inCrossMode = data.marginMode === MarginMode.MARGIN_MODE_CROSS_MARGIN;
-  const hasOrderAccountBalance =
-    !inCrossMode && data.orderAccountBalance !== '0';
+  const hasOrderMarginAccountBalance =
+    !inCrossMode && data.orderMarginAccountBalance !== '0';
 
   return (
     <>
-      <MarginChart
-        width={inCrossMode ? getWidth(data.marginAccountBalance) : undefined}
-        label={t('Margin: {{balance}}', {
-          balance: addDecimalsFormatNumberQuantum(
-            data.marginAccountBalance,
-            data.assetDecimals,
-            data.quantum
-          ),
-        })}
-        other={
-          inCrossMode
-            ? t('General account: {{balance}}', {
-                balance: addDecimalsFormatNumberQuantum(
-                  data.generalAccountBalance,
-                  data.assetDecimals,
-                  data.quantum
-                ),
-              })
-            : undefined
-        }
-        className={classnames({ 'mb-2': hasOrderAccountBalance })}
-        marker={
-          data.maintenanceLevel ? getWidth(data.maintenanceLevel) : undefined
-        }
-        markerLabel={
-          data.maintenanceLevel &&
-          t('Liquidation: {{maintenanceLevel}}', {
-            maintenanceLevel: addDecimalsFormatNumberQuantum(
-              data.maintenanceLevel,
+      {data.marginAccountBalance !== '0' && (
+        <MarginChart
+          width={inCrossMode ? getWidth(data.marginAccountBalance) : undefined}
+          label={t('Margin: {{balance}}', {
+            balance: addDecimalsFormatNumberQuantum(
+              data.marginAccountBalance,
               data.assetDecimals,
               data.quantum
             ),
-          })
-        }
-      />
-      {hasOrderAccountBalance ? (
+          })}
+          other={
+            inCrossMode
+              ? t('General account: {{balance}}', {
+                  balance: addDecimalsFormatNumberQuantum(
+                    data.generalAccountBalance,
+                    data.assetDecimals,
+                    data.quantum
+                  ),
+                })
+              : undefined
+          }
+          className={classnames({ 'mb-2': hasOrderMarginAccountBalance })}
+          marker={
+            data.maintenanceLevel ? getWidth(data.maintenanceLevel) : undefined
+          }
+          markerLabel={
+            data.maintenanceLevel &&
+            t('Liquidation: {{maintenanceLevel}}', {
+              maintenanceLevel: addDecimalsFormatNumberQuantum(
+                data.maintenanceLevel,
+                data.assetDecimals,
+                data.quantum
+              ),
+            })
+          }
+        />
+      )}
+      {hasOrderMarginAccountBalance ? (
         <MarginChart
-          width={getWidth(data.orderAccountBalance)}
+          width={getWidth(data.orderMarginAccountBalance)}
           label={t('Order: {{balance}}', {
             balance: addDecimalsFormatNumber(
-              data.orderAccountBalance,
+              data.orderMarginAccountBalance,
               data.assetDecimals
             ),
           })}
@@ -340,20 +343,16 @@ export const PositionsTable = ({
           return !data
             ? undefined
             : toBigNum(
-                data.marginAccountBalance,
+                data.totalMarginAccountBalance,
                 data.assetDecimals
               ).toNumber();
         },
         cellRenderer: ({ data }: VegaICellRendererParams<Position>) => {
-          if (
-            !data ||
-            !data.marginAccountBalance ||
-            !data.marketDecimalPlaces
-          ) {
+          if (!data || !data.totalMarginAccountBalance) {
             return null;
           }
           const margin = addDecimalsFormatNumberQuantum(
-            data.marginAccountBalance,
+            data.totalMarginAccountBalance,
             data.assetDecimals,
             data.quantum
           );
@@ -364,7 +363,7 @@ export const PositionsTable = ({
             <Tooltip
               description={
                 data &&
-                data.marginAccountBalance !== '0' && (
+                data.totalMarginAccountBalance !== '0' && (
                   <PositionMargin data={data} />
                 )
               }
@@ -410,10 +409,10 @@ export const PositionsTable = ({
                 className="block text-right grow"
                 marketId={data.marketId}
                 openVolume={data.openVolume}
+                averageEntryPrice={data.averageEntryPrice}
                 generalAccountBalance={data.generalAccountBalance}
                 marginAccountBalance={data.marginAccountBalance}
-                orderMarginAccountBalance={data.orderAccountBalance}
-                averageEntryPrice={data.averageEntryPrice}
+                orderMarginAccountBalance={data.orderMarginAccountBalance}
                 marginFactor={data.marginFactor}
                 marginMode={data.marginMode}
                 decimalPlaces={data.marketDecimalPlaces}

libs/positions/src/lib/positions.mock.ts

@@ -181,11 +181,11 @@ const marginsFields: MarginFieldsFragment[] = [
 ];
 
 export const singleRow: Position = {
+  marginFactor: '1',
   generalAccountBalance: '12345600',
   maintenanceLevel: '12300000',
   marginMode: Schema.MarginMode.MARGIN_MODE_CROSS_MARGIN,
-  marginFactor: '1',
-  orderAccountBalance: '0',
+  orderMarginAccountBalance: '0',
   partyId: 'partyId',
   assetId: 'asset-id',
   assetSymbol: 'BTC',
@@ -195,6 +195,7 @@ export const singleRow: Position = {
   quantum: '0.1',
   lossSocializationAmount: '0',
   marginAccountBalance: '12345600',
+  totalMarginAccountBalance: '12345600',
   marketDecimalPlaces: 1,
   marketId: 'string',
   marketCode: 'ETHBTC.QM21',

libs/positions/src/lib/use-open-volume.ts

@@ -1,14 +1,17 @@
 import { useState, useCallback } from 'react';
-import { openVolumeDataProvider } from './positions-data-providers';
+import {
+  OpenVolumeData,
+  openVolumeDataProvider,
+} from './positions-data-providers';
 import { useDataProvider } from '@vegaprotocol/data-provider';
 
 export const useOpenVolume = (
   partyId: string | null | undefined,
   marketId: string
 ) => {
-  const [openVolume, setOpenVolume] = useState<string | undefined>(undefined);
-  const update = useCallback(({ data }: { data: string | null }) => {
-    setOpenVolume(data ?? undefined);
+  const [openVolume, setOpenVolume] = useState<OpenVolumeData | null>(null);
+  const update = useCallback(({ data }: { data: OpenVolumeData | null }) => {
+    setOpenVolume(data);
     return true;
   }, []);
   useDataProvider({

libs/trading-view/src/lib/trading-view.tsx

@@ -41,16 +41,17 @@ export const TradingView = ({
   const chartContainerRef = useRef<HTMLDivElement>(null);
   const widgetRef = useRef<IChartingLibraryWidget>();
 
-  const datafeed = useDatafeed();
-
   const prevMarketId = usePrevious(marketId);
   const prevTheme = usePrevious(theme);
 
+  const datafeed = useDatafeed(marketId);
+
   useEffect(() => {
     // Widget already created
     if (widgetRef.current !== undefined) {
       // Update the symbol if changed
       if (marketId !== prevMarketId) {
+        datafeed.setSymbol(marketId);
         widgetRef.current.setSymbol(
           marketId,
           (interval ? interval : '15') as TVResolutionString,

libs/trading-view/src/lib/use-datafeed.ts

@@ -44,14 +44,22 @@ const configurationData: DatafeedConfiguration = {
   supported_resolutions: supportedResolutions as ResolutionString[],
 } as const;
 
-export const useDatafeed = () => {
+// HACK: local handle for market id
+let requestedSymbol: string | undefined = undefined;
+
+export const useDatafeed = (marketId: string) => {
   const hasHistory = useRef(false);
   const subRef = useRef<Subscription>();
   const client = useApolloClient();
 
   const datafeed = useMemo(() => {
-    const feed: IBasicDataFeed = {
+    const feed: IBasicDataFeed & { setSymbol: (symbol: string) => void } = {
+      setSymbol: (symbol: string) => {
+        // re-setting the symbol so it could be consumed by `resolveSymbol`
+        requestedSymbol = symbol;
+      },
       onReady: (callback) => {
+        requestedSymbol = marketId;
         setTimeout(() => callback(configurationData));
       },
 
@@ -68,7 +76,7 @@ export const useDatafeed = () => {
           const result = await client.query<SymbolQuery, SymbolQueryVariables>({
             query: SymbolDocument,
             variables: {
-              marketId,
+              marketId: requestedSymbol || marketId,
             },
           });
 
@@ -242,7 +250,7 @@ export const useDatafeed = () => {
     };
 
     return feed;
-  }, [client]);
+  }, [client, marketId]);
 
   useEffect(() => {
     return () => {