fix: use aggregation epochs and update tests

feat(trading): competitions

.github/workflows/console-test-run.yml

@@ -19,7 +19,7 @@ jobs:
   create-docker-image:
     name: Create docker image for console-test
     runs-on: ubuntu-22.04
-    timeout-minutes: 20
+    timeout-minutes: 45
     steps:
       #----------------------------------------------
       #       check-out frontend-monorepo
@@ -138,7 +138,7 @@ jobs:
     name: run-tests
     runs-on: 8-cores
     needs: [create-docker-image, console-test-branch]
-    timeout-minutes: 20
+    timeout-minutes: 45
     steps:
       #----------------------------------------------
       #       load docker image
@@ -205,7 +205,7 @@ jobs:
       # run tests
       #----------------------------------------------
       - name: Run tests
-        run: CONSOLE_IMAGE_NAME=ci/trading:local poetry run pytest -v -s --numprocesses 4 --dist loadfile --durations=15
+        run: CONSOLE_IMAGE_NAME=ci/trading:local poetry run pytest -v -s --numprocesses 1 --dist loadfile --durations=45
         working-directory: apps/trading/e2e
       #----------------------------------------------
       # upload traces
@@ -227,3 +227,46 @@ jobs:
           name: worker-logs
           path: ./logs/
           retention-days: 15
+      #----------------------------------------------
+      #  -----  upload market-sim logs  -----
+      #----------------------------------------------
+      - name: Prepare and Zip market-sim-logs
+        if: always()
+        run: |
+          parent_dir="/tmp/market-sim-logs"
+          echo "Creating parent directory at $parent_dir"
+          mkdir -p "$parent_dir"
+
+          echo "Waiting for vega-sim-* folders to be created..."
+          sleep 10  # Waits 10 seconds to ensure all folders are created
+
+          echo "Before searching for vega-sim-* folders in /tmp..."
+          folders=$(find /tmp -mindepth 1 -type d -name 'vega-sim-*' -print) || echo "Find command failed with exit code $?"
+
+          echo "After searching for vega-sim-* folders in /tmp..."
+
+          if [ -z "$folders" ]; then
+            echo "No vega-sim-* folders found."
+            exit 0
+          fi
+
+          echo "Moving vega-sim-* folders to $parent_dir"
+          echo "$folders" | xargs -I {} mv {} "$parent_dir/"
+
+          echo "Checking if $parent_dir is not empty..."
+          if [ "$(ls -A $parent_dir)" ]; then
+            echo "Zipping the parent directory..."
+            zip -r market-sim-logs.zip "$parent_dir" && echo "Zip file created successfully."
+          else
+            echo "$parent_dir is empty. No zip file created."
+            exit 0
+          fi
+        shell: /usr/bin/bash -e {0}
+
+      - name: Upload market-sim-logs
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: market-sim-logs
+          path: market-sim-logs.zip
+          retention-days: 15

apps/explorer-e2e/src/integration/proposal.cy.js

@@ -44,7 +44,7 @@ context('Proposal page', { tags: '@smoke' }, function () {
       cy.getByTestId('icon-cross').click();
     });
 
-    it.skip('Proposal page displayed on mobile', function () {
+    it('Proposal page displayed on mobile', function () {
       const proposalTitle = 'Add Lorem Ipsum market';
 
       cy.common_switch_to_mobile_and_click_toggle();
@@ -55,7 +55,7 @@ context('Proposal page', { tags: '@smoke' }, function () {
       });
     });
 
-    it('Able to view new asset proposal', function () {
+    it.skip('Able to view new asset proposal', function () {
       const proposalTitle = 'Test new asset proposal';
       const newAssetProposalBody = getNewAssetTxBody();
       cy.VegaWalletSubmitProposal(newAssetProposalBody);

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

@@ -3,7 +3,11 @@ import { MockedProvider } from '@apollo/client/testing';
 import type { MockedResponse } from '@apollo/client/testing';
 import { render } from '@testing-library/react';
 import ProposalLink from './proposal-link';
-import { ExplorerProposalDocument } from './__generated__/Proposal';
+import {
+  ExplorerProposalDocument,
+  type ExplorerProposalQuery,
+  type ExplorerProposalQueryVariables,
+} from './__generated__/Proposal';
 import { GraphQLError } from 'graphql';
 
 function renderComponent(id: string, mocks: MockedResponse[]) {
@@ -23,7 +27,10 @@ describe('Proposal link component', () => {
   });
 
   it('Renders the ID on error', async () => {
-    const mock = {
+    const mock: MockedResponse<
+      ExplorerProposalQuery,
+      ExplorerProposalQueryVariables
+    > = {
       request: {
         query: ExplorerProposalDocument,
         variables: {
@@ -40,17 +47,22 @@ describe('Proposal link component', () => {
   });
 
   it('Renders the proposal title when the query returns a result', async () => {
-    const mock = {
+    const proposalId = '123';
+    const mock: MockedResponse<
+      ExplorerProposalQuery,
+      ExplorerProposalQueryVariables
+    > = {
       request: {
         query: ExplorerProposalDocument,
         variables: {
-          id: '123',
+          id: proposalId,
         },
       },
       result: {
         data: {
           proposal: {
-            id: '123',
+            __typename: 'Proposal',
+            id: proposalId,
             rationale: {
               title: 'test-title',
               description: 'test description',
@@ -60,13 +72,16 @@ describe('Proposal link component', () => {
       },
     };
 
-    const res = render(renderComponent('123', [mock]));
-    expect(res.getByText('123')).toBeInTheDocument();
+    const res = render(renderComponent(proposalId, [mock]));
+    expect(res.getByText(proposalId)).toBeInTheDocument();
     expect(await res.findByText('test-title')).toBeInTheDocument();
   });
 
   it('Leaves the proposal id when the market is not found', async () => {
-    const mock = {
+    const mock: MockedResponse<
+      ExplorerProposalQuery,
+      ExplorerProposalQueryVariables
+    > = {
       request: {
         query: ExplorerProposalDocument,
         variables: {

apps/explorer/src/app/components/nested-data-list/nested-data-list.spec.tsx

@@ -1,9 +1,5 @@
 import { render, waitFor } from '@testing-library/react';
-import {
-  BORDER_COLOURS,
-  NestedDataList,
-  sortNestedDataByChildren,
-} from './nested-data-list';
+import { NestedDataList, sortNestedDataByChildren } from './nested-data-list';
 import userEvent from '@testing-library/user-event';
 
 const mockData = {
@@ -61,38 +57,6 @@ describe('NestedDataList', () => {
     expect(parent[0].querySelector('li')).toHaveClass('pl-4 border-l-4 pt-2');
   });
 
-  it('should repeat the border colours in the correct order', () => {
-    const colourMockData = {
-      t0: {
-        t1: {
-          t2: {
-            t3: {
-              t4: {
-                t5: {
-                  t6: {
-                    t7: {
-                      t8: {
-                        hello: 'world',
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    };
-    const tree = render(<NestedDataList data={colourMockData} />);
-    const { getByTestId } = tree;
-
-    for (let i = 0; i < 8; i++) {
-      const item = getByTestId(`T${i}`);
-      const expected = BORDER_COLOURS.light[i % 5];
-      expect(item.style.borderColor.toUpperCase()).toBe(expected);
-    }
-  });
-
   it('should sort the data by values with children', () => {
     const mockData = {
       nonce: '5980890939790185837',

apps/explorer/src/app/components/txs/details/referrals/__generated__/code-owner.ts

@@ -0,0 +1,54 @@
+import * as Types from '@vegaprotocol/types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type ExplorerReferralCodeOwnerQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID'];
+}>;
+
+
+export type ExplorerReferralCodeOwnerQuery = { __typename?: 'Query', referralSets: { __typename?: 'ReferralSetConnection', edges: Array<{ __typename?: 'ReferralSetEdge', node: { __typename?: 'ReferralSet', createdAt: any, updatedAt: any, referrer: string } } | null> } };
+
+
+export const ExplorerReferralCodeOwnerDocument = gql`
+    query ExplorerReferralCodeOwner($id: ID!) {
+  referralSets(id: $id) {
+    edges {
+      node {
+        createdAt
+        updatedAt
+        referrer
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useExplorerReferralCodeOwnerQuery__
+ *
+ * To run a query within a React component, call `useExplorerReferralCodeOwnerQuery` and pass it any options that fit your needs.
+ * When your component renders, `useExplorerReferralCodeOwnerQuery` 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 } = useExplorerReferralCodeOwnerQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useExplorerReferralCodeOwnerQuery(baseOptions: Apollo.QueryHookOptions<ExplorerReferralCodeOwnerQuery, ExplorerReferralCodeOwnerQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<ExplorerReferralCodeOwnerQuery, ExplorerReferralCodeOwnerQueryVariables>(ExplorerReferralCodeOwnerDocument, options);
+      }
+export function useExplorerReferralCodeOwnerLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExplorerReferralCodeOwnerQuery, ExplorerReferralCodeOwnerQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<ExplorerReferralCodeOwnerQuery, ExplorerReferralCodeOwnerQueryVariables>(ExplorerReferralCodeOwnerDocument, options);
+        }
+export type ExplorerReferralCodeOwnerQueryHookResult = ReturnType<typeof useExplorerReferralCodeOwnerQuery>;
+export type ExplorerReferralCodeOwnerLazyQueryHookResult = ReturnType<typeof useExplorerReferralCodeOwnerLazyQuery>;
+export type ExplorerReferralCodeOwnerQueryResult = Apollo.QueryResult<ExplorerReferralCodeOwnerQuery, ExplorerReferralCodeOwnerQueryVariables>;

apps/explorer/src/app/components/txs/details/referrals/code-owner.graphql

@@ -0,0 +1,11 @@
+query ExplorerReferralCodeOwner($id: ID!) {
+  referralSets(id: $id) {
+    edges {
+      node {
+        createdAt
+        updatedAt
+        referrer
+      }
+    }
+  }
+}

apps/explorer/src/app/components/txs/details/referrals/referral-code-owner.test.tsx

@@ -0,0 +1,95 @@
+import { render, waitFor } from '@testing-library/react';
+import type { MockedResponse } from '@apollo/client/testing';
+import { MockedProvider } from '@apollo/client/testing';
+import { MemoryRouter } from 'react-router-dom';
+import { ReferralCodeOwner } from './referral-code-owner';
+import type { ReferralCodeOwnerProps } from './referral-code-owner';
+import { ExplorerReferralCodeOwnerDocument } from './__generated__/code-owner';
+const renderComponent = (
+  props: ReferralCodeOwnerProps,
+  mocks: MockedResponse[]
+) => {
+  return render(
+    <MockedProvider mocks={mocks}>
+      <MemoryRouter>
+        <ReferralCodeOwner {...props} />
+      </MemoryRouter>
+    </MockedProvider>
+  );
+};
+
+describe('ReferralCodeOwner', () => {
+  it('should render loading state', () => {
+    const mocks = [
+      {
+        request: {
+          query: ExplorerReferralCodeOwnerDocument,
+          variables: {
+            id: 'ABC123',
+          },
+        },
+      },
+    ];
+
+    const { getByText } = renderComponent({ code: 'ABC123' }, mocks);
+
+    expect(getByText('Loading...')).toBeInTheDocument();
+  });
+
+  it('should render error state', async () => {
+    const errorMessage = 'Error fetching referrer: ABC123';
+    const mocks = [
+      {
+        request: {
+          query: ExplorerReferralCodeOwnerDocument,
+          variables: {
+            id: 'ABC123',
+          },
+        },
+        error: new Error('nope'),
+      },
+    ];
+    const { getByText } = renderComponent({ code: 'ABC123' }, mocks);
+
+    await waitFor(() => {
+      expect(getByText(errorMessage)).toBeInTheDocument();
+    });
+  });
+
+  it('should render link to referring party', async () => {
+    const referrerId = 'DEF789';
+
+    const mocks = [
+      {
+        request: {
+          query: ExplorerReferralCodeOwnerDocument,
+          variables: {
+            id: 'ABC123',
+          },
+        },
+        result: {
+          data: {
+            referralSets: {
+              edges: [
+                {
+                  node: {
+                    __typename: 'ReferralSet',
+                    referrer: referrerId,
+                    createdAt: '123',
+                    updatedAt: '456',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      },
+    ];
+
+    const { getByText } = renderComponent({ code: 'ABC123' }, mocks);
+
+    await waitFor(() => {
+      expect(getByText(referrerId)).toBeInTheDocument();
+    });
+  });
+});

apps/explorer/src/app/components/txs/details/referrals/referral-code-owner.tsx

@@ -0,0 +1,26 @@
+import { TableCell } from '../../../table';
+import { useExplorerReferralCodeOwnerQuery } from './__generated__/code-owner';
+import { PartyLink } from '../../../links';
+
+export interface ReferralCodeOwnerProps {
+  code: string;
+}
+
+/**
+ * Render the owner of a referral code
+ */
+export const ReferralCodeOwner = ({ code }: ReferralCodeOwnerProps) => {
+  const { data, error, loading } = useExplorerReferralCodeOwnerQuery({
+    variables: {
+      id: code,
+    },
+  });
+  const referrer = data?.referralSets.edges[0]?.node.referrer || '';
+  return (
+    <TableCell>
+      {loading && 'Loading...'}
+      {error && `Error fetching referrer: ${code}`}
+      {referrer.length > 0 && <PartyLink id={referrer} />}
+    </TableCell>
+  );
+};

apps/explorer/src/app/components/txs/details/referrals/team.test.tsx

@@ -0,0 +1,93 @@
+import { render } from '@testing-library/react';
+import { ReferralTeam } from './team';
+import type { CreateReferralSet } from './team';
+import { MockedProvider } from '@apollo/client/testing';
+
+describe('ReferralTeam', () => {
+  const team = {
+    name: 'Test Team',
+    teamUrl: 'https://example.com/team',
+    avatarUrl: 'https://example.com/avatar',
+    closed: false,
+  };
+
+  const mockTx: CreateReferralSet = {
+    team,
+  };
+
+  const mockId = '123456';
+  const mockCreator = 'JohnDoe';
+
+  it('should render the team name', () => {
+    const { getByText } = render(
+      <MockedProvider>
+        <ReferralTeam tx={mockTx} id={mockId} creator={mockCreator} />
+      </MockedProvider>
+    );
+    expect(getByText('Test Team')).toBeInTheDocument();
+  });
+
+  it('should render the team ID', () => {
+    const { getByText } = render(
+      <MockedProvider>
+        <ReferralTeam tx={mockTx} id={mockId} creator={mockCreator} />
+      </MockedProvider>
+    );
+    expect(getByText('Id')).toBeInTheDocument();
+    expect(getByText(mockId)).toBeInTheDocument();
+  });
+
+  it('should render the creator', () => {
+    const { getByText } = render(
+      <MockedProvider>
+        <ReferralTeam tx={mockTx} id={mockId} creator={mockCreator} />
+      </MockedProvider>
+    );
+    expect(getByText('Creator')).toBeInTheDocument();
+    expect(getByText(mockCreator)).toBeInTheDocument();
+  });
+
+  it('should render the team URL', () => {
+    const { getByText } = render(
+      <MockedProvider>
+        <ReferralTeam tx={mockTx} id={mockId} creator={mockCreator} />
+      </MockedProvider>
+    );
+    expect(getByText('Team URL')).toBeInTheDocument();
+    expect(getByText(team.teamUrl)).toBeInTheDocument();
+  });
+
+  it('should render the avatar URL', () => {
+    const { getByText } = render(
+      <MockedProvider>
+        <ReferralTeam tx={mockTx} id={mockId} creator={mockCreator} />
+      </MockedProvider>
+    );
+    expect(getByText('Avatar')).toBeInTheDocument();
+    expect(getByText(team.avatarUrl)).toBeInTheDocument();
+  });
+
+  it('should render the open status as a tick if closed is falsy', () => {
+    const { getByTestId } = render(
+      <MockedProvider>
+        <ReferralTeam tx={mockTx} id={mockId} creator={mockCreator} />
+      </MockedProvider>
+    );
+    expect(getByTestId('open-yes')).toBeInTheDocument();
+  });
+
+  it('should render the open status as a cross if it is truthy', () => {
+    const m = {
+      team: {
+        closed: true,
+      },
+    };
+
+    const { getByTestId } = render(
+      <MockedProvider>
+        <ReferralTeam tx={m} id={mockId} creator={mockCreator} />
+      </MockedProvider>
+    );
+    expect(getByTestId('open-no')).toBeInTheDocument();
+  });
+});

apps/explorer/src/app/components/txs/details/referrals/team.tsx

@@ -0,0 +1,73 @@
+import {
+  VegaIcon,
+  Icon,
+  KeyValueTable,
+  KeyValueTableRow,
+  VegaIconNames,
+} from '@vegaprotocol/ui-toolkit';
+import type { components } from '../../../../../types/explorer';
+import Hash from '../../../links/hash';
+import { t } from 'i18next';
+import { PartyLink } from '../../../links';
+
+export type CreateReferralSet = components['schemas']['v1CreateReferralSet'];
+export type ReferralTeam = CreateReferralSet['team'];
+
+export interface ReferralTeamProps {
+  tx: CreateReferralSet;
+  id: string;
+  creator: string;
+}
+
+/**
+ * Renders the details for a team in a CreateReferralSet or UpdateReferralSet transaction.
+ *
+ * Intentionally does not render the avatar image or link to the team url.
+ */
+export const ReferralTeam = ({ tx, id, creator }: ReferralTeamProps) => {
+  if (!tx.team) {
+    return null;
+  }
+
+  return (
+    <section>
+      <div className="inline-block mr-2 leading-none">
+        <VegaIcon name={VegaIconNames.TEAM} />
+      </div>
+      {tx.team.name && (
+        <h3 className="inline-block leading-loose">{tx.team.name}</h3>
+      )}
+
+      <div className="min-w-fit max-w-2xl block">
+        <KeyValueTable>
+          <KeyValueTableRow>
+            {t('Id')}
+            <Hash text={id} truncate={false} />
+          </KeyValueTableRow>
+          <KeyValueTableRow>
+            {t('Creator')}
+            <PartyLink id={creator} truncate={false} />
+          </KeyValueTableRow>
+          {tx.team.teamUrl && (
+            <KeyValueTableRow>
+              {t('Team URL')}
+              <Hash text={tx.team.teamUrl} truncate={false} />
+            </KeyValueTableRow>
+          )}
+          {tx.team.avatarUrl && (
+            <KeyValueTableRow>
+              {t('Avatar')}
+              <Hash text={tx.team.avatarUrl} truncate={false} />
+            </KeyValueTableRow>
+          )}
+          <KeyValueTableRow>
+            {t('Open')}
+            <span data-testid={!tx.team.closed ? 'open-yes' : 'open-no'}>
+              {!tx.team.closed ? <Icon name="tick" /> : <Icon name="cross" />}
+            </span>
+          </KeyValueTableRow>
+        </KeyValueTable>
+      </div>
+    </section>
+  );
+};

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

@@ -27,7 +27,8 @@ export const sharedHeaderProps = {
   className: 'align-top',
 };
 
-const Labels: Record<BlockExplorerTransactionResult['type'], string> = {
+// The incoming type field is usually the right thing to show. Exceptions are listed here
+const LabelOverrides: Record<BlockExplorerTransactionResult['type'], string> = {
   'Stop Orders Submission': 'Stop Order',
   'Stop Orders Cancellation': 'Cancel Stop Order',
 };
@@ -50,7 +51,7 @@ export const TxDetailsShared = ({
   const time: string = blockData?.result.block.header.time || '';
   const height: string = blockData?.result.block.header.height || txData.block;
 
-  const type = Labels[txData.type] || txData.type;
+  const type = LabelOverrides[txData.type] || txData.type;
 
   return (
     <>

apps/explorer/src/app/components/txs/details/tx-apply-referral-code.tsx

@@ -0,0 +1,47 @@
+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 { ReferralCodeOwner } from './referrals/referral-code-owner';
+
+interface TxDetailsApplyReferralCodeProps {
+  txData: BlockExplorerTransactionResult | undefined;
+  pubKey: string | undefined;
+  blockData: TendermintBlocksResponse | undefined;
+}
+
+/**
+ * The signature can be turned in to an id with txSignatureToDeterministicId but
+ */
+export const TxDetailsApplyReferralCode = ({
+  txData,
+  pubKey,
+  blockData,
+}: TxDetailsApplyReferralCodeProps) => {
+  if (!txData || !txData.command.applyReferralCode || !txData.signature) {
+    return <>{t('Awaiting Block Explorer transaction details')}</>;
+  }
+
+  const referralCode = txData.command.applyReferralCode.id;
+
+  return (
+    <div>
+      <TableWithTbody className="mb-8" allowWrap={true}>
+        <TxDetailsShared
+          txData={txData}
+          pubKey={pubKey}
+          blockData={blockData}
+        />
+        <TableRow modifier="bordered">
+          <TableCell>{t('Applied Code')}</TableCell>
+          <TableCell>{referralCode}</TableCell>
+        </TableRow>
+        <TableRow modifier="bordered">
+          <TableCell>{t('Referrer')}</TableCell>
+          <ReferralCodeOwner code={referralCode} />
+        </TableRow>
+      </TableWithTbody>
+    </div>
+  );
+};

apps/explorer/src/app/components/txs/details/tx-create-referral-set.tsx

@@ -0,0 +1,52 @@
+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 { txSignatureToDeterministicId } from '../lib/deterministic-ids';
+import { ReferralTeam } from './referrals/team';
+
+interface TxDetailsCreateReferralProps {
+  txData: BlockExplorerTransactionResult | undefined;
+  pubKey: string | undefined;
+  blockData: TendermintBlocksResponse | undefined;
+}
+
+/**
+ * The signature can be turned in to an id with txSignatureToDeterministicId but
+ */
+export const TxDetailsCreateReferralSet = ({
+  txData,
+  pubKey,
+  blockData,
+}: TxDetailsCreateReferralProps) => {
+  if (!txData || !txData.command.createReferralSet || !txData.signature) {
+    return <>{t('Awaiting Block Explorer transaction details')}</>;
+  }
+
+  const id = txSignatureToDeterministicId(txData.signature.value);
+
+  const isTeam = txData.command.createReferralSet.isTeam || false;
+
+  return (
+    <div>
+      <TableWithTbody className="mb-8" allowWrap={true}>
+        <TxDetailsShared
+          txData={txData}
+          pubKey={pubKey}
+          blockData={blockData}
+        />
+        <TableRow modifier="bordered">
+          <TableCell>{isTeam ? t('Team ID') : t('Referral code')}</TableCell>
+          <TableCell>{id}</TableCell>
+        </TableRow>
+      </TableWithTbody>
+
+      <ReferralTeam
+        tx={txData.command.createReferralSet}
+        id={id}
+        creator={txData.submitter}
+      />
+    </div>
+  );
+};

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

@@ -28,6 +28,10 @@ import { TxProposal } from './tx-proposal';
 import { TxDetailsTransfer } from './tx-transfer';
 import { TxDetailsStopOrderSubmission } from './tx-stop-order-submission';
 import { TxDetailsLiquiditySubmission } from './tx-liquidity-submission';
+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';
 
 interface TxDetailsWrapperProps {
   txData: BlockExplorerTransactionResult | undefined;
@@ -121,6 +125,14 @@ function getTransactionComponent(txData?: BlockExplorerTransactionResult) {
       return TxDetailsStopOrderSubmission;
     case 'Transfer Funds':
       return TxDetailsTransfer;
+    case 'Create Referral Set':
+      return TxDetailsCreateReferralSet;
+    case 'Update Referral Set':
+      return TxDetailsUpdateReferralSet;
+    case 'Apply Referral Code':
+      return TxDetailsApplyReferralCode;
+    case 'Join Team':
+      return TxDetailsJoinTeam;
     default:
       return TxDetailsGeneric;
   }

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

@@ -0,0 +1,47 @@
+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 { ReferralCodeOwner } from './referrals/referral-code-owner';
+
+interface TxDetailsJoinTeamProps {
+  txData: BlockExplorerTransactionResult | undefined;
+  pubKey: string | undefined;
+  blockData: TendermintBlocksResponse | undefined;
+}
+
+/**
+ * The signature can be turned in to an id with txSignatureToDeterministicId but
+ */
+export const TxDetailsJoinTeam = ({
+  txData,
+  pubKey,
+  blockData,
+}: TxDetailsJoinTeamProps) => {
+  if (!txData || !txData.command.joinTeam || !txData.signature) {
+    return <>{t('Awaiting Block Explorer transaction details')}</>;
+  }
+
+  const team = txData.command.joinTeam.id;
+
+  return (
+    <div>
+      <TableWithTbody className="mb-8" allowWrap={true}>
+        <TxDetailsShared
+          txData={txData}
+          pubKey={pubKey}
+          blockData={blockData}
+        />
+        <TableRow modifier="bordered">
+          <TableCell>{t('Team')}</TableCell>
+          <TableCell>{team}</TableCell>
+        </TableRow>
+        <TableRow modifier="bordered">
+          <TableCell>{t('Referrer')}</TableCell>
+          <ReferralCodeOwner code={team} />
+        </TableRow>
+      </TableWithTbody>
+    </div>
+  );
+};

apps/explorer/src/app/components/txs/details/tx-update-referral-set.tsx

@@ -0,0 +1,54 @@
+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 { txSignatureToDeterministicId } from '../lib/deterministic-ids';
+import { ReferralTeam } from './referrals/team';
+
+interface TxDetailsUpdateReferralProps {
+  txData: BlockExplorerTransactionResult | undefined;
+  pubKey: string | undefined;
+  blockData: TendermintBlocksResponse | undefined;
+}
+
+/**
+ * A copy of create referral set, effectively.
+ * Updating a referral set without a team doesn't make sense,
+ * but is valid, so this component ignores sense.
+ */
+export const TxDetailsUpdateReferralSet = ({
+  txData,
+  pubKey,
+  blockData,
+}: TxDetailsUpdateReferralProps) => {
+  if (!txData || !txData.command.updateReferralSet || !txData.signature) {
+    return <>{t('Awaiting Block Explorer transaction details')}</>;
+  }
+
+  const id = txSignatureToDeterministicId(txData.signature.value);
+
+  const isTeam = txData.command.updateReferralSet.isTeam || false;
+
+  return (
+    <div>
+      <TableWithTbody className="mb-8" allowWrap={true}>
+        <TxDetailsShared
+          txData={txData}
+          pubKey={pubKey}
+          blockData={blockData}
+        />
+        <TableRow modifier="bordered">
+          <TableCell>{isTeam ? t('Team ID') : t('Referral code')}</TableCell>
+          <TableCell>{id}</TableCell>
+        </TableRow>
+      </TableWithTbody>
+
+      <ReferralTeam
+        tx={txData.command.updateReferralSet}
+        id={id}
+        creator={txData.submitter}
+      />
+    </div>
+  );
+};

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

@@ -28,6 +28,7 @@ export type FilterOption =
   | 'Delegate'
   | 'Ethereum Key Rotate Submission'
   | 'Issue Signatures'
+  | 'Join Team'
   | 'Key Rotate Submission'
   | 'Liquidity Provision Order'
   | 'Node Signature'
@@ -47,45 +48,46 @@ export type FilterOption =
   | 'Vote on Proposal'
   | 'Withdraw';
 
-// Alphabetised list of transaction types to appear at the top level
-export const PrimaryFilterOptions: FilterOption[] = [
-  'Amend LiquidityProvision Order',
-  'Amend Order',
-  'Batch Market Instructions',
-  'Cancel LiquidityProvision Order',
-  'Cancel Order',
-  'Cancel Transfer Funds',
-  'Delegate',
-  'Liquidity Provision Order',
-  'Proposal',
-  'Stop Orders Submission',
-  'Stop Orders Cancellation',
-  'Submit Oracle Data',
-  'Submit Order',
-  'Transfer Funds',
-  'Undelegate',
-  'Vote on Proposal',
-  'Withdraw',
-];
+export const filterOptions: Record<string, FilterOption[]> = {
+  'Market Instructions': [
+    'Amend LiquidityProvision Order',
+    'Amend Order',
+    'Batch Market Instructions',
+    'Cancel LiquidityProvision Order',
+    'Cancel Order',
+    'Liquidity Provision Order',
+    'Stop Orders Submission',
+    'Stop Orders Cancellation',
+    'Submit Order',
+  ],
+  'Transfers and Withdrawals': [
+    'Transfer Funds',
+    'Cancel Transfer Funds',
+    'Withdraw',
+  ],
+  Governance: ['Delegate', 'Undelegate', 'Vote on Proposal', 'Proposal'],
+  Referrals: [
+    'Apply Referral Code',
+    'Create Referral Set',
+    'Join Team',
+    'Update Referral Set',
+  ],
+  'External Data': ['Chain Event', 'Submit Oracle Data'],
+  Validators: [
+    'Ethereum Key Rotate Submission',
+    'Issue Signatures',
+    'Key Rotate Submission',
+    'Node Signature',
+    'Node Vote',
+    'Protocol Upgrade',
+    'Register new Node',
+    'State Variable Proposal',
+    'Validator Heartbeat',
+  ],
+};
 
-// Alphabetised list of transaction types to nest under a 'More...' submenu
-export const SecondaryFilterOptions: FilterOption[] = [
-  'Chain Event',
-  'Ethereum Key Rotate Submission',
-  'Issue Signatures',
-  'Key Rotate Submission',
-  'Node Signature',
-  'Node Vote',
-  'Protocol Upgrade',
-  'Register new Node',
-  'State Variable Proposal',
-  'Validator Heartbeat',
-];
-
-export const AllFilterOptions: FilterOption[] = [
-  ...PrimaryFilterOptions,
-  ...SecondaryFilterOptions,
-];
+export const AllFilterOptions: FilterOption[] =
+  Object.values(filterOptions).flat();
 
 export interface TxFilterProps {
   filters: Set<FilterOption>;
@@ -122,46 +124,33 @@ export const TxsFilter = ({ filters, setFilters }: TxFilterProps) => {
             <DropdownMenuSeparator />
           </>
         )}
-        {PrimaryFilterOptions.map((f) => (
-          <DropdownMenuCheckboxItem
-            key={f}
-            checked={filters.has(f)}
-            onCheckedChange={() => {
-              // NOTE: These act like radio buttons until the API supports multiple filters
-              setFilters(new Set([f]));
-            }}
-            id={`radio-${f}`}
-          >
-            {f}
-            <DropdownMenuItemIndicator>
-              <Icon name="tick-circle" />
-            </DropdownMenuItemIndicator>
-          </DropdownMenuCheckboxItem>
+
+        {Object.entries(filterOptions).map(([key, value]) => (
+          <DropdownMenuSub key={key}>
+            <DropdownMenuSubTrigger>
+              {t(key)}
+              <Icon name="chevron-right" />
+            </DropdownMenuSubTrigger>
+            <DropdownMenuSubContent>
+              {value.map((f) => (
+                <DropdownMenuCheckboxItem
+                  key={f}
+                  checked={filters.has(f)}
+                  onCheckedChange={(checked) => {
+                    // NOTE: These act like radio buttons until the API supports multiple filters
+                    setFilters(new Set([f]));
+                  }}
+                  id={`radio-${f}`}
+                >
+                  {f}
+                  <DropdownMenuItemIndicator>
+                    <Icon name="tick-circle" className="inline" />
+                  </DropdownMenuItemIndicator>
+                </DropdownMenuCheckboxItem>
+              ))}
+            </DropdownMenuSubContent>
+          </DropdownMenuSub>
         ))}
-        <DropdownMenuSub>
-          <DropdownMenuSubTrigger>
-            {t('More Types')}
-            <Icon name="chevron-right" />
-          </DropdownMenuSubTrigger>
-          <DropdownMenuSubContent>
-            {SecondaryFilterOptions.map((f) => (
-              <DropdownMenuCheckboxItem
-                key={f}
-                checked={filters.has(f)}
-                onCheckedChange={(checked) => {
-                  // NOTE: These act like radio buttons until the API supports multiple filters
-                  setFilters(new Set([f]));
-                }}
-                id={`radio-${f}`}
-              >
-                {f}
-                <DropdownMenuItemIndicator>
-                  <Icon name="tick-circle" className="inline" />
-                </DropdownMenuItemIndicator>
-              </DropdownMenuCheckboxItem>
-            ))}
-          </DropdownMenuSubContent>
-        </DropdownMenuSub>
       </DropdownMenuContent>
     </DropdownMenu>
   );

apps/explorer/src/app/components/txs/tx-list-navigation.spec.tsx

@@ -61,53 +61,4 @@ describe('TxsListNavigation', () => {
 
     expect(nextPageMock).toHaveBeenCalledTimes(1);
   });
-
-  it('disables "Older" button if hasMoreTxs is false', () => {
-    render(
-      <TxsListNavigation
-        refreshTxs={NOOP}
-        nextPage={NOOP}
-        previousPage={NOOP}
-        hasMoreTxs={false}
-        hasPreviousPage={false}
-      >
-        <span></span>
-      </TxsListNavigation>
-    );
-
-    expect(screen.getByText('Older')).toBeDisabled();
-  });
-
-  it('disables "Newer" button if hasPreviousPage is false', () => {
-    render(
-      <TxsListNavigation
-        refreshTxs={NOOP}
-        nextPage={NOOP}
-        previousPage={NOOP}
-        hasMoreTxs={true}
-        hasPreviousPage={false}
-      >
-        <span></span>
-      </TxsListNavigation>
-    );
-
-    expect(screen.getByText('Newer')).toBeDisabled();
-  });
-
-  it('disables both buttons when more and previous are false', () => {
-    render(
-      <TxsListNavigation
-        refreshTxs={NOOP}
-        nextPage={NOOP}
-        previousPage={NOOP}
-        hasMoreTxs={false}
-        hasPreviousPage={false}
-      >
-        <span></span>
-      </TxsListNavigation>
-    );
-
-    expect(screen.getByText('Newer')).toBeDisabled();
-    expect(screen.getByText('Older')).toBeDisabled();
-  });
 });

apps/explorer/src/app/components/txs/tx-list-navigation.tsx

@@ -10,7 +10,8 @@ export interface TxListNavigationProps {
   loading?: boolean;
   hasPreviousPage: boolean;
   hasMoreTxs: boolean;
-  children: React.ReactNode;
+  children?: React.ReactNode;
+  isEmpty?: boolean;
 }
 /**
  * Displays a list of transactions with filters and controls to navigate through the list.
@@ -21,9 +22,8 @@ export const TxsListNavigation = ({
   refreshTxs,
   nextPage,
   previousPage,
-  hasMoreTxs,
-  hasPreviousPage,
   children,
+  isEmpty,
   loading = false,
 }: TxListNavigationProps) => {
   return (
@@ -35,7 +35,6 @@ export const TxsListNavigation = ({
           <Button
             className="mr-2"
             size="xs"
-            disabled={!hasPreviousPage || loading}
             onClick={() => {
               previousPage();
             }}
@@ -44,7 +43,7 @@ export const TxsListNavigation = ({
           </Button>
           <Button
             size="xs"
-            disabled={!hasMoreTxs}
+            disabled={isEmpty}
             onClick={() => {
               nextPage();
             }}

apps/explorer/src/app/components/txs/tx-order-type.tsx

@@ -48,6 +48,8 @@ const displayString: StringMap = {
   StopOrdersSubmission: 'Stop',
   StopOrdersCancellation: 'Cancel stop',
   'Stop Orders Cancellation': 'Cancel stop',
+  'Apply Referral Code': 'Referral',
+  'Create Referral Set': 'Create referral',
 };
 
 export function getLabelForStopOrderType(

apps/explorer/src/app/hooks/get-txs-data-url.ts

@@ -43,7 +43,7 @@ export const getTxsDataUrl = (params: IGetTxsDataUrl) => {
     url.searchParams.append('first', count);
     url.searchParams.append('after', params.after);
   } else {
-    url.searchParams.append('last', count);
+    url.searchParams.append('first', count);
   }
 
   // Hacky fix for param as array

apps/explorer/src/app/hooks/get-txs-data-urls.spec.ts

@@ -6,7 +6,7 @@ describe('getTxsDataUrl', () => {
       count: 10,
       baseUrl: 'https://example.com/transactions',
     };
-    const expectedUrl = 'https://example.com/transactions?last=10';
+    const expectedUrl = 'https://example.com/transactions?first=10';
 
     expect(getTxsDataUrl(params)).toEqual(expectedUrl);
   });
@@ -41,7 +41,7 @@ describe('getTxsDataUrl', () => {
       baseUrl: 'https://example.com/transactions',
     };
     const expectedUrl =
-      'https://example.com/transactions?last=10&filters[cmd.type]=Made%20Up%20Transaction&filters[tx.submitter]=1234';
+      'https://example.com/transactions?first=10&filters[cmd.type]=Made%20Up%20Transaction&filters[tx.submitter]=1234';
 
     expect(getTxsDataUrl(params)).toEqual(expectedUrl);
   });

apps/explorer/src/app/hooks/use-txs-data.ts

@@ -31,14 +31,14 @@ export interface IUseTxsData {
 }
 
 export const useTxsData = ({
-  count = 25,
+  count = 50,
   before,
   after,
   filters,
   party,
 }: IUseTxsData) => {
   const [, setSearchParams] = useSearchParams();
-  let hasMoreTxs = true;
+  let hasMoreTxs = false;
   let txsData: BlockExplorerTransactionResult[] = [];
 
   const url = getTxsDataUrl({
@@ -60,8 +60,8 @@ export const useTxsData = ({
   }
 
   const nextPage = useCallback(() => {
-    const after = data?.transactions.at(-1)?.cursor || '';
-    const params: URLSearchParamsInit = { after };
+    const before = data?.transactions.at(-1)?.cursor || '';
+    const params: URLSearchParamsInit = { before };
     if (filters) {
       params.filters = Array.from(filters).join(',');
     }
@@ -69,8 +69,8 @@ export const useTxsData = ({
   }, [filters, data, setSearchParams]);
 
   const previousPage = useCallback(() => {
-    const before = data?.transactions[0]?.cursor || '';
-    const params: URLSearchParamsInit = { before };
+    const after = data?.transactions[0]?.cursor || '';
+    const params: URLSearchParamsInit = { after };
     if (filters && filters.size > 0 && filters.size === 1) {
       params.filters = Array.from(filters)[0];
     }

apps/explorer/src/app/routes/txs/home/index.tsx

@@ -51,9 +51,10 @@ export const TxsListFiltered = () => {
         refreshTxs={refreshTxs}
         nextPage={nextPage}
         previousPage={previousPage}
-        hasPreviousPage={true}
+        hasPreviousPage={hasMoreTxs}
         loading={loading}
         hasMoreTxs={hasMoreTxs}
+        isEmpty={txsData.length === 0}
       >
         <TxsFilter
           filters={filters}
@@ -70,7 +71,16 @@ export const TxsListFiltered = () => {
         txs={txsData}
         loadMoreTxs={nextPage}
         error={error}
-        className="mb-28 w-full min-w-[400px]"
+        className="mb-4 w-full min-w-[400px]"
+      />
+      <TxsListNavigation
+        refreshTxs={refreshTxs}
+        nextPage={nextPage}
+        previousPage={previousPage}
+        hasPreviousPage={hasMoreTxs}
+        loading={loading}
+        hasMoreTxs={hasMoreTxs}
+        isEmpty={txsData.length === 0}
       />
     </>
   );

apps/explorer/src/app/routes/txs/id/index.tsx

@@ -31,6 +31,10 @@ const Tx = () => {
     }
   }
 
+  if (!data || !data?.transaction) {
+    errorMessage = 'Transaction not found';
+  }
+
   return (
     <section>
       <PageHeader
@@ -49,7 +53,7 @@ const Tx = () => {
         <TxDetails
           className="mb-28"
           txData={data?.transaction}
-          pubKey={data?.transaction.submitter}
+          pubKey={data?.transaction?.submitter}
         />
       </RenderFetched>
     </section>

apps/explorer/src/app/routes/txs/id/tx-details.tsx

@@ -11,8 +11,8 @@ interface TxDetailsProps {
 export const txDetailsTruncateLength = 30;
 
 export const TxDetails = ({ txData, pubKey }: TxDetailsProps) => {
-  if (!txData) {
-    return <>{t('Awaiting Block Explorer transaction details')}</>;
+  if (!txData || !pubKey) {
+    return <>{t('Transaction could not be found')}</>;
   }
   return (
     <section className="mb-10" key={txData.hash}>

apps/explorer/src/types/explorer.d.ts

@@ -8,13 +8,13 @@ type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
 type XOR<T, U> = T | U extends object
   ? (Without<T, U> & U) | (Without<U, T> & T)
   : T | U;
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable  @typescript-eslint/no-explicit-any */
 type OneOf<T extends any[]> = T extends [infer Only]
   ? Only
   : T extends [infer A, infer B, ...infer Rest]
   ? OneOf<[XOR<A, B>, ...Rest]>
   : never;
-/* eslint-enable @typescript-eslint/no-explicit-any */
+/* eslint-enable  @typescript-eslint/no-explicit-any */
 
 export interface paths {
   '/info': {

apps/governance-e2e/src/integration/view/pubkey-view.cy.ts

@@ -47,7 +47,7 @@ context('View functionality with public key', { tags: '@smoke' }, function () {
       .and('contain.text', 'USDC (fake)');
   });
 
-  it('Unable to submit proposal with public key', function () {
+  it.skip('Unable to submit proposal with public key', function () {
     const expectedErrorTxt = `You are connected in a view only state for public key: ${vegaWalletPubKey}. In order to send transactions you must connect to a real wallet.`;
 
     goToMakeNewProposal(governanceProposalType.RAW);
@@ -55,7 +55,10 @@ context('View functionality with public key', { tags: '@smoke' }, function () {
     cy.getByTestId('dialog-content')
       .first()
       .within(() => {
-        cy.get('h1').should('have.text', 'Transaction failed');
+        cy.getByTestId('dialog-title').should(
+          'have.text',
+          'Transaction failed'
+        );
         cy.getByTestId('Error').should('have.text', expectedErrorTxt);
       });
   });

apps/governance-e2e/src/support/proposal.functions.ts

@@ -112,6 +112,7 @@ export function createNewMarketProposalTxBody(): ProposalSubmissionBody {
               performanceHysteresisEpochs: 2,
               slaCompetitionFactor: '0.1',
             },
+            // FIXME: workaround because of https://github.com/vegaprotocol/vega/issues/10343
             quadraticSlippageFactor: '0',
             instrument: {
               name: 'Token test market',
@@ -196,6 +197,7 @@ export function createNewMarketProposalTxBody(): ProposalSubmissionBody {
                 timeWindow: '3600',
                 scalingFactor: 10,
               },
+              // FIXME: workaround because of https://github.com/vegaprotocol/vega/issues/10343
               triggeringRatio: '0.7',
               auctionExtension: '1',
             },
@@ -240,6 +242,7 @@ export function createSuccessorMarketProposalTxBody(
             decimalPlaces: '5',
             positionDecimalPlaces: '5',
             linearSlippageFactor: '0.001',
+            // FIXME: workaround because of https://github.com/vegaprotocol/vega/issues/10343
             quadraticSlippageFactor: '0',
             liquiditySlaParameters: {
               priceRange: '0.5',
@@ -334,6 +337,7 @@ export function createSuccessorMarketProposalTxBody(
                 timeWindow: '3600',
                 scalingFactor: 10,
               },
+              // FIXME: workaround because of https://github.com/vegaprotocol/vega/issues/10343
               triggeringRatio: '0.7',
               auctionExtension: '1',
             },

apps/governance/src/app.tsx

@@ -26,7 +26,7 @@ import {
 } from '@vegaprotocol/web3';
 import { Web3Provider } from '@vegaprotocol/web3';
 import { VegaWalletDialogs } from './components/vega-wallet-dialogs';
-import { VegaWalletProvider } from '@vegaprotocol/wallet';
+import { VegaWalletProvider, useChainId } from '@vegaprotocol/wallet';
 import {
   useVegaTransactionManager,
   useVegaTransactionUpdater,
@@ -96,7 +96,9 @@ const cache: InMemoryCacheConfig = {
 const Web3Container = ({
   chainId,
 }: {
+  /** Ethereum chain id */
   chainId: number;
+  /** Ethereum provider url */
   providerUrl: string;
 }) => {
   const InitializeHandlers = () => {
@@ -123,6 +125,9 @@ const Web3Container = ({
     MOZILLA_EXTENSION_URL,
     VEGA_WALLET_URL,
   } = useEnvironment();
+
+  const vegaChainId = useChainId(VEGA_URL);
+
   useEffect(() => {
     if (chainId) {
       return initializeConnectors(
@@ -157,7 +162,8 @@ const Web3Container = ({
     !VEGA_EXPLORER_URL ||
     !DocsLinks ||
     !CHROME_EXTENSION_URL ||
-    !MOZILLA_EXTENSION_URL
+    !MOZILLA_EXTENSION_URL ||
+    !vegaChainId
   ) {
     return null;
   }
@@ -169,6 +175,7 @@ const Web3Container = ({
           config={{
             network: VEGA_ENV,
             vegaUrl: VEGA_URL,
+            chainId: vegaChainId,
             vegaWalletServiceUrl: VEGA_WALLET_URL,
             links: {
               explorer: VEGA_EXPLORER_URL,

apps/governance/src/lib/party.test.ts

@@ -0,0 +1,112 @@
+import type { ApolloError } from '@apollo/client';
+import {
+  PARTY_NOT_FOUND,
+  filterAcceptableGraphqlErrors,
+  isPartyNotFoundError,
+} from './party';
+import type { GraphQLError } from 'graphql';
+
+/**
+ *
+ * @param message
+ * @returns GraphQLError
+ */
+function createMockApolloErrors(message: string): GraphQLError {
+  return {
+    message,
+    extensions: {
+      code: message.toUpperCase().replace(/ /g, '_'),
+    },
+    locations: [],
+    originalError: new Error(message),
+    path: [],
+    nodes: [],
+    positions: [1],
+    name: message,
+    source: {
+      body: message,
+      name: message,
+      locationOffset: {
+        line: 1,
+        column: 1,
+      },
+    },
+  };
+}
+
+describe('filterAcceptableGraphqlErrors', () => {
+  it('should return undefined if the error is a party not found error', () => {
+    const error: Partial<ApolloError> = {
+      graphQLErrors: [createMockApolloErrors('failed to get party for ID')],
+    };
+
+    const result = filterAcceptableGraphqlErrors(error as ApolloError);
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should return the error if it is not a party not found error', () => {
+    const error: Partial<ApolloError> = {
+      graphQLErrors: [createMockApolloErrors('Some other error')],
+    };
+
+    const result = filterAcceptableGraphqlErrors(error as ApolloError);
+
+    expect(result).toEqual(error);
+  });
+
+  it('should return the error if there are multiple errors', () => {
+    const error: Partial<ApolloError> = {
+      graphQLErrors: [
+        createMockApolloErrors('failed to get party for ID'),
+        createMockApolloErrors('Some other error'),
+      ],
+    };
+
+    const result = filterAcceptableGraphqlErrors(error as ApolloError);
+
+    expect(result).toEqual(error);
+  });
+
+  it('should return the error if there are no errors', () => {
+    const error: Partial<ApolloError> = {
+      graphQLErrors: [],
+    };
+
+    const result = filterAcceptableGraphqlErrors(error as ApolloError);
+
+    expect(result).toEqual(error);
+  });
+
+  it('should return undefined if the error is undefined', () => {
+    const result = filterAcceptableGraphqlErrors(undefined);
+
+    expect(result).toBeUndefined();
+  });
+});
+
+describe('isPartyNotFoundError', () => {
+  it('should return true if the error message includes PARTY_NOT_FOUND', () => {
+    const error = { message: 'failed to get party for ID' };
+
+    const result = isPartyNotFoundError(error);
+
+    expect(result).toBe(true);
+  });
+
+  it('should return false if the error message does not include PARTY_NOT_FOUND', () => {
+    const error = { message: 'Some other error' };
+
+    const result = isPartyNotFoundError(error);
+
+    expect(result).toBe(false);
+  });
+
+  // Will trip if the error message changes, which should not be a problem, but there
+  // might be logic that depends on it
+  it('expects party not found error to remain consistent', () => {
+    const error = 'failed to get party for ID';
+
+    expect(PARTY_NOT_FOUND).toStrictEqual(error);
+  });
+});

apps/governance/src/lib/party.ts

@@ -1,3 +1,5 @@
+import type { ApolloError } from '@apollo/client';
+
 export const PARTY_NOT_FOUND = 'failed to get party for ID';
 
 export const isPartyNotFoundError = (error: { message: string }) => {
@@ -6,3 +8,23 @@ export const isPartyNotFoundError = (error: { message: string }) => {
   }
   return false;
 };
+
+/**
+ * If a party has no accounts or data, then this GraphQL query believes it does not exist
+ * Not having any rewards is a valid state, so in some cases we can filter this error out.
+ *
+ * @param error ApolloError | undefined
+ * @returns ApolloError | undefined
+ */
+export function filterAcceptableGraphqlErrors(
+  error?: ApolloError
+): ApolloError | undefined {
+  // Currently the only error we expect is when a party has no accounts
+  if (error && error.graphQLErrors.length === 1) {
+    if (isPartyNotFoundError(error.graphQLErrors[0])) {
+      return;
+    }
+  }
+
+  return error;
+}

apps/governance/src/routes/proposals/components/proposal-detail-header/proposal-header.spec.tsx

@@ -126,7 +126,7 @@ describe('Proposal header', () => {
       screen.queryByTestId('proposal-description')
     ).not.toBeInTheDocument();
     expect(screen.getByTestId('proposal-details')).toHaveTextContent(
-      'Market change: MarketId'
+      'Update to market ID: MarketId'
     );
   });
 

apps/governance/src/routes/proposals/components/proposal-detail-header/proposal-header.tsx

@@ -1,5 +1,11 @@
 import { useTranslation } from 'react-i18next';
-import { Lozenge, VegaIcon, VegaIconNames } from '@vegaprotocol/ui-toolkit';
+import {
+  CopyWithTooltip,
+  Lozenge,
+  Tooltip,
+  VegaIcon,
+  VegaIconNames,
+} from '@vegaprotocol/ui-toolkit';
 import { shorten } from '@vegaprotocol/utils';
 import { Heading, SubHeading } from '../../../../components/heading';
 import { type ReactNode } from 'react';
@@ -11,7 +17,12 @@ import {
   useNewTransferProposalDetails,
   useSuccessorMarketProposalDetails,
 } from '@vegaprotocol/proposals';
-import { useFeatureFlags } from '@vegaprotocol/environment';
+import {
+  CONSOLE_MARKET_PAGE,
+  DApp,
+  useFeatureFlags,
+  useLinks,
+} from '@vegaprotocol/environment';
 import Routes from '../../../routes';
 import { Link } from 'react-router-dom';
 import { type VoteState } from '../vote-details/use-user-vote';
@@ -32,6 +43,8 @@ export const ProposalHeader = ({
   const { t } = useTranslation();
   const change = proposal?.terms.change;
 
+  const consoleLink = useLinks(DApp.Console);
+
   let details: ReactNode;
   let proposalType = '';
   let fallbackTitle = '';
@@ -106,8 +119,33 @@ export const ProposalHeader = ({
       fallbackTitle = t('UpdateMarketProposal');
       details = (
         <>
-          <span>{t('MarketChange')}:</span>{' '}
-          <span>{truncateMiddle(change.marketId)}</span>
+          <span>{t('UpdateToMarket')}:</span>{' '}
+          <span className="inline-flex items-start gap-2">
+            <span className="break-all">{change.marketId} </span>
+            <span className="inline-flex items-end gap-0">
+              <CopyWithTooltip
+                text={change.marketId}
+                description={t('copyToClipboard')}
+              >
+                <button className="inline-block px-1">
+                  <VegaIcon size={20} name={VegaIconNames.COPY} />
+                </button>
+              </CopyWithTooltip>
+              <Tooltip description={t('OpenInConsole')} align="center">
+                <button
+                  className="inline-block px-1"
+                  onClick={() => {
+                    const marketPageLink = consoleLink(
+                      CONSOLE_MARKET_PAGE.replace(':marketId', change.marketId)
+                    );
+                    window.open(marketPageLink, '_blank');
+                  }}
+                >
+                  <VegaIcon size={20} name={VegaIconNames.OPEN_EXTERNAL} />
+                </button>
+              </Tooltip>
+            </span>
+          </span>
         </>
       );
       break;

apps/governance/src/routes/proposals/components/proposal/proposal.spec.tsx

@@ -48,6 +48,7 @@ const vegaWalletConfig: VegaWalletConfig = {
     chromeExtensionUrl: 'chrome',
     mozillaExtensionUrl: 'mozilla',
   },
+  chainId: 'VEGA_CHAIN_ID',
 };
 
 const renderComponent = (proposal: IProposal) => {

apps/governance/src/routes/proposals/components/proposals-list/proposals-list.spec.tsx

@@ -63,7 +63,7 @@ const closedProtocolUpgradeProposal = generateProtocolUpgradeProposal({
 });
 
 const renderComponent = (
-  proposals: Proposal,
+  proposals: Proposal[],
   protocolUpgradeProposals?: ProtocolUpgradeProposalFieldsFragment[]
 ) => (
   <Router>

apps/governance/src/routes/proposals/components/vote-details/vote-buttons.tsx

@@ -18,6 +18,7 @@ import { ProposalMinRequirements, ProposalUserAction } from '../shared';
 import { VoteTransactionDialog } from './vote-transaction-dialog';
 import { useVoteButtonsQuery } from './__generated__/Stake';
 import type { DialogProps, VegaTxState } from '@vegaprotocol/proposals';
+import { filterAcceptableGraphqlErrors } from '../../../../lib/party';
 
 interface VoteButtonsContainerProps {
   voteState: VoteState | null;
@@ -42,8 +43,10 @@ export const VoteButtonsContainer = (props: VoteButtonsContainerProps) => {
     skip: !pubKey,
   });
 
+  const filteredErrors = filterAcceptableGraphqlErrors(error);
+
   return (
-    <AsyncRenderer loading={loading} error={error} data={data}>
+    <AsyncRenderer loading={loading} error={filteredErrors} data={data}>
       <VoteButtons
         {...props}
         currentStakeAvailable={toBigNum(

apps/governance/src/routes/proposals/proposal/Proposal.graphql

@@ -206,7 +206,6 @@ query Proposal(
               }
             }
             liquidityMonitoringParameters {
-              triggeringRatio
               targetStakeParameters {
                 timeWindow
                 scalingFactor
@@ -214,7 +213,6 @@ query Proposal(
             }
             positionDecimalPlaces
             linearSlippageFactor
-            quadraticSlippageFactor
           }
           ... on UpdateMarket {
             marketId
@@ -367,7 +365,6 @@ query Proposal(
                 }
               }
               liquidityMonitoringParameters {
-                triggeringRatio
                 targetStakeParameters {
                   timeWindow
                   scalingFactor

apps/governance/src/routes/rewards/epoch-individual-rewards/epoch-individual-rewards.tsx

@@ -10,6 +10,7 @@ import { EpochIndividualRewardsTable } from './epoch-individual-rewards-table';
 import { generateEpochIndividualRewardsList } from './generate-epoch-individual-rewards-list';
 import { calculateEpochOffset } from '../../../lib/epoch-pagination';
 import { useNetworkParam } from '@vegaprotocol/network-parameters';
+import { filterAcceptableGraphqlErrors } from '../../../lib/party';
 
 const EPOCHS_PAGE_SIZE = 10;
 
@@ -99,17 +100,24 @@ export const EpochIndividualRewards = ({
     prevEpochIdRef.current = epochId;
   }, [epochId, refetchData]);
 
+  // Workarounds for the error handling of AsyncRenderer
+  const filteredErrors = filterAcceptableGraphqlErrors(error);
+  const filteredData = data || [];
+
   return (
     <AsyncRenderer
       loading={loading}
-      error={error}
-      data={data}
+      error={filteredErrors}
+      data={filteredData}
       render={() => (
         <div>
           <p data-testid="connected-vega-key" className="mb-10">
             {t('Connected Vega key')}:{' '}
             <span className="text-white">{pubKey}</span>
           </p>
+          {epochIndividualRewardSummaries.length === 0 && (
+            <p>{t('No rewards for key')}</p>
+          )}
           {epochIndividualRewardSummaries.map(
             (epochIndividualRewardSummary) => (
               <EpochIndividualRewardsTable
@@ -118,17 +126,19 @@ export const EpochIndividualRewards = ({
               />
             )
           )}
-          <Pagination
-            isLoading={loading}
-            hasPrevPage={page > 1}
-            hasNextPage={page < totalPages}
-            onBack={() => refetchData(page - 1)}
-            onNext={() => refetchData(page + 1)}
-            onFirst={() => refetchData(1)}
-            onLast={() => refetchData(totalPages)}
-          >
-            {t('Page')} {page}
-          </Pagination>
+          {epochIndividualRewardSummaries.length > 0 && (
+            <Pagination
+              isLoading={loading}
+              hasPrevPage={page > 1}
+              hasNextPage={page < totalPages}
+              onBack={() => refetchData(page - 1)}
+              onNext={() => refetchData(page + 1)}
+              onFirst={() => refetchData(1)}
+              onLast={() => refetchData(totalPages)}
+            >
+              {t('Page')} {page}
+            </Pagination>
+          )}
         </div>
       )}
     />

apps/governance/src/routes/staking/home/validator-tables/consensus-validators-table.spec.tsx

@@ -16,7 +16,7 @@ import type { ValidatorsView } from './validator-tables';
 const nodeFactory = (
   overrides?: PartialDeep<NodesFragmentFragment>
 ): NodesFragmentFragment => {
-  const defaultNode = {
+  const defaultNode: NodesFragmentFragment = {
     id: 'ccc022b7e63a4d0a6d3a193c3940c88574060e58a184964c994998d86835a1b4',
     name: 'high',
     avatarUrl: 'https://upload.wikimedia.org/wikipedia/en/2/25/Marvin-TV-3.jpg',
@@ -288,7 +288,7 @@ describe('Consensus validators table', () => {
 
     expect(
       grid.querySelector('[role="gridcell"][col-id="totalPenalties"]')
-    ).toHaveTextContent('10.07%');
+    ).toHaveTextContent('13.16%');
 
     expect(
       grid.querySelector('[role="gridcell"][col-id="normalisedVotingPower"]')

apps/governance/src/routes/staking/home/validator-tables/consensus-validators-table.tsx

@@ -185,6 +185,15 @@ export const ConsensusValidatorsTable = ({
           const { rawValidatorScore: previousEpochValidatorScore } =
             getLastEpochScoreAndPerformance(previousEpochData, id);
 
+          const overstakingPenalty = calculateOverallPenalty(
+            id,
+            allNodesInPreviousEpoch
+          );
+          const totalPenalty = calculateOverstakedPenalty(
+            id,
+            allNodesInPreviousEpoch
+          );
+
           return {
             id,
             [ValidatorFields.RANKING_INDEX]: stakedTotalRanking,
@@ -213,11 +222,11 @@ export const ConsensusValidatorsTable = ({
               2
             ),
             [ValidatorFields.OVERSTAKING_PENALTY]: formatNumberPercentage(
-              calculateOverstakedPenalty(id, allNodesInPreviousEpoch),
+              overstakingPenalty,
               2
             ),
             [ValidatorFields.TOTAL_PENALTIES]: formatNumberPercentage(
-              calculateOverallPenalty(id, allNodesInPreviousEpoch),
+              totalPenalty,
               2
             ),
             [ValidatorFields.PENDING_STAKE]: pendingStake,

apps/governance/src/routes/staking/home/validator-tables/standby-pending-validators-table.tsx

@@ -124,6 +124,15 @@ export const StandbyPendingValidatorsTable = ({
             }
           }
 
+          const overstakingPenalty = calculateOverallPenalty(
+            id,
+            allNodesInPreviousEpoch
+          );
+          const totalPenalty = calculateOverstakedPenalty(
+            id,
+            allNodesInPreviousEpoch
+          );
+
           return {
             id,
             [ValidatorFields.RANKING_INDEX]: stakedTotalRanking,
@@ -154,11 +163,11 @@ export const StandbyPendingValidatorsTable = ({
               2
             ),
             [ValidatorFields.OVERSTAKING_PENALTY]: formatNumberPercentage(
-              calculateOverstakedPenalty(id, allNodesInPreviousEpoch),
+              overstakingPenalty,
               2
             ),
             [ValidatorFields.TOTAL_PENALTIES]: formatNumberPercentage(
-              calculateOverallPenalty(id, allNodesInPreviousEpoch),
+              totalPenalty,
               2
             ),
             [ValidatorFields.PENDING_STAKE]: pendingStake,

apps/governance/src/routes/staking/node/validator-table.tsx

@@ -266,7 +266,9 @@ export const ValidatorTable = ({
 
                 <Tooltip description={t('OverstakedPenaltyDescription')}>
                   <span data-testid="overstaking-penalty">
-                    {formatNumberPercentage(penalties.overstaked, 2)}
+                    {penalties.overstaked
+                      ? formatNumberPercentage(penalties.overstaked, 2)
+                      : '-'}
                   </span>
                 </Tooltip>
               </KeyValueTableRow>
@@ -285,7 +287,9 @@ export const ValidatorTable = ({
                 </span>
                 <span data-testid="total-penalties">
                   <strong>
-                    {formatNumberPercentage(penalties.overall, 2)}
+                    {penalties.overall
+                      ? formatNumberPercentage(penalties.overall, 2)
+                      : '-'}
                   </strong>
                 </span>
               </KeyValueTableRow>

apps/governance/src/routes/staking/shared.spec.ts

@@ -3,11 +3,11 @@ import {
   getLastEpochScoreAndPerformance,
   getNormalisedVotingPower,
   getUnnormalisedVotingPower,
-  getOverstakingPenalty,
   getFormattedPerformanceScore,
   getPerformancePenalty,
-  getTotalPenalties,
   getStakePercentage,
+  calculateOverallPenalty,
+  calculateOverstakedPenalty,
 } from './shared';
 import * as Schema from '@vegaprotocol/types';
 
@@ -106,38 +106,6 @@ describe('getUnnormalisedVotingPower', () => {
   });
 });
 
-describe('getOverstakingPenalty', () => {
-  it('returns "0%" when both arguments are null or undefined', () => {
-    expect(getOverstakingPenalty(null, null)).toBe('0%');
-    expect(getOverstakingPenalty(undefined, undefined)).toBe('0%');
-    expect(getOverstakingPenalty(null, undefined)).toBe('0%');
-    expect(getOverstakingPenalty(undefined, null)).toBe('0%');
-  });
-
-  it('returns "0%" when one argument is null or undefined', () => {
-    expect(getOverstakingPenalty('10', null)).toBe('0%');
-    expect(getOverstakingPenalty(null, '20')).toBe('0%');
-    expect(getOverstakingPenalty('10', undefined)).toBe('0%');
-    expect(getOverstakingPenalty(undefined, '20')).toBe('0%');
-  });
-
-  it('returns "0%" when validatorScore or stakeScore is zero', () => {
-    expect(getOverstakingPenalty('0', '20')).toBe('0%');
-    expect(getOverstakingPenalty('10', '0')).toBe('0%');
-  });
-
-  it('returns the correct overstaking penalty', () => {
-    expect(getOverstakingPenalty('0.18', '0.2')).toBe('10.00%');
-    expect(getOverstakingPenalty('0.2', '0.2')).toBe('0.00%');
-    expect(getOverstakingPenalty('0.04', '0.2')).toBe('80.00%');
-  });
-
-  it('handles string numbers with decimals', () => {
-    expect(getOverstakingPenalty('7.5', '15')).toBe('50.00%');
-    expect(getOverstakingPenalty('12.5', '25')).toBe('50.00%');
-  });
-});
-
 describe('getFormattedPerformanceScore', () => {
   it('should return the formatted performance score', () => {
     expect(getFormattedPerformanceScore('0.25')).toEqual(new BigNumber(0.25));
@@ -152,17 +120,6 @@ describe('getPerformancePenalty', () => {
   });
 });
 
-describe('getTotalPenalties', () => {
-  it('should return the total penalties', () => {
-    expect(getTotalPenalties('0.25', '1', '5000', '10000')).toEqual('50.00%');
-    expect(getTotalPenalties('0.25', '0.5', '5000', '10000')).toEqual('75.00%');
-  });
-
-  it('should return 0 if the total penalties is negative', () => {
-    expect(getTotalPenalties('0.25', '0.5', '1000', '10000')).toEqual('0.00%');
-  });
-});
-
 describe('getStakePercentage', () => {
   it('should return the stake percentage', () => {
     expect(
@@ -182,3 +139,107 @@ describe('getStakePercentage', () => {
     );
   });
 });
+
+describe('calculateOverallPenalty', () => {
+  it('returns null if rewardScore is null', () => {
+    const res = calculateOverallPenalty('1', [
+      {
+        id: '1',
+        rewardScore: null,
+        stakedTotal: '',
+        rankingScore: {
+          stakeScore: '0.25',
+          performanceScore: '0.75',
+          status: Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          previousStatus:
+            Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          rankingScore: '',
+          votingPower: '',
+        },
+      },
+    ]);
+
+    expect(res).toBeNull();
+  });
+
+  it('returns null if rewardScore.rawValidatorScore is null (should not happen)', () => {
+    const res = calculateOverallPenalty('1', [
+      {
+        id: '1',
+        stakedTotal: '',
+        rewardScore: {
+          rawValidatorScore: '0.25',
+          performanceScore: '0.75',
+          multisigScore: '',
+          validatorScore: null as unknown as string,
+          normalisedScore: '',
+          validatorStatus:
+            Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+        },
+        rankingScore: {
+          stakeScore: '0.25',
+          performanceScore: '0.75',
+          status: Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          previousStatus:
+            Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          rankingScore: '',
+          votingPower: '',
+        },
+      },
+    ]);
+
+    expect(res).toBeNull();
+  });
+});
+
+describe('calculateOverstakedPenalty', () => {
+  it('returns null if rewardScore is null', () => {
+    const res = calculateOverstakedPenalty('1', [
+      {
+        id: '1',
+        rewardScore: null,
+        stakedTotal: '',
+        rankingScore: {
+          stakeScore: '0.25',
+          performanceScore: '0.75',
+          status: Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          previousStatus:
+            Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          rankingScore: '',
+          votingPower: '',
+        },
+      },
+    ]);
+
+    expect(res).toBeNull();
+  });
+
+  it('returns null if rewardScore.rawValidatorScore is null (should not happen)', () => {
+    const res = calculateOverstakedPenalty('1', [
+      {
+        id: '1',
+        stakedTotal: '',
+        rewardScore: {
+          rawValidatorScore: null as unknown as string,
+          performanceScore: '0.75',
+          multisigScore: '',
+          validatorScore: '',
+          normalisedScore: '',
+          validatorStatus:
+            Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+        },
+        rankingScore: {
+          stakeScore: '0.25',
+          performanceScore: '0.75',
+          status: Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          previousStatus:
+            Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+          rankingScore: '',
+          votingPower: '',
+        },
+      },
+    ]);
+
+    expect(res).toBeNull();
+  });
+});

apps/governance/src/routes/staking/shared.ts

@@ -5,6 +5,7 @@ import {
 import type { PreviousEpochQuery } from './__generated__/PreviousEpoch';
 import { BigNumber } from '../../lib/bignumber';
 import type { LastArrayElement } from 'type-fest';
+import isNull from 'lodash/isNull';
 
 type Node = NonNullable<
   LastArrayElement<
@@ -21,7 +22,10 @@ type Node = NonNullable<
  * @returns Theoretical stake score for given node based on the staked total
  * of all node of the same type (status)
  */
-const calculateTheoreticalStakeScore = (nodeId: string, nodes: Node[]) => {
+const calculateTheoreticalStakeScore = (
+  nodeId: string,
+  nodes: Node[]
+): BigNumber | null => {
   const node = nodes.find((n) => n.id === nodeId);
   if (!node) {
     return new BigNumber(0);
@@ -42,14 +46,25 @@ const calculateTheoreticalStakeScore = (nodeId: string, nodes: Node[]) => {
  * @param nodes A collection of all nodes - needed to calculate theoretical stake score
  * @returns %
  */
-export const calculateOverallPenalty = (nodeId: string, nodes: Node[]) => {
+export const calculateOverallPenalty = (
+  nodeId: string,
+  nodes: Node[]
+): BigNumber | null => {
   const node = nodes.find((n) => n.id === nodeId);
   const tts = calculateTheoreticalStakeScore(nodeId, nodes);
-  if (!node || tts.isZero()) {
+  if (
+    !node ||
+    isNull(tts) ||
+    !node.rewardScore ||
+    (node.rewardScore && isNull(node.rewardScore.validatorScore))
+  ) {
+    return null;
+  }
+  if (tts.isZero()) {
     return new BigNumber(0);
   }
   const penalty = new BigNumber(1)
-    .minus(new BigNumber(node.rewardScore?.validatorScore || 0).dividedBy(tts))
+    .minus(new BigNumber(node.rewardScore.validatorScore).dividedBy(tts))
     .times(100);
   return penalty.isLessThan(0) ? new BigNumber(0) : penalty;
 };
@@ -60,10 +75,21 @@ export const calculateOverallPenalty = (nodeId: string, nodes: Node[]) => {
  * @param nodes A collection of all nodes - needed to calculate theoretical stake score
  * @returns %
  */
-export const calculateOverstakedPenalty = (nodeId: string, nodes: Node[]) => {
+export const calculateOverstakedPenalty = (
+  nodeId: string,
+  nodes: Node[]
+): BigNumber | null => {
   const node = nodes.find((n) => n.id === nodeId);
   const tts = calculateTheoreticalStakeScore(nodeId, nodes);
-  if (!node || tts.isZero()) {
+  if (
+    !node ||
+    isNull(tts) ||
+    isNull(node.rewardScore) ||
+    (node.rewardScore && node.rewardScore.rawValidatorScore === null)
+  ) {
+    return null;
+  }
+  if (tts.isZero()) {
     return new BigNumber(0);
   }
   const penalty = new BigNumber(1)
@@ -78,7 +104,9 @@ export const calculateOverstakedPenalty = (nodeId: string, nodes: Node[]) => {
  * Calculates performance penalty based on the given performance score.
  * @returns %
  */
-export const calculatesPerformancePenalty = (performanceScore: string) => {
+export const calculatesPerformancePenalty = (
+  performanceScore: string
+): BigNumber => {
   const penalty = new BigNumber(1)
     .minus(new BigNumber(performanceScore))
     .times(100);
@@ -123,60 +151,6 @@ export const getPerformancePenalty = (performanceScore?: string) =>
     2
   );
 
-export const getOverstakingPenalty = (
-  validatorScore: string | null | undefined,
-  stakeScore: string | null | undefined
-) => {
-  if (!validatorScore || !stakeScore) {
-    return '0%';
-  }
-
-  // avoid division by zero
-  if (
-    new BigNumber(validatorScore).isZero() ||
-    new BigNumber(stakeScore).isZero()
-  ) {
-    return '0%';
-  }
-
-  return formatNumberPercentage(
-    BigNumber.max(
-      new BigNumber(1)
-        .minus(
-          new BigNumber(validatorScore).dividedBy(new BigNumber(stakeScore))
-        )
-        .times(100),
-      new BigNumber(0)
-    ),
-    2
-  );
-};
-
-export const getTotalPenalties = (
-  rawValidatorScore: string | null | undefined,
-  performanceScore: string | undefined,
-  stakedOnNode: string,
-  totalStake: string
-) => {
-  const calc =
-    rawValidatorScore &&
-    performanceScore &&
-    new BigNumber(totalStake).isGreaterThan(0)
-      ? new BigNumber(1).minus(
-          new BigNumber(performanceScore)
-            .times(new BigNumber(rawValidatorScore))
-            .dividedBy(
-              new BigNumber(stakedOnNode).dividedBy(new BigNumber(totalStake))
-            )
-        )
-      : new BigNumber(0);
-
-  return formatNumberPercentage(
-    calc.isPositive() ? calc.times(100) : new BigNumber(0),
-    2
-  );
-};
-
 export const getStakePercentage = (total: BigNumber, stakedOnNode: BigNumber) =>
   total.isEqualTo(0) || stakedOnNode.isEqualTo(0)
     ? '0%'

apps/governance/src/toasts-manager.tsx

@@ -1,14 +1,50 @@
-import { ToastsContainer, useToasts } from '@vegaprotocol/ui-toolkit';
+import {
+  Intent,
+  ToastsContainer,
+  TradingButton,
+  VegaIcon,
+  VegaIconNames,
+  useToasts,
+} from '@vegaprotocol/ui-toolkit';
+import { useVegaWalletDialogStore } from '@vegaprotocol/wallet';
 import {
   useEthereumTransactionToasts,
   useEthereumWithdrawApprovalsToasts,
   useVegaTransactionToasts,
+  useWalletDisconnectToastActions,
+  useWalletDisconnectedToasts,
 } from '@vegaprotocol/web3';
+import { useTranslation } from 'react-i18next';
+
+const WalletDisconnectAdditionalContent = () => {
+  const { t } = useTranslation();
+  const { hideToast } = useWalletDisconnectToastActions();
+  const openVegaWalletDialog = useVegaWalletDialogStore(
+    (store) => store.openVegaWalletDialog
+  );
+  return (
+    <p className="mt-2">
+      <TradingButton
+        data-testid="connect-vega-wallet"
+        onClick={() => {
+          hideToast();
+          openVegaWalletDialog();
+        }}
+        size="small"
+        intent={Intent.Danger}
+        icon={<VegaIcon name={VegaIconNames.ARROW_RIGHT} size={14} />}
+      >
+        <span className="whitespace-nowrap uppercase">{t('Connect')}</span>
+      </TradingButton>
+    </p>
+  );
+};
 
 export const ToastsManager = () => {
   useVegaTransactionToasts();
   useEthereumTransactionToasts();
   useEthereumWithdrawApprovalsToasts();
+  useWalletDisconnectedToasts(<WalletDisconnectAdditionalContent />);
 
   const toasts = useToasts((store) => store.toasts);
   return <ToastsContainer order="desc" toasts={toasts} />;

apps/trading/.env

@@ -21,8 +21,15 @@ NX_WALLETCONNECT_PROJECT_ID=fe8091dc35738863e509fc4947525c72
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
+NX_ISOLATED_MARGIN=true
 NX_ICEBERG_ORDERS=true
-# NX_PRODUCT_PERPETUALS
 NX_METAMASK_SNAPS=true
 NX_REFERRALS=true
+# NX_DISABLE_CLOSE_POSITION=false
 NX_TEAM_COMPETITION=true
+
+NX_TENDERMINT_URL=https://be.vega.community
+NX_TENDERMINT_WEBSOCKET_URL=wss://be.vega.community/websocket
+
+NX_CHARTING_LIBRARY_PATH=https://assets.vega.community/trading-view-bundle/v0.0.1/
+NX_CHARTING_LIBRARY_HASH=PDjWaqPFndDp+LCvqbKvntWriaqNzNpZ5i9R/BULzCg=

apps/trading/.env.capsule

@@ -21,6 +21,7 @@ NX_ETH_WALLET_MNEMONIC="ozone access unlock valid olympic save include omit supp
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=false
 NX_STOP_ORDERS=false
+NX_ISOLATED_MARGIN=true
 # NX_ICEBERG_ORDERS
 # NX_PRODUCT_PERPETUALS
 NX_METAMASK_SNAPS=false

apps/trading/.env.devnet

@@ -20,6 +20,7 @@ NX_ORACLE_PROOFS_URL=https://raw.githubusercontent.com/vegaprotocol/well-known/m
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
+NX_ISOLATED_MARGIN=true
 # NX_ICEBERG_ORDERS
 # NX_PRODUCT_PERPETUALS
 NX_METAMASK_SNAPS=true
@@ -27,3 +28,8 @@ NX_REFERRALS=true
 
 NX_TENDERMINT_URL=https://tm.be.devnet1.vega.xyz/
 NX_TENDERMINT_WEBSOCKET_URL=wss://be.devnet1.vega.xyz/websocket
+
+NX_TEAM_COMPETITION=true
+
+NX_CHARTING_LIBRARY_PATH=https://assets.vega.community/trading-view-bundle/v0.0.1/
+NX_CHARTING_LIBRARY_HASH=PDjWaqPFndDp+LCvqbKvntWriaqNzNpZ5i9R/BULzCg=

apps/trading/.env.mainnet

@@ -21,6 +21,7 @@ NX_WALLETCONNECT_PROJECT_ID=fe8091dc35738863e509fc4947525c72
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
+NX_ISOLATED_MARGIN=false
 NX_ICEBERG_ORDERS=true
 NX_METAMASK_SNAPS=true
 NX_REFERRALS=true
@@ -28,3 +29,6 @@ NX_REFERRALS=true
 
 NX_TENDERMINT_URL=https://be.vega.community
 NX_TENDERMINT_WEBSOCKET_URL=wss://be.vega.community/websocket
+
+NX_CHARTING_LIBRARY_PATH=https://assets.vega.community/trading-view-bundle/v0.0.1/
+NX_CHARTING_LIBRARY_HASH=PDjWaqPFndDp+LCvqbKvntWriaqNzNpZ5i9R/BULzCg=

apps/trading/.env.mainnet-mirror

@@ -21,6 +21,7 @@ NX_APP_VERSION=v0.20.19-core-0.71.6
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
+NX_ISOLATED_MARGIN=false
 NX_ICEBERG_ORDERS=true
 # NX_PRODUCT_PERPETUALS
 NX_METAMASK_SNAPS=false

apps/trading/.env.stagnet1

@@ -21,10 +21,12 @@ NX_WALLETCONNECT_PROJECT_ID=fe8091dc35738863e509fc4947525c72
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
+NX_ISOLATED_MARGIN=true
 NX_ICEBERG_ORDERS=true
 # NX_PRODUCT_PERPETUALS
 NX_METAMASK_SNAPS=true
 NX_REFERRALS=true
+NX_TEAM_COMPETITION=true
 
 NX_CHARTING_LIBRARY_PATH=https://assets.vega.community/trading-view-bundle/v0.0.1/
 NX_CHARTING_LIBRARY_HASH=PDjWaqPFndDp+LCvqbKvntWriaqNzNpZ5i9R/BULzCg=

apps/trading/.env.testnet

@@ -22,9 +22,11 @@ NX_WALLETCONNECT_PROJECT_ID=fe8091dc35738863e509fc4947525c72
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
+NX_ISOLATED_MARGIN=true
 NX_ICEBERG_ORDERS=true
 NX_METAMASK_SNAPS=true
 NX_REFERRALS=true
+NX_TEAM_COMPETITION=true
 
 NX_TENDERMINT_URL=https://tm.be.testnet.vega.xyz
 NX_TENDERMINT_WEBSOCKET_URL=wss://be.testnet.vega.xyz/websocket

apps/trading/.env.validators-testnet

@@ -22,6 +22,7 @@ NX_ORACLE_PROOFS_URL=https://raw.githubusercontent.com/vegaprotocol/well-known/m
 # Cosmic elevator flags
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
+NX_ISOLATED_MARGIN=true
 NX_ICEBERG_ORDERS=true
 # NX_PRODUCT_PERPETUALS
 NX_METAMASK_SNAPS=false

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

@@ -0,0 +1,131 @@
+import { useSearchParams } from 'react-router-dom';
+import { Intent, TradingAnchorButton } from '@vegaprotocol/ui-toolkit';
+import { useVegaWallet, useVegaWalletDialogStore } from '@vegaprotocol/wallet';
+import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
+import { useT } from '../../lib/use-t';
+import { useReferralSetTransaction } from '../../lib/hooks/use-referral-set-transaction';
+import { DApp, TokenStaticLinks, useLinks } from '@vegaprotocol/environment';
+import { RainbowButton } from '../../components/rainbow-button';
+import { usePageTitle } from '../../lib/hooks/use-page-title';
+import { ErrorBoundary } from '../../components/error-boundary';
+import { Box } from '../../components/competitions/box';
+import { LayoutWithGradient } from '../../components/layouts-inner';
+import { Links } from '../../lib/links';
+import { TeamForm, TransactionType } from './team-form';
+
+export const CompetitionsCreateTeam = () => {
+  const [searchParams] = useSearchParams();
+  const isSolo = Boolean(searchParams.get('solo'));
+  const t = useT();
+
+  usePageTitle(t('Create a team'));
+
+  const { isReadOnly, pubKey } = useVegaWallet();
+  const openWalletDialog = useVegaWalletDialogStore(
+    (store) => store.openVegaWalletDialog
+  );
+
+  return (
+    <ErrorBoundary feature="create-team">
+      <LayoutWithGradient>
+        <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')}
+            </h1>
+            {pubKey && !isReadOnly ? (
+              <CreateTeamFormContainer isSolo={isSolo} />
+            ) : (
+              <>
+                <p>
+                  {t(
+                    'Create a team to participate in team based rewards as well as access the discount benefits of the current referral program.'
+                  )}
+                </p>
+                <RainbowButton variant="border" onClick={openWalletDialog}>
+                  {t('Connect wallet')}
+                </RainbowButton>
+              </>
+            )}
+          </Box>
+        </div>
+      </LayoutWithGradient>
+    </ErrorBoundary>
+  );
+};
+
+const CreateTeamFormContainer = ({ isSolo }: { isSolo: boolean }) => {
+  const t = useT();
+  const createLink = useLinks(DApp.Governance);
+
+  const { err, status, code, isEligible, requiredStake, onSubmit } =
+    useReferralSetTransaction({
+      onSuccess: (code) => {
+        // For some reason team creation takes a long time, too long even to make
+        // polling viable, so its not feasible to navigate to the team page
+        // after creation
+        //
+        // navigate(Links.COMPETITIONS_TEAM(code));
+      },
+    });
+
+  if (status === 'confirmed') {
+    return (
+      <div className="flex flex-col items-start gap-2">
+        <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>
+            </p>
+            <TradingAnchorButton
+              href={Links.COMPETITIONS_TEAM(code)}
+              intent={Intent.Info}
+              size="small"
+            >
+              {t('View team')}
+            </TradingAnchorButton>
+          </>
+        )}
+      </div>
+    );
+  }
+
+  if (!isEligible) {
+    return (
+      <div className="flex flex-col gap-4">
+        {requiredStake !== undefined && (
+          <p>
+            {t(
+              'You need at least {{requiredStake}} VEGA staked to generate a referral code and participate in the referral program.',
+              {
+                requiredStake: addDecimalsFormatNumber(
+                  requiredStake.toString(),
+                  18
+                ),
+              }
+            )}
+          </p>
+        )}
+        <TradingAnchorButton
+          href={createLink(TokenStaticLinks.ASSOCIATE)}
+          intent={Intent.Primary}
+          target="_blank"
+        >
+          {t('Stake some $VEGA now')}
+        </TradingAnchorButton>
+      </div>
+    );
+  }
+
+  return (
+    <TeamForm
+      type={TransactionType.CreateReferralSet}
+      onSubmit={onSubmit}
+      status={status}
+      err={err}
+      isSolo={isSolo}
+    />
+  );
+};

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

@@ -0,0 +1,133 @@
+import { useT } from '../../lib/use-t';
+import { ErrorBoundary } from '@sentry/react';
+import { CompetitionsHeader } from '../../components/competitions/competitions-header';
+import { Intent, Loader, TradingButton } from '@vegaprotocol/ui-toolkit';
+
+import { useGames } from '../../lib/hooks/use-games';
+import { useCurrentEpochInfoQuery } from '../referrals/hooks/__generated__/Epoch';
+import { Link, useNavigate } from 'react-router-dom';
+import { Links } from '../../lib/links';
+import {
+  CompetitionsAction,
+  CompetitionsActionsContainer,
+} from '../../components/competitions/competitions-cta';
+import { GamesContainer } from '../../components/competitions/games-container';
+import { CompetitionsLeaderboard } from '../../components/competitions/competitions-leaderboard';
+import { useTeams } from '../../lib/hooks/use-teams';
+import take from 'lodash/take';
+import { usePageTitle } from '../../lib/hooks/use-page-title';
+
+export const CompetitionsHome = () => {
+  const t = useT();
+  const navigate = useNavigate();
+
+  usePageTitle(t('Competitions'));
+
+  const { data: epochData } = useCurrentEpochInfoQuery();
+  const currentEpoch = Number(epochData?.epoch.id);
+
+  const { data: gamesData, loading: gamesLoading } = useGames({
+    onlyActive: true,
+    currentEpoch,
+  });
+
+  const { data: teamsData, loading: teamsLoading } = useTeams({
+    sortByField: ['totalQuantumRewards'],
+    order: 'desc',
+  });
+
+  return (
+    <ErrorBoundary>
+      <CompetitionsHeader title={t('Competitions')}>
+        <p className="text-lg mb-1">
+          {t(
+            'Be a team player! Participate in games and work together to rake in as much profit to win.'
+          )}
+        </p>
+      </CompetitionsHeader>
+
+      {/** 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>
+
+      {/** List of available games */}
+      <h2 className="text-2xl mb-6">{t('Games')}</h2>
+
+      {gamesLoading ? (
+        <Loader size="small" />
+      ) : (
+        <GamesContainer data={gamesData} currentEpoch={currentEpoch} />
+      )}
+
+      {/** The teams ranking */}
+      <div className="mb-6 flex flex-row items-baseline justify-between">
+        <h2 className="text-2xl">{t('Leaderboard')}</h2>
+        <Link to={Links.COMPETITIONS_TEAMS()} className="text-sm underline">
+          {t('View all teams')}
+        </Link>
+      </div>
+
+      {teamsLoading ? (
+        <Loader size="small" />
+      ) : (
+        <CompetitionsLeaderboard data={take(teamsData, 10)} />
+      )}
+    </ErrorBoundary>
+  );
+};

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

@@ -0,0 +1,238 @@
+import { useState, type ButtonHTMLAttributes } from 'react';
+import { Link, useParams } from 'react-router-dom';
+import orderBy from 'lodash/orderBy';
+import { Splash, truncateMiddle, Loader } from '@vegaprotocol/ui-toolkit';
+import { DispatchMetricLabels, type DispatchMetric } from '@vegaprotocol/types';
+import classNames from 'classnames';
+import { useT } from '../../lib/use-t';
+import { Table } from '../../components/table';
+import { formatNumber, getDateTimeFormat } from '@vegaprotocol/utils';
+import {
+  useTeam,
+  type TeamStats as ITeamStats,
+  type Team as TeamType,
+  type Member,
+  type TeamGame,
+} from '../../lib/hooks/use-team';
+import { DApp, EXPLORER_PARTIES, useLinks } from '@vegaprotocol/environment';
+import { TeamAvatar } from '../../components/competitions/team-avatar';
+import { TeamStats } from '../../components/competitions/team-stats';
+import { usePageTitle } from '../../lib/hooks/use-page-title';
+import { ErrorBoundary } from '../../components/error-boundary';
+import { LayoutWithGradient } from '../../components/layouts-inner';
+import { useVegaWallet } from '@vegaprotocol/wallet';
+import { JoinTeam } from './join-team';
+import { UpdateTeamButton } from './update-team-button';
+
+export const CompetitionsTeam = () => {
+  const t = useT();
+  const { teamId } = useParams<{ teamId: string }>();
+  usePageTitle([t('Competitions'), t('Team')]);
+  return (
+    <ErrorBoundary feature="team">
+      <TeamPageContainer teamId={teamId} />
+    </ErrorBoundary>
+  );
+};
+
+const TeamPageContainer = ({ teamId }: { teamId: string | undefined }) => {
+  const t = useT();
+  const { pubKey } = useVegaWallet();
+  const { team, partyTeam, stats, members, games, loading, refetch } = useTeam(
+    teamId,
+    pubKey || undefined
+  );
+
+  if (loading) {
+    return (
+      <Splash>
+        <Loader />
+      </Splash>
+    );
+  }
+
+  if (!team) {
+    return (
+      <Splash>
+        <p>{t('Page not found')}</p>
+      </Splash>
+    );
+  }
+
+  return (
+    <TeamPage
+      team={team}
+      partyTeam={partyTeam}
+      stats={stats}
+      members={members}
+      games={games}
+      refetch={refetch}
+    />
+  );
+};
+
+const TeamPage = ({
+  team,
+  partyTeam,
+  stats,
+  members,
+  games,
+  refetch,
+}: {
+  team: TeamType;
+  partyTeam?: TeamType;
+  stats?: ITeamStats;
+  members?: Member[];
+  games?: TeamGame[];
+  refetch: () => void;
+}) => {
+  const t = useT();
+  const [showGames, setShowGames] = useState(true);
+
+  return (
+    <LayoutWithGradient>
+      <header className="flex gap-3 lg:gap-4 pt-5 lg:pt-10">
+        <TeamAvatar teamId={team.teamId} imgUrl={team.avatarUrl} />
+        <div className="flex flex-col items-start gap-1 lg:gap-3">
+          <h1
+            className="calt text-2xl lg:text-3xl xl:text-5xl"
+            data-testid="team-name"
+          >
+            {team.name}
+          </h1>
+          <JoinTeam team={team} partyTeam={partyTeam} refetch={refetch} />
+          <UpdateTeamButton team={team} />
+        </div>
+      </header>
+      <TeamStats stats={stats} members={members} games={games} />
+      <section>
+        <div className="flex gap-4 lg:gap-8 mb-4 border-b border-default">
+          <ToggleButton
+            active={showGames}
+            onClick={() => setShowGames(true)}
+            data-testid="games-toggle"
+          >
+            {t('Games ({{count}})', { count: games ? games.length : 0 })}
+          </ToggleButton>
+          <ToggleButton
+            active={!showGames}
+            onClick={() => setShowGames(false)}
+            data-testid="members-toggle"
+          >
+            {t('Members ({{count}})', {
+              count: members ? members.length : 0,
+            })}
+          </ToggleButton>
+        </div>
+        {showGames ? <Games games={games} /> : <Members members={members} />}
+      </section>
+    </LayoutWithGradient>
+  );
+};
+
+const Games = ({ games }: { games?: TeamGame[] }) => {
+  const t = useT();
+
+  if (!games?.length) {
+    return <p>{t('No games')}</p>;
+  }
+
+  return (
+    <Table
+      columns={[
+        { name: 'rank', displayName: t('Rank') },
+        {
+          name: 'epoch',
+          displayName: t('Epoch'),
+          headerClassName: 'hidden md:table-cell',
+          className: 'hidden md:table-cell',
+        },
+        { name: 'type', displayName: t('Type') },
+        { name: 'amount', displayName: t('Amount earned') },
+        {
+          name: 'participatingTeams',
+          displayName: t('No. of participating teams'),
+          headerClassName: 'hidden md:table-cell',
+          className: 'hidden md:table-cell',
+        },
+        {
+          name: 'participatingMembers',
+          displayName: t('No. of participating members'),
+          headerClassName: 'hidden md:table-cell',
+          className: 'hidden md:table-cell',
+        },
+      ]}
+      data={games.map((game) => ({
+        rank: game.team.rank,
+        epoch: game.epoch,
+        type: DispatchMetricLabels[game.team.rewardMetric as DispatchMetric],
+        amount: formatNumber(game.team.totalRewardsEarned),
+        participatingTeams: game.entities.length,
+        participatingMembers: game.numberOfParticipants,
+      }))}
+      noCollapse={true}
+    />
+  );
+};
+
+const Members = ({ members }: { members?: Member[] }) => {
+  const t = useT();
+
+  if (!members?.length) {
+    return <p>{t('No members')}</p>;
+  }
+
+  const data = orderBy(
+    members.map((m) => ({
+      referee: <RefereeLink pubkey={m.referee} />,
+      joinedAt: getDateTimeFormat().format(new Date(m.joinedAt)),
+      joinedAtEpoch: Number(m.joinedAtEpoch),
+    })),
+    'joinedAtEpoch',
+    'desc'
+  );
+
+  return (
+    <Table
+      columns={[
+        { name: 'referee', displayName: t('Referee') },
+        {
+          name: 'joinedAt',
+          displayName: t('Joined at'),
+        },
+        {
+          name: 'joinedAtEpoch',
+          displayName: t('Joined epoch'),
+        },
+      ]}
+      data={data}
+      noCollapse={true}
+    />
+  );
+};
+
+const RefereeLink = ({ pubkey }: { pubkey: string }) => {
+  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>
+  );
+};
+
+const ToggleButton = ({
+  active,
+  ...props
+}: ButtonHTMLAttributes<HTMLButtonElement> & { active: boolean }) => {
+  return (
+    <button
+      {...props}
+      className={classNames('relative top-px uppercase border-b-2 py-4', {
+        'text-muted border-transparent': !active,
+        'border-vega-yellow': active,
+      })}
+    />
+  );
+};

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

@@ -0,0 +1,67 @@
+import { ErrorBoundary } from '@sentry/react';
+import { CompetitionsHeader } from '../../components/competitions/competitions-header';
+import { useRef, useState } from 'react';
+import { useT } from '../../lib/use-t';
+import { useTeams } from '../../lib/hooks/use-teams';
+import { CompetitionsLeaderboard } from '../../components/competitions/competitions-leaderboard';
+import {
+  Input,
+  Loader,
+  VegaIcon,
+  VegaIconNames,
+} from '@vegaprotocol/ui-toolkit';
+import { usePageTitle } from '../../lib/hooks/use-page-title';
+
+export const CompetitionsTeams = () => {
+  const t = useT();
+
+  usePageTitle([t('Competitions'), t('Teams')]);
+
+  const { data: teamsData, loading: teamsLoading } = useTeams({
+    sortByField: ['totalQuantumRewards'],
+    order: 'desc',
+  });
+
+  const inputRef = useRef<HTMLInputElement>(null);
+  const [filter, setFilter] = useState<string | null | undefined>(undefined);
+
+  return (
+    <ErrorBoundary>
+      <CompetitionsHeader title={t('Join a team')}>
+        <p className="text-lg mb-1">{t('Choose a team to get involved')}</p>
+      </CompetitionsHeader>
+
+      <div className="mb-6 flex justify-end">
+        <div className="w-full md:w-60 h-10 relative">
+          <span className="absolute z-10 pointer-events-none opacity-90 top-[5px] left-[5px]">
+            <VegaIcon name={VegaIconNames.SEARCH} size={18} />
+          </span>
+          <Input
+            ref={inputRef}
+            className="opacity-90 text-right"
+            placeholder={t('Name')}
+            onKeyUp={() => {
+              const value = inputRef.current?.value;
+              if (value != filter) setFilter(value);
+            }}
+          />
+        </div>
+      </div>
+      <div>
+        {teamsLoading ? (
+          <Loader size="small" />
+        ) : (
+          <CompetitionsLeaderboard
+            data={teamsData.filter((td) => {
+              if (filter && filter.length > 0) {
+                const re = new RegExp(filter, 'i');
+                return re.test(td.name);
+              }
+              return true;
+            })}
+          />
+        )}
+      </div>
+    </ErrorBoundary>
+  );
+};

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

@@ -0,0 +1,106 @@
+import { ErrorBoundary } from '../../components/error-boundary';
+import { usePageTitle } from '../../lib/hooks/use-page-title';
+import { Box } from '../../components/competitions/box';
+import { useT } from '../../lib/use-t';
+import { useVegaWallet, useVegaWalletDialogStore } from '@vegaprotocol/wallet';
+import { Loader, Splash } from '@vegaprotocol/ui-toolkit';
+import { RainbowButton } from '../../components/rainbow-button';
+import { Link, Navigate, useParams } from 'react-router-dom';
+import { Links } from '../../lib/links';
+import { useReferralSetTransaction } from '../../lib/hooks/use-referral-set-transaction';
+import { type FormFields, TeamForm, TransactionType } from './team-form';
+import { useTeam } from '../../lib/hooks/use-team';
+import { LayoutWithGradient } from '../../components/layouts-inner';
+
+export const CompetitionsUpdateTeam = () => {
+  const t = useT();
+  usePageTitle([t('Competitions'), t('Update a team')]);
+  const { pubKey, isReadOnly } = useVegaWallet();
+  const openWalletDialog = useVegaWalletDialogStore(
+    (store) => store.openVegaWalletDialog
+  );
+  const { teamId } = useParams<{ teamId: string }>();
+  if (!teamId) {
+    return <Navigate to={Links.COMPETITIONS()} />;
+  }
+
+  return (
+    <ErrorBoundary feature="update-team">
+      <LayoutWithGradient>
+        <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-5xl">
+              {t('Update a team')}
+            </h1>
+            {pubKey && !isReadOnly ? (
+              <UpdateTeamFormContainer teamId={teamId} pubKey={pubKey} />
+            ) : (
+              <>
+                <p>{t('Connect to update the details of your team.')}</p>
+                <RainbowButton variant="border" onClick={openWalletDialog}>
+                  {t('Connect wallet')}
+                </RainbowButton>
+              </>
+            )}
+          </Box>
+        </div>
+      </LayoutWithGradient>
+    </ErrorBoundary>
+  );
+};
+
+const UpdateTeamFormContainer = ({
+  teamId,
+  pubKey,
+}: {
+  teamId: string;
+  pubKey: string;
+}) => {
+  const t = useT();
+  const { team, loading, error } = useTeam(teamId, pubKey);
+
+  const { err, status, onSubmit } = useReferralSetTransaction({
+    onSuccess: () => {
+      // NOOP
+    },
+  });
+
+  if (loading) {
+    return <Loader size="small" />;
+  }
+  if (error) {
+    return (
+      <Splash className="gap-1">
+        <span>{t('Something went wrong.')}</span>
+        <Link to={Links.COMPETITIONS_TEAM(teamId)} className="underline">
+          {t("Go back to the team's profile")}
+        </Link>
+      </Splash>
+    );
+  }
+
+  const isMyTeam = team?.referrer === pubKey;
+  if (!isMyTeam) {
+    return <Navigate to={Links.COMPETITIONS_TEAM(teamId)} />;
+  }
+
+  const defaultValues: FormFields = {
+    id: team.teamId,
+    name: team.name,
+    url: team.teamUrl,
+    avatarUrl: team.avatarUrl,
+    private: team.closed,
+    allowList: team.allowList.join(','),
+  };
+
+  return (
+    <TeamForm
+      type={TransactionType.UpdateReferralSet}
+      status={status}
+      err={err}
+      isSolo={team.closed}
+      onSubmit={onSubmit}
+      defaultValues={defaultValues}
+    />
+  );
+};

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

@@ -0,0 +1,88 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { JoinButton } from './join-team';
+import { type Team } from '../../lib/hooks/use-team';
+
+describe('JoinButton', () => {
+  const teamA = {
+    teamId: 'teamA',
+    name: 'Team A',
+    referrer: 'referrerA',
+  } as Team;
+
+  const teamB = {
+    teamId: 'teamB',
+    name: 'Team B',
+    referrer: 'referrerrB',
+  } as Team;
+
+  const props = {
+    pubKey: 'pubkey',
+    isReadOnly: false,
+    team: teamA,
+    partyTeam: teamB,
+    onJoin: jest.fn(),
+  };
+
+  beforeEach(() => {
+    props.onJoin.mockClear();
+  });
+
+  it('disables button if not connected', async () => {
+    render(<JoinButton {...props} pubKey={null} />);
+    const button = screen.getByRole('button');
+    expect(button).toBeDisabled();
+    await userEvent.hover(button);
+    const tooltip = await screen.findByRole('tooltip');
+    expect(tooltip).toHaveTextContent(/Connect your wallet/);
+  });
+
+  it('disables button if you created the current team', () => {
+    render(
+      <JoinButton
+        {...props}
+        pubKey={teamA.referrer}
+        team={teamA}
+        partyTeam={teamA}
+      />
+    );
+
+    const button = screen.getByRole('button', { name: /Owner/ });
+    expect(button).toBeDisabled();
+  });
+
+  it('disables button if you created a team', async () => {
+    render(<JoinButton {...props} pubKey={teamB.referrer} />);
+
+    const button = screen.getByRole('button', { name: /Switch team/ });
+    expect(button).toBeDisabled();
+    await userEvent.hover(button);
+    const tooltip = await screen.findByRole('tooltip');
+    expect(tooltip).toHaveTextContent(/As a team creator/);
+  });
+
+  it('shows if party is already in team', async () => {
+    render(<JoinButton {...props} team={teamA} partyTeam={teamA} />);
+
+    const button = screen.getByRole('button', { name: /Joined/ });
+    expect(button).toBeDisabled();
+  });
+
+  it('enables switch team if party is in a different team', async () => {
+    render(<JoinButton {...props} />);
+
+    const button = screen.getByRole('button', { name: /Switch team/ });
+    expect(button).toBeEnabled();
+    await userEvent.click(button);
+    expect(props.onJoin).toHaveBeenCalledWith('switch');
+  });
+
+  it('enables join team if party is not in a team', async () => {
+    render(<JoinButton {...props} partyTeam={undefined} />);
+
+    const button = screen.getByRole('button', { name: /Join team/ });
+    expect(button).toBeEnabled();
+    await userEvent.click(button);
+    expect(props.onJoin).toHaveBeenCalledWith('join');
+  });
+});

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

@@ -0,0 +1,225 @@
+import {
+  TradingButton as Button,
+  Dialog,
+  Intent,
+  Tooltip,
+  VegaIcon,
+  VegaIconNames,
+} from '@vegaprotocol/ui-toolkit';
+import {
+  useSimpleTransaction,
+  useVegaWallet,
+  type Status,
+} from '@vegaprotocol/wallet';
+import { useT } from '../../lib/use-t';
+import { type Team } from '../../lib/hooks/use-team';
+import { useState } from 'react';
+
+type JoinType = 'switch' | 'join';
+
+export const JoinTeam = ({
+  team,
+  partyTeam,
+  refetch,
+}: {
+  team: Team;
+  partyTeam?: Team;
+  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
+        team={team}
+        partyTeam={partyTeam}
+        pubKey={pubKey}
+        isReadOnly={isReadOnly}
+        onJoin={setConfirmDialog}
+      />
+      <Dialog
+        open={confirmDialog !== undefined}
+        onChange={() => setConfirmDialog(undefined)}
+      >
+        {confirmDialog !== undefined && (
+          <DialogContent
+            type={confirmDialog}
+            status={status}
+            team={team}
+            partyTeam={partyTeam}
+            onConfirm={joinTeam}
+            onCancel={() => setConfirmDialog(undefined)}
+          />
+        )}
+      </Dialog>
+    </>
+  );
+};
+
+export const JoinButton = ({
+  pubKey,
+  isReadOnly,
+  team,
+  partyTeam,
+  onJoin,
+}: {
+  pubKey: string | null;
+  isReadOnly: boolean;
+  team: Team;
+  partyTeam?: Team;
+  onJoin: (type: JoinType) => void;
+}) => {
+  const t = useT();
+
+  if (!pubKey || isReadOnly) {
+    return (
+      <Tooltip description={t('Connect your wallet to join the team')}>
+        <Button intent={Intent.Primary} disabled={true}>
+          {t('Join team')}{' '}
+        </Button>
+      </Tooltip>
+    );
+  }
+  // Party is the creator of a team
+  else if (partyTeam && partyTeam.referrer === pubKey) {
+    // Party is the creator of THIS team
+    if (partyTeam.teamId === team.teamId) {
+      return (
+        <Button intent={Intent.None} disabled={true}>
+          <span className="flex items-center gap-2">
+            {t('Owner')}{' '}
+            <span className="text-vega-green-600 dark:text-vega-green">
+              <VegaIcon name={VegaIconNames.TICK} />
+            </span>
+          </span>
+        </Button>
+      );
+    } else {
+      // 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">
+          <Button intent={Intent.Primary} disabled={true}>
+            {t('Switch team')}{' '}
+          </Button>
+        </Tooltip>
+      );
+    }
+  }
+  // Party is in a team, but not this one
+  else if (partyTeam && partyTeam.teamId !== team.teamId) {
+    return (
+      <Button onClick={() => onJoin('switch')} intent={Intent.Primary}>
+        {t('Switch team')}{' '}
+      </Button>
+    );
+  }
+  // Joined. Current party is already in this team
+  else if (partyTeam && partyTeam.teamId === team.teamId) {
+    return (
+      <Button intent={Intent.None} disabled={true}>
+        <span className="flex items-center gap-2">
+          {t('Joined')}{' '}
+          <span className="text-vega-green-600 dark:text-vega-green">
+            <VegaIcon name={VegaIconNames.TICK} />
+          </span>
+        </span>
+      </Button>
+    );
+  }
+
+  return (
+    <Button onClick={() => onJoin('join')} intent={Intent.Primary}>
+      {t('Join team')}
+    </Button>
+  );
+};
+
+const DialogContent = ({
+  type,
+  status,
+  team,
+  partyTeam,
+  onConfirm,
+  onCancel,
+}: {
+  type: JoinType;
+  status: Status;
+  team: Team;
+  partyTeam?: Team;
+  onConfirm: () => void;
+  onCancel: () => void;
+}) => {
+  const t = useT();
+
+  if (status === 'requested') {
+    return <p>{t('Confirm in wallet...')}</p>;
+  }
+
+  if (status === 'pending') {
+    return <p>{t('Confirming transaction...')}</p>;
+  }
+
+  if (status === 'confirmed') {
+    if (type === 'switch') {
+      return (
+        <p>
+          {t(
+            'Team switch successful. You will switch team at the end of the epoch.'
+          )}
+        </p>
+      );
+    }
+
+    return <p>{t('Team joined')}</p>;
+  }
+
+  return (
+    <div className="flex flex-col gap-4">
+      {type === 'switch' && (
+        <>
+          <h2 className="font-alpha text-xl">{t('Switch team')}</h2>
+          <p>
+            {t(
+              "Switching team will move you from '{{fromTeam}}' to '{{toTeam}}' at the end of the epoch. Are you sure?",
+              {
+                fromTeam: partyTeam?.name,
+                toTeam: team.name,
+              }
+            )}
+          </p>
+        </>
+      )}
+      {type === 'join' && (
+        <>
+          <h2 className="font-alpha text-xl">{t('Join team')}</h2>
+          <p>
+            {t('Are you sure you want to join team: {{team}}', {
+              team: team.name,
+            })}
+          </p>
+        </>
+      )}
+      <div className="flex justify-between gap-2">
+        <Button onClick={onConfirm} intent={Intent.Success}>
+          {t('Confirm')}
+        </Button>
+        <Button onClick={onCancel} intent={Intent.Danger}>
+          {t('Cancel')}
+        </Button>
+      </div>
+    </div>
+  );
+};

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

@@ -0,0 +1,254 @@
+import {
+  TradingFormGroup,
+  TradingInput,
+  TradingInputError,
+  TradingCheckbox,
+  TextArea,
+  TradingButton,
+  Intent,
+} from '@vegaprotocol/ui-toolkit';
+import { URL_REGEX, isValidVegaPublicKey } from '@vegaprotocol/utils';
+
+import { type useReferralSetTransaction } from '../../lib/hooks/use-referral-set-transaction';
+import { useT } from '../../lib/use-t';
+import { useForm, Controller } from 'react-hook-form';
+import type {
+  CreateReferralSet,
+  UpdateReferralSet,
+  Status,
+} from '@vegaprotocol/wallet';
+
+export type FormFields = {
+  id: string;
+  name: string;
+  url: string;
+  avatarUrl: string;
+  private: boolean;
+  allowList: string;
+};
+
+export enum TransactionType {
+  CreateReferralSet,
+  UpdateReferralSet,
+}
+
+const prepareTransaction = (
+  type: TransactionType,
+  fields: FormFields
+): CreateReferralSet | UpdateReferralSet => {
+  switch (type) {
+    case TransactionType.CreateReferralSet:
+      return {
+        createReferralSet: {
+          isTeam: true,
+          team: {
+            name: fields.name,
+            teamUrl: fields.url,
+            avatarUrl: fields.avatarUrl,
+            closed: fields.private,
+            allowList: fields.private
+              ? parseAllowListText(fields.allowList)
+              : [],
+          },
+        },
+      };
+    case TransactionType.UpdateReferralSet:
+      return {
+        updateReferralSet: {
+          id: fields.id,
+          isTeam: true,
+          team: {
+            name: fields.name,
+            teamUrl: fields.url,
+            avatarUrl: fields.avatarUrl,
+            closed: fields.private,
+            allowList: fields.private
+              ? parseAllowListText(fields.allowList)
+              : [],
+          },
+        },
+      };
+  }
+};
+
+export const TeamForm = ({
+  type,
+  status,
+  err,
+  isSolo,
+  onSubmit,
+  defaultValues,
+}: {
+  type: TransactionType;
+  status: ReturnType<typeof useReferralSetTransaction>['status'];
+  err: ReturnType<typeof useReferralSetTransaction>['err'];
+  isSolo: boolean;
+  onSubmit: ReturnType<typeof useReferralSetTransaction>['onSubmit'];
+  defaultValues?: FormFields;
+}) => {
+  const t = useT();
+
+  const {
+    register,
+    handleSubmit,
+    control,
+    watch,
+    formState: { errors },
+  } = useForm<FormFields>({
+    defaultValues: {
+      private: isSolo,
+      ...defaultValues,
+    },
+  });
+
+  const isPrivate = watch('private');
+
+  const sendTransaction = (fields: FormFields) => {
+    onSubmit(prepareTransaction(type, fields));
+  };
+
+  return (
+    <form onSubmit={handleSubmit(sendTransaction)}>
+      <input
+        type="hidden"
+        {...register('id', {
+          disabled: true,
+        })}
+      />
+      <TradingFormGroup label={t('Team name')} labelFor="name">
+        <TradingInput {...register('name', { required: t('Required') })} />
+        {errors.name?.message && (
+          <TradingInputError forInput="name">
+            {errors.name.message}
+          </TradingInputError>
+        )}
+      </TradingFormGroup>
+      <TradingFormGroup
+        label={t('URL')}
+        labelFor="url"
+        labelDescription={t(
+          'Provide a link so users can learn more about your team'
+        )}
+      >
+        <TradingInput
+          {...register('url', {
+            pattern: { value: URL_REGEX, message: t('Invalid URL') },
+          })}
+        />
+        {errors.url?.message && (
+          <TradingInputError forInput="url">
+            {errors.url.message}
+          </TradingInputError>
+        )}
+      </TradingFormGroup>
+      <TradingFormGroup
+        label={t('Avatar URL')}
+        labelFor="avatarUrl"
+        labelDescription={t('Provide a URL to a hosted image')}
+      >
+        <TradingInput
+          {...register('avatarUrl', {
+            pattern: {
+              value: URL_REGEX,
+              message: t('Invalid image URL'),
+            },
+          })}
+        />
+        {errors.avatarUrl?.message && (
+          <TradingInputError forInput="avatarUrl">
+            {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);
+                }}
+                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>
+      )}
+      {err && <p className="text-danger text-xs mb-4 capitalize">{err}</p>}
+      <SubmitButton type={type} status={status} />
+    </form>
+  );
+};
+
+const SubmitButton = ({
+  type,
+  status,
+}: {
+  type?: TransactionType;
+  status: Status;
+}) => {
+  const t = useT();
+  const disabled = status === 'pending' || status === 'requested';
+
+  let text = t('Create');
+  if (type === TransactionType.UpdateReferralSet) {
+    text = t('Update');
+  }
+
+  if (status === 'requested') {
+    text = t('Confirm in wallet...');
+  } else if (status === 'pending') {
+    text = t('Confirming transaction...');
+  }
+
+  return (
+    <TradingButton type="submit" intent={Intent.Info} disabled={disabled}>
+      {text}
+    </TradingButton>
+  );
+};
+
+const parseAllowListText = (str: string) => {
+  return str
+    .split(',')
+    .map((v) => v.trim())
+    .filter(Boolean);
+};

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

@@ -0,0 +1,20 @@
+import { useVegaWallet } from '@vegaprotocol/wallet';
+import { type Team } from '../../lib/hooks/use-team';
+import { Intent, TradingAnchorButton } from '@vegaprotocol/ui-toolkit';
+import { Links } from '../../lib/links';
+
+export const UpdateTeamButton = ({ team }: { team: Team }) => {
+  const { pubKey, isReadOnly } = useVegaWallet();
+
+  if (pubKey && !isReadOnly && pubKey === team.referrer) {
+    return (
+      <TradingAnchorButton
+        data-testid="update-team-button"
+        href={Links.COMPETITIONS_UPDATE_TEAM(team.teamId)}
+        intent={Intent.Info}
+      />
+    );
+  }
+
+  return null;
+};

apps/trading/client-pages/markets/closed.spec.tsx

@@ -314,7 +314,7 @@ describe('Closed', () => {
   });
 
   it('display market actions', async () => {
-    // Use market with a succcessor Id as the actions dropdown will optionally
+    // Use market with a successor Id as the actions dropdown will optionally
     // show a link to the successor market
     const marketsWithSuccessorAndParent = [
       {

apps/trading/client-pages/markets/closed.tsx

@@ -137,6 +137,8 @@ const ClosedMarketsDataGrid = ({
         headerName: t('Market'),
         field: 'code',
         cellRenderer: 'MarketCodeCell',
+        width: 150,
+        resizable: true,
       },
       {
         headerName: t('Status'),
@@ -280,6 +282,7 @@ const ClosedMarketsDataGrid = ({
   return (
     <AgGrid
       rowData={rowData}
+      defaultColDef={COL_DEFS.default}
       columnDefs={colDefs}
       getRowId={({ data }) => data.id}
       overlayNoRowsTemplate={error ? error.message : t('No markets')}

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

@@ -17,6 +17,7 @@ const defaultColDef = {
   filter: true,
   resizable: true,
   filterParams: { buttons: ['reset'] },
+  minWidth: 120,
 };
 
 const components = {

apps/trading/client-pages/markets/markets-page.tsx

@@ -53,6 +53,7 @@ export const MarketsPage = () => {
                 size="extra-small"
                 data-testid="propose-new-market"
                 href={externalLink}
+                target="_blank"
               >
                 {t('Propose a new market')}
               </TradingAnchorButton>

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

@@ -29,6 +29,7 @@ export const useColumnDefs = () => {
       {
         headerName: t('Market'),
         field: 'tradableInstrument.instrument.code',
+        pinned: true,
         cellRenderer: ({
           value,
           data,

apps/trading/client-pages/referrals/apply-code-form.tsx

@@ -5,17 +5,19 @@ import {
   VegaIcon,
   VegaIconNames,
 } from '@vegaprotocol/ui-toolkit';
-import type { FieldValues } from 'react-hook-form';
 import { useForm } from 'react-hook-form';
 import classNames from 'classnames';
 import { Navigate, useNavigate, useSearchParams } from 'react-router-dom';
 import type { ButtonHTMLAttributes, MouseEventHandler } from 'react';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { RainbowButton } from './buttons';
-import { useVegaWallet, useVegaWalletDialogStore } from '@vegaprotocol/wallet';
+import { useCallback } from 'react';
+import { RainbowButton } from '../../components/rainbow-button';
+import {
+  useSimpleTransaction,
+  useVegaWallet,
+  useVegaWalletDialogStore,
+} from '@vegaprotocol/wallet';
 import { useIsInReferralSet, useReferral } from './hooks/use-referral';
 import { Routes } from '../../lib/links';
-import { useTransactionEventSubscription } from '@vegaprotocol/web3';
 import { Statistics, useStats } from './referral-statistics';
 import { useReferralProgram } from './hooks/use-referral-program';
 import { ns, useT } from '../../lib/use-t';
@@ -73,6 +75,10 @@ export const ApplyCodeFormContainer = ({
   return <ApplyCodeForm onSuccess={onSuccess} />;
 };
 
+type FormFields = {
+  code: string;
+};
+
 export const ApplyCodeForm = ({ onSuccess }: { onSuccess?: () => void }) => {
   const t = useT();
   const program = useReferralProgram();
@@ -81,31 +87,47 @@ export const ApplyCodeForm = ({ onSuccess }: { onSuccess?: () => void }) => {
     (store) => store.openVegaWalletDialog
   );
 
-  const [status, setStatus] = useState<
-    'requested' | 'no-funds' | 'successful' | null
-  >(null);
-  const txHash = useRef<string | null>(null);
-  const { isReadOnly, pubKey, sendTx } = useVegaWallet();
+  const { isReadOnly, pubKey } = useVegaWallet();
   const { isEligible, requiredFunds } = useFundsAvailable();
 
   const currentRouteId = useGetCurrentRouteId();
   const setViews = useSidebar((s) => s.setViews);
 
+  const [params] = useSearchParams();
   const {
     register,
     handleSubmit,
     formState: { errors },
-    setValue,
     setError,
     watch,
-  } = useForm();
-  const [params] = useSearchParams();
+  } = useForm<FormFields>({
+    defaultValues: {
+      code: params.get('code') || '',
+    },
+  });
 
   const codeField = watch('code');
+
   const { data: previewData, loading: previewLoading } = useReferral({
     code: validateCode(codeField, t) ? codeField : undefined,
   });
 
+  const { send, status } = useSimpleTransaction({
+    onSuccess: () => {
+      // go to main page when successfully applied
+      setTimeout(() => {
+        if (onSuccess) onSuccess();
+        navigate(Routes.REFERRALS);
+      }, RELOAD_DELAY);
+    },
+    onError: (msg) => {
+      setError('code', {
+        type: 'required',
+        message: msg,
+      });
+    },
+  });
+
   /**
    * Validates if a connected party can apply a code (min funds span protection)
    */
@@ -135,99 +157,55 @@ export const ApplyCodeForm = ({ onSuccess }: { onSuccess?: () => void }) => {
     return true;
   }, [codeField, previewData, previewLoading, t]);
 
-  useEffect(() => {
-    const code = params.get('code');
-    if (code) setValue('code', code);
-  }, [params, setValue]);
+  const noFunds = validateFundsAvailable() !== true ? true : false;
 
-  useEffect(() => {
-    const err = validateFundsAvailable();
-    if (err !== true) {
-      setStatus('no-funds');
-    } else {
-      setStatus(null);
-    }
-  }, [isEligible, validateFundsAvailable]);
-
-  const onSubmit = ({ code }: FieldValues) => {
+  const onSubmit = ({ code }: FormFields) => {
     if (isReadOnly || !pubKey || !code || code.length === 0) {
       return;
     }
 
-    setStatus('requested');
-
-    sendTx(pubKey, {
+    send({
       applyReferralCode: {
         id: code as string,
       },
-    })
-      .then((res) => {
-        if (!res) {
-          setError('code', {
-            type: 'required',
-            message: t('The transaction could not be sent'),
-          });
-        }
-        if (res) {
-          txHash.current = res.transactionHash.toLowerCase();
-        }
-      })
-      .catch((err) => {
-        if (err.message.includes('user rejected')) {
-          setStatus(null);
-        } else {
-          setStatus(null);
-          setError('code', {
-            type: 'required',
-            message:
-              err instanceof Error
-                ? err.message
-                : t('Your code has been rejected'),
-          });
-        }
-      });
-  };
+    });
 
-  useTransactionEventSubscription({
-    variables: { partyId: pubKey || '' },
-    skip: !pubKey,
-    fetchPolicy: 'no-cache',
-    onData: ({ data: result }) =>
-      result.data?.busEvents?.forEach((event) => {
-        if (event.event.__typename === 'TransactionResult') {
-          const hash = event.event.hash.toLowerCase();
-          if (txHash.current && txHash.current === hash) {
-            const err = event.event.error;
-            const status = event.event.status;
-            if (err) {
-              setStatus(null);
-              setError('code', {
-                type: 'required',
-                message: err,
-              });
-            }
-            if (status && !err) {
-              setStatus('successful');
-            }
-          }
-        }
-      }),
-  });
+    // sendTx(pubKey, {
+    //   applyReferralCode: {
+    //     id: code as string,
+    //   },
+    // })
+    //   .then((res) => {
+    //     if (!res) {
+    //       setError('code', {
+    //         type: 'required',
+    //         message: t('The transaction could not be sent'),
+    //       });
+    //     }
+    //     if (res) {
+    //       txHash.current = res.transactionHash.toLowerCase();
+    //     }
+    //   })
+    //   .catch((err) => {
+    //     if (err.message.includes('user rejected')) {
+    //       setStatus(null);
+    //     } else {
+    //       setStatus(null);
+    //       setError('code', {
+    //         type: 'required',
+    //         message:
+    //           err instanceof Error
+    //             ? err.message
+    //             : t('Your code has been rejected'),
+    //       });
+    //     }
+    //   });
+  };
 
   const { epochsValue, nextBenefitTierValue } = useStats({ program });
 
-  // go to main page when successfully applied
-  useEffect(() => {
-    if (status === 'successful') {
-      setTimeout(() => {
-        if (onSuccess) onSuccess();
-        navigate(Routes.REFERRALS);
-      }, RELOAD_DELAY);
-    }
-  }, [navigate, onSuccess, status]);
-
   // show "code applied" message when successfully applied
-  if (status === 'successful') {
+  if (status === 'confirmed') {
     return (
       <div className="mx-auto w-1/2">
         <h3 className="calt mb-5 flex flex-row items-center justify-center gap-2 text-center text-xl uppercase">
@@ -261,7 +239,7 @@ export const ApplyCodeForm = ({ onSuccess }: { onSuccess?: () => void }) => {
       };
     }
 
-    if (status === 'no-funds') {
+    if (noFunds) {
       return {
         disabled: false,
         children: t('Deposit funds'),
@@ -332,7 +310,7 @@ export const ApplyCodeForm = ({ onSuccess }: { onSuccess?: () => void }) => {
           </label>
           <RainbowButton variant="border" {...getButtonProps()} />
         </form>
-        {status === 'no-funds' ? (
+        {noFunds ? (
           <InputError intent="warning" className="overflow-auto break-words">
             <span>
               <SpamProtectionErr requiredFunds={requiredFunds?.toString()} />

apps/trading/client-pages/referrals/buttons.tsx

@@ -4,41 +4,6 @@ import type { ComponentProps, ButtonHTMLAttributes } from 'react';
 import { forwardRef } from 'react';
 import { NavLink } from 'react-router-dom';
 
-type RainbowButtonProps = {
-  variant?: 'full' | 'border';
-};
-
-export const RainbowButton = ({
-  variant = 'full',
-  children,
-  className,
-  ...props
-}: RainbowButtonProps & ButtonHTMLAttributes<HTMLButtonElement>) => (
-  <button
-    className={classNames(
-      'bg-rainbow rounded-lg overflow-hidden disabled:opacity-40',
-      'hover:bg-rainbow-180 hover:animate-spin-rainbow',
-      {
-        'px-5 py-3 text-white': variant === 'full',
-        'p-[0.125rem]': variant === 'border',
-      }
-    )}
-    {...props}
-  >
-    <div
-      className={classNames(
-        {
-          'bg-vega-clight-800 dark:bg-vega-cdark-800 text-black dark:text-white px-5 py-3 rounded-[0.35rem] overflow-hidden':
-            variant === 'border',
-        },
-        className
-      )}
-    >
-      {children}
-    </div>
-  </button>
-);
-
 const RAINBOW_TAB_STYLE = classNames(
   'inline-block',
   'bg-vega-clight-500 dark:bg-vega-cdark-500',

apps/trading/client-pages/referrals/constants.ts

@@ -2,9 +2,6 @@ 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 SKY_BACKGROUND =
-  'bg-[url(/sky-light.png)] dark:bg-[url(/sky-dark.png)] bg-[37%_0px] bg-[length:1440px] bg-no-repeat bg-local';
-
 // TODO: Update the links to use the correct referral related pages
 export const REFERRAL_DOCS_LINK =
   'https://docs.vega.xyz/mainnet/concepts/trading-on-vega/discounts-rewards#referral-program';

apps/trading/client-pages/referrals/create-code-form.tsx

@@ -1,9 +1,5 @@
-import {
-  useVegaWallet,
-  useVegaWalletDialogStore,
-  determineId,
-} from '@vegaprotocol/wallet';
-import { RainbowButton } from './buttons';
+import { useVegaWallet, useVegaWalletDialogStore } from '@vegaprotocol/wallet';
+import { RainbowButton } from '../../components/rainbow-button';
 import { useState } from 'react';
 import {
   CopyWithTooltip,
@@ -11,6 +7,7 @@ import {
   ExternalLink,
   InputError,
   Intent,
+  Tooltip,
   TradingAnchorButton,
   TradingButton,
   VegaIcon,
@@ -18,34 +15,28 @@ import {
 } from '@vegaprotocol/ui-toolkit';
 import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
 import { DApp, TokenStaticLinks, useLinks } from '@vegaprotocol/environment';
-import { useStakeAvailable } from './hooks/use-stake-available';
 import { ABOUT_REFERRAL_DOCS_LINK } from './constants';
 import { useIsInReferralSet, useReferral } from './hooks/use-referral';
 import { useT } from '../../lib/use-t';
-import { Navigate } from 'react-router-dom';
-import { Routes } from '../../lib/links';
+import { Link, Navigate, useNavigate } from 'react-router-dom';
+import { Links, Routes } from '../../lib/links';
 import { useReferralProgram } from './hooks/use-referral-program';
+import { useReferralSetTransaction } from '../../lib/hooks/use-referral-set-transaction';
+import { Trans } from 'react-i18next';
 
 export const CreateCodeContainer = () => {
-  const { pubKey } = useVegaWallet();
+  const t = useT();
+  const { pubKey, isReadOnly } = useVegaWallet();
   const isInReferralSet = useIsInReferralSet(pubKey);
+  const openWalletDialog = useVegaWalletDialogStore(
+    (store) => store.openVegaWalletDialog
+  );
 
   // Navigate to the index page when already in the referral set.
   if (isInReferralSet) {
     return <Navigate to={Routes.REFERRALS} />;
   }
 
-  return <CreateCodeForm />;
-};
-
-export const CreateCodeForm = () => {
-  const t = useT();
-  const [dialogOpen, setDialogOpen] = useState(false);
-  const openWalletDialog = useVegaWalletDialogStore(
-    (store) => store.openVegaWalletDialog
-  );
-  const { pubKey, isReadOnly } = useVegaWallet();
-
   return (
     <div
       data-testid="referral-create-code-form"
@@ -60,22 +51,82 @@ export const CreateCodeForm = () => {
         )}
       </p>
 
-      <div className="w-full flex flex-col">
-        <RainbowButton
-          variant="border"
-          disabled={isReadOnly}
-          onClick={() => {
-            if (pubKey) {
-              setDialogOpen(true);
-            } else {
-              openWalletDialog();
-            }
-          }}
-        >
-          {pubKey ? t('Create a referral code') : t('Connect wallet')}
-        </RainbowButton>
+      <div className="w-full flex flex-col gap-4 items-stretch">
+        {pubKey ? (
+          <CreateCodeForm />
+        ) : (
+          <RainbowButton
+            variant="border"
+            disabled={isReadOnly}
+            onClick={openWalletDialog}
+          >
+            {t('Connect wallet')}
+          </RainbowButton>
+        )}
       </div>
+    </div>
+  );
+};
 
+export const CreateCodeForm = () => {
+  const t = useT();
+  const navigate = useNavigate();
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const { isReadOnly } = useVegaWallet();
+
+  return (
+    <>
+      <Tooltip
+        description={t(
+          'Create a simple referral code to enjoy the referrer commission outlined in the current referral program'
+        )}
+      >
+        <span>
+          <RainbowButton
+            variant="border"
+            disabled={isReadOnly}
+            onClick={() => setDialogOpen(true)}
+            className="w-full"
+          >
+            {t('Create a referral code')}
+          </RainbowButton>
+        </span>
+      </Tooltip>
+      <Tooltip
+        description={
+          <Trans
+            i18nKey={
+              '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'
+            }
+            components={[
+              <Link
+                key="homepage-link"
+                to={Links.COMPETITIONS()}
+                className="underline"
+              >
+                Compeitionts Homepage
+              </Link>,
+            ]}
+          />
+        }
+      >
+        <span>
+          <RainbowButton
+            role="link"
+            variant="border"
+            disabled={isReadOnly}
+            onClick={() => navigate(Links.COMPETITIONS_CREATE_TEAM())}
+            className="w-full"
+          >
+            {t('Create a team')}
+          </RainbowButton>
+        </span>
+      </Tooltip>
+      <p className="text-xs">
+        <Link className="underline" to={Links.COMPETITIONS()}>
+          {t('Go to competitions')}
+        </Link>
+      </p>
       <Dialog
         title={t('Create a referral code')}
         open={dialogOpen}
@@ -84,7 +135,7 @@ export const CreateCodeForm = () => {
       >
         <CreateCodeDialog setDialogOpen={setDialogOpen} />
       </Dialog>
-    </div>
+    </>
   );
 };
 
@@ -95,67 +146,42 @@ const CreateCodeDialog = ({
 }) => {
   const t = useT();
   const createLink = useLinks(DApp.Governance);
-  const { isReadOnly, pubKey, sendTx } = useVegaWallet();
+  const { pubKey } = useVegaWallet();
   const { refetch } = useReferral({ pubKey, role: 'referrer' });
-  const [err, setErr] = useState<string | null>(null);
-  const [code, setCode] = useState<string | null>(null);
-  const [status, setStatus] = useState<
-    'idle' | 'loading' | 'success' | 'error'
-  >('idle');
-
-  const { stakeAvailable: currentStakeAvailable, requiredStake } =
-    useStakeAvailable();
+  const {
+    err,
+    code,
+    status,
+    stakeAvailable: currentStakeAvailable,
+    requiredStake,
+    onSubmit,
+  } = useReferralSetTransaction();
 
   const { details: programDetails } = useReferralProgram();
 
-  const onSubmit = () => {
-    if (isReadOnly || !pubKey) {
-      setErr('Not connected');
-    } else {
-      setErr(null);
-      setStatus('loading');
-      setCode(null);
-      sendTx(pubKey, {
-        createReferralSet: {
-          isTeam: false,
-        },
-      })
-        .then((res) => {
-          if (!res) {
-            setErr(`Invalid response: ${JSON.stringify(res)}`);
-            return;
-          }
-          const code = determineId(res.signature);
-          setCode(code);
-          setStatus('success');
-        })
-        .catch((err) => {
-          if (err.message.includes('user rejected')) {
-            setStatus('idle');
-            return;
-          }
-          setStatus('error');
-          setErr(err.message);
-        });
-    }
-  };
-
   const getButtonProps = () => {
-    if (status === 'idle' || status === 'error') {
+    if (status === 'idle') {
       return {
         children: t('Generate code'),
-        onClick: () => onSubmit(),
+        onClick: () => onSubmit({ createReferralSet: { isTeam: false } }),
       };
     }
 
-    if (status === 'loading') {
+    if (status === 'requested') {
       return {
         children: t('Confirm in wallet...'),
         disabled: true,
       };
     }
 
-    if (status === 'success') {
+    if (status === 'pending') {
+      return {
+        children: t('Waiting for transaction...'),
+        disabled: true,
+      };
+    }
+
+    if (status === 'confirmed') {
       return {
         children: t('Close'),
         intent: Intent.Success,
@@ -209,7 +235,10 @@ const CreateCodeDialog = ({
   if (!programDetails) {
     return (
       <div className="flex flex-col gap-4">
-        {(status === 'idle' || status === 'loading' || status === 'error') && (
+        {(status === 'idle' ||
+          status === 'requested' ||
+          status === 'pending' ||
+          err) && (
           <>
             {
               <p>
@@ -220,7 +249,7 @@ const CreateCodeDialog = ({
             }
           </>
         )}
-        {status === 'success' && code && (
+        {status === 'confirmed' && code && (
           <div className="flex items-center gap-2">
             <div className="flex-1 min-w-0 p-2 text-sm rounded bg-vega-clight-700 dark:bg-vega-cdark-700">
               <p className="overflow-hidden whitespace-nowrap text-ellipsis">
@@ -240,7 +269,7 @@ const CreateCodeDialog = ({
         <TradingButton
           fill={true}
           intent={Intent.Primary}
-          onClick={() => onSubmit()}
+          onClick={() => onSubmit({ createReferralSet: { isTeam: false } })}
           {...getButtonProps()}
         >
           {t('Yes')}
@@ -269,14 +298,17 @@ const CreateCodeDialog = ({
 
   return (
     <div className="flex flex-col gap-4">
-      {(status === 'idle' || status === 'loading' || status === 'error') && (
+      {(status === 'idle' ||
+        status === 'requested' ||
+        status === 'pending' ||
+        err) && (
         <p>
           {t(
             'Generate a referral code to share with your friends and access the commission benefits of the current program.'
           )}
         </p>
       )}
-      {status === 'success' && code && (
+      {status === 'confirmed' && code && (
         <div className="flex items-center gap-2">
           <div className="flex-1 min-w-0 p-2 text-sm rounded bg-vega-clight-700 dark:bg-vega-cdark-700">
             <p className="overflow-hidden whitespace-nowrap text-ellipsis">

apps/trading/client-pages/referrals/error-boundary.tsx

@@ -1,53 +1,10 @@
-import { isRouteErrorResponse, useNavigate, useRouteError } from 'react-router';
-import { RainbowButton } from './buttons';
+import { useNavigate } from 'react-router';
+import { RainbowButton } from '../../components/rainbow-button';
+import { LayoutWithSky } from '../../components/layouts-inner';
 import { AnimatedDudeWithWire } from './graphics/dude';
-import { LayoutWithSky } from './layout';
 import { Routes } from '../../lib/links';
 import { useT } from '../../lib/use-t';
 
-export const ErrorBoundary = () => {
-  const t = useT();
-  const error = useRouteError();
-  const navigate = useNavigate();
-
-  const title = isRouteErrorResponse(error)
-    ? `${error.status} ${error.statusText}`
-    : t('Something went wrong');
-
-  const code = isRouteErrorResponse(error) ? error.status : 0;
-
-  const messages: Record<number, string> = {
-    0: t('An unknown error occurred.'),
-    404: t("The page you're looking for doesn't exists."),
-  };
-
-  return (
-    <LayoutWithSky className="pt-32">
-      <div
-        aria-hidden
-        className="absolute top-64 right-[220px] md:right-[340px] max-sm:hidden"
-      >
-        <AnimatedDudeWithWire className="animate-spin" />
-      </div>
-      <h1 className="text-6xl font-alpha calt mb-10">{title}</h1>
-
-      {Object.keys(messages).includes(code.toString()) ? (
-        <p className="text-lg mb-10">{messages[code]}</p>
-      ) : null}
-
-      <p className="text-lg mb-10">
-        <RainbowButton
-          onClick={() => navigate('..')}
-          variant="border"
-          className="text-xs"
-        >
-          {t('Go back and try again')}
-        </RainbowButton>
-      </p>
-    </LayoutWithSky>
-  );
-};
-
 export const NotFound = () => {
   const t = useT();
   const navigate = useNavigate();

apps/trading/client-pages/referrals/hooks/use-referral.ts

@@ -8,13 +8,13 @@ import type {
   ReferralSetsQueryVariables,
 } from './__generated__/ReferralSets';
 import { useReferralSetsQuery } from './__generated__/ReferralSets';
-import { useStakeAvailable } from './use-stake-available';
+import { useStakeAvailable } from '../../../lib/hooks/use-stake-available';
 
 export const DEFAULT_AGGREGATION_DAYS = 30;
 
 export type Role = 'referrer' | 'referee';
 type UseReferralArgs = (
-  | { code: string }
+  | { code: string | undefined }
   | { pubKey: string | null; role: Role }
 ) & {
   aggregationEpochs?: number;

apps/trading/client-pages/referrals/referral-statistics.spec.tsx

@@ -1,6 +1,9 @@
 import { MockedProvider, type MockedResponse } from '@apollo/react-testing';
-import { render, waitFor } from '@testing-library/react';
-import { type VegaWalletContextShape } from '@vegaprotocol/wallet';
+import { render, screen, waitFor } from '@testing-library/react';
+import {
+  VegaWalletContext,
+  type VegaWalletContextShape,
+} from '@vegaprotocol/wallet';
 import { ReferralStatistics } from './referral-statistics';
 import {
   ReferralProgramDocument,
@@ -15,7 +18,7 @@ import {
   StakeAvailableDocument,
   type StakeAvailableQueryVariables,
   type StakeAvailableQuery,
-} from './hooks/__generated__/StakeAvailable';
+} from '../../lib/hooks/__generated__/StakeAvailable';
 import {
   RefereesDocument,
   type RefereesQueryVariables,
@@ -296,122 +299,99 @@ const refereesMock30: MockedResponse<RefereesQuery, RefereesQueryVariables> = {
   },
 };
 
-jest.mock('@vegaprotocol/wallet', () => {
-  return {
-    ...jest.requireActual('@vegaprotocol/wallet'),
-    useVegaWallet: () => {
-      const ctx: Partial<VegaWalletContextShape> = {
-        pubKey: MOCK_PUBKEY,
-      };
-      return ctx;
-    },
-  };
-});
-
 describe('ReferralStatistics', () => {
-  it('displays apply code when no data has been found for given pubkey', () => {
-    const { queryByTestId } = render(
+  const renderComponent = (mocks: MockedResponse[]) => {
+    const walletContext = {
+      pubKey: MOCK_PUBKEY,
+      isReadOnly: false,
+      sendTx: jest.fn(),
+    } as unknown as VegaWalletContextShape;
+
+    return render(
       <MemoryRouter>
-        <MockedProvider mocks={[]} showWarnings={false}>
-          <ReferralStatistics />
-        </MockedProvider>
+        <VegaWalletContext.Provider value={walletContext}>
+          <MockedProvider mocks={mocks} showWarnings={false}>
+            <ReferralStatistics />
+          </MockedProvider>
+        </VegaWalletContext.Provider>
       </MemoryRouter>
     );
+  };
 
-    expect(queryByTestId('referral-apply-code-form')).toBeInTheDocument();
+  it('displays apply code when no data has been found for given pubkey', () => {
+    renderComponent([]);
+    expect(
+      screen.queryByTestId('referral-apply-code-form')
+    ).toBeInTheDocument();
   });
 
   it('displays referrer stats when given pubkey is a referrer', async () => {
-    const { queryByTestId } = render(
-      <MemoryRouter>
-        <MockedProvider
-          mocks={[
-            programMock,
-            referralSetAsReferrerMock,
-            noReferralSetAsRefereeMock,
-            stakeAvailableMock,
-            refereesMock,
-            refereesMock30,
-          ]}
-          showWarnings={false}
-        >
-          <ReferralStatistics />
-        </MockedProvider>
-      </MemoryRouter>
-    );
+    renderComponent([
+      programMock,
+      referralSetAsReferrerMock,
+      noReferralSetAsRefereeMock,
+      stakeAvailableMock,
+      refereesMock,
+      refereesMock30,
+    ]);
 
     await waitFor(() => {
       expect(
-        queryByTestId('referral-create-code-form')
+        screen.queryByTestId('referral-create-code-form')
       ).not.toBeInTheDocument();
-      expect(queryByTestId('referral-statistics')).toBeInTheDocument();
-      expect(queryByTestId('referral-statistics')?.dataset.as).toEqual(
+      expect(screen.queryByTestId('referral-statistics')).toBeInTheDocument();
+      expect(screen.queryByTestId('referral-statistics')?.dataset.as).toEqual(
         'referrer'
       );
       // gets commision from 30 epochs query
-      expect(queryByTestId('total-commission-value')).toHaveTextContent(
+      expect(screen.queryByTestId('total-commission-value')).toHaveTextContent(
         '12,340'
       );
     });
   });
 
   it('displays referee stats when given pubkey is a referee', async () => {
-    const { queryByTestId } = render(
-      <MemoryRouter>
-        <MockedProvider
-          mocks={[
-            programMock,
-            noReferralSetAsReferrerMock,
-            referralSetAsRefereeMock,
-            stakeAvailableMock,
-            refereesMock,
-          ]}
-          showWarnings={false}
-        >
-          <ReferralStatistics />
-        </MockedProvider>
-      </MemoryRouter>
-    );
-
+    renderComponent([
+      programMock,
+      noReferralSetAsReferrerMock,
+      referralSetAsRefereeMock,
+      stakeAvailableMock,
+      refereesMock,
+    ]);
     await waitFor(() => {
       expect(
-        queryByTestId('referral-create-code-form')
+        screen.queryByTestId('referral-create-code-form')
       ).not.toBeInTheDocument();
-      expect(queryByTestId('referral-statistics')).toBeInTheDocument();
-      expect(queryByTestId('referral-statistics')?.dataset.as).toEqual(
+      expect(screen.queryByTestId('referral-statistics')).toBeInTheDocument();
+      expect(screen.queryByTestId('referral-statistics')?.dataset.as).toEqual(
         'referee'
       );
     });
   });
 
   it('displays eligibility warning when the set is no longer valid due to the referrers stake', async () => {
-    const { queryByTestId } = render(
-      <MemoryRouter>
-        <MockedProvider
-          mocks={[
-            programMock,
-            noReferralSetAsReferrerMock,
-            referralSetAsRefereeMock,
-            nonEligibleStakeAvailableMock,
-            refereesMock,
-          ]}
-          showWarnings={false}
-        >
-          <ReferralStatistics />
-        </MockedProvider>
-      </MemoryRouter>
-    );
+    renderComponent([
+      programMock,
+      noReferralSetAsReferrerMock,
+      referralSetAsRefereeMock,
+      nonEligibleStakeAvailableMock,
+      refereesMock,
+    ]);
 
     await waitFor(() => {
       expect(
-        queryByTestId('referral-create-code-form')
+        screen.queryByTestId('referral-create-code-form')
       ).not.toBeInTheDocument();
-      expect(queryByTestId('referral-statistics')).toBeInTheDocument();
-      expect(queryByTestId('referral-statistics')?.dataset.as).toEqual(
+      expect(screen.queryByTestId('referral-statistics')).toBeInTheDocument();
+      expect(screen.queryByTestId('referral-statistics')?.dataset.as).toEqual(
         'referee'
       );
-      expect(queryByTestId('referral-eligibility-warning')).toBeInTheDocument();
-      expect(queryByTestId('referral-apply-code-form')).toBeInTheDocument();
+      expect(
+        screen.queryByTestId('referral-eligibility-warning')
+      ).toBeInTheDocument();
+      expect(
+        screen.queryByTestId('referral-apply-code-form')
+      ).toBeInTheDocument();
     });
   });
 });

apps/trading/client-pages/referrals/referral-statistics.tsx

@@ -1,20 +1,17 @@
+import { useCallback, useLayoutEffect, useRef, useState } from 'react';
+import BigNumber from 'bignumber.js';
 import minBy from 'lodash/minBy';
-import { CodeTile, StatTile } from './tile';
+import sortBy from 'lodash/sortBy';
+import compact from 'lodash/compact';
+import { Trans } from 'react-i18next';
+import classNames from 'classnames';
 import {
   VegaIcon,
   VegaIconNames,
   truncateMiddle,
   TextChildrenTooltip as Tooltip,
 } from '@vegaprotocol/ui-toolkit';
-
 import { useVegaWallet } from '@vegaprotocol/wallet';
-import {
-  DEFAULT_AGGREGATION_DAYS,
-  useReferral,
-  useUpdateReferees,
-} from './hooks/use-referral';
-import classNames from 'classnames';
-import { Table } from '../../components/table';
 import {
   addDecimalsFormatNumber,
   getDateFormat,
@@ -24,17 +21,22 @@ import {
   removePaginationWrapper,
 } from '@vegaprotocol/utils';
 import { useReferralSetStatsQuery } from './hooks/__generated__/ReferralSetStats';
-import compact from 'lodash/compact';
-import { useReferralProgram } from './hooks/use-referral-program';
-import { useStakeAvailable } from './hooks/use-stake-available';
-import sortBy from 'lodash/sortBy';
-import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react';
-import { useCurrentEpochInfoQuery } from './hooks/__generated__/Epoch';
-import BigNumber from 'bignumber.js';
+import { useStakeAvailable } from '../../lib/hooks/use-stake-available';
 import { useT, ns } from '../../lib/use-t';
-import { Trans } from 'react-i18next';
+import { useTeam } from '../../lib/hooks/use-team';
+import { TeamAvatar } from '../../components/competitions/team-avatar';
+import { TeamStats } from '../../components/competitions/team-stats';
+import { Table } from '../../components/table';
+import {
+  DEFAULT_AGGREGATION_DAYS,
+  useReferral,
+  useUpdateReferees,
+} from './hooks/use-referral';
 import { ApplyCodeForm, ApplyCodeFormContainer } from './apply-code-form';
+import { useReferralProgram } from './hooks/use-referral-program';
+import { useCurrentEpochInfoQuery } from './hooks/__generated__/Epoch';
 import { QUSDTooltip } from './qusd-tooltip';
+import { CodeTile, StatTile, Tile } from './tile';
 
 export const ReferralStatistics = () => {
   const { pubKey } = useVegaWallet();
@@ -192,10 +194,7 @@ export const Statistics = ({
     nextBenefitTierEpochsValue,
   } = useStats({ data, program });
 
-  const isApplyCodePreview = useMemo(
-    () => data.referee === null,
-    [data.referee]
-  );
+  const isApplyCodePreview = data.referee === null;
 
   const { benefitTiers } = useReferralProgram();
 
@@ -328,23 +327,6 @@ export const Statistics = ({
     </StatTile>
   );
 
-  const referrerTiles = (
-    <>
-      <div className="grid grid-rows-1 gap-5 grid-cols-1 md:grid-cols-3">
-        {baseCommissionTile}
-        {stakingMultiplierTile}
-        {finalCommissionTile}
-      </div>
-
-      <div className="grid grid-rows-1 gap-5 grid-cols-1 sm:grid-cols-2 xl:grid-cols-4">
-        {codeTile}
-        {referrerVolumeTile}
-        {numberOfTradersTile}
-        {totalCommissionTile}
-      </div>
-    </>
-  );
-
   const currentBenefitTierTile = (
     <StatTile
       title={t('Current tier')}
@@ -416,8 +398,41 @@ export const Statistics = ({
     </StatTile>
   );
 
+  const eligibilityWarningOverlay = as === 'referee' && !isEligible && (
+    <div
+      data-testid="referral-eligibility-warning"
+      className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 text-center w-1/2 lg:w-1/3"
+    >
+      <h2 className="text-2xl mb-2">{t('Referral code no longer valid')}</h2>
+      <p>
+        {t(
+          'Your referral code is no longer valid as the referrer no longer meets the minimum requirements. Apply a new code to continue receiving discounts.'
+        )}
+      </p>
+    </div>
+  );
+
+  const referrerTiles = (
+    <>
+      <Team teamId={data.code} />
+      <div className="grid grid-rows-1 gap-5 grid-cols-1 md:grid-cols-3">
+        {baseCommissionTile}
+        {stakingMultiplierTile}
+        {finalCommissionTile}
+      </div>
+
+      <div className="grid grid-rows-1 gap-5 grid-cols-1 sm:grid-cols-2 xl:grid-cols-4">
+        {codeTile}
+        {referrerVolumeTile}
+        {numberOfTradersTile}
+        {totalCommissionTile}
+      </div>
+    </>
+  );
+
   const refereeTiles = (
     <>
+      <Team teamId={data.code} />
       <div className="grid grid-rows-1 gap-5 grid-cols-1 md:grid-cols-3">
         {currentBenefitTierTile}
         {runningVolumeTile}
@@ -432,20 +447,6 @@ export const Statistics = ({
     </>
   );
 
-  const eligibilityWarning = as === 'referee' && !isEligible && (
-    <div
-      data-testid="referral-eligibility-warning"
-      className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 text-center w-1/2 lg:w-1/3"
-    >
-      <h2 className="text-2xl mb-2">{t('Referral code no longer valid')}</h2>
-      <p>
-        {t(
-          'Your referral code is no longer valid as the referrer no longer meets the minimum requirements. Apply a new code to continue receiving discounts.'
-        )}
-      </p>
-    </div>
-  );
-
   return (
     <div
       data-testid="referral-statistics"
@@ -460,8 +461,7 @@ export const Statistics = ({
         {as === 'referrer' && referrerTiles}
         {as === 'referee' && refereeTiles}
       </div>
-
-      {eligibilityWarning}
+      {eligibilityWarningOverlay}
     </div>
   );
 };
@@ -574,3 +574,19 @@ export const RefereesTable = ({
     </>
   );
 };
+
+const Team = ({ teamId }: { teamId?: string }) => {
+  const { team, games, members } = useTeam(teamId);
+
+  if (!team) return null;
+
+  return (
+    <Tile className="flex gap-3 lg:gap-4">
+      <TeamAvatar teamId={team.teamId} imgUrl={team.avatarUrl} />
+      <div className="flex flex-col items-start gap-1 lg:gap-3">
+        <h1 className="calt text-2xl lg:text-3xl xl:text-5xl">{team.name}</h1>
+        <TeamStats members={members} games={games} />
+      </div>
+    </Tile>
+  );
+};

apps/trading/client-pages/referrals/referrals.tsx

@@ -13,11 +13,9 @@ import { useVegaWallet } from '@vegaprotocol/wallet';
 import { useReferral } from './hooks/use-referral';
 import { REFERRAL_DOCS_LINK } from './constants';
 import classNames from 'classnames';
-import { usePageTitleStore } from '../../stores';
-import { useEffect } from 'react';
-import { titlefy } from '@vegaprotocol/utils';
 import { useT } from '../../lib/use-t';
 import { ErrorBoundary } from '../../components/error-boundary';
+import { usePageTitle } from '../../lib/hooks/use-page-title';
 
 const Nav = () => {
   const t = useT();
@@ -57,13 +55,7 @@ export const Referrals = () => {
   const loading = refereeLoading || referrerLoading;
   const showNav = !loading && !error && !referrer && !referee;
 
-  const { updateTitle } = usePageTitleStore((store) => ({
-    updateTitle: store.updateTitle,
-  }));
-
-  useEffect(() => {
-    updateTitle(titlefy([t('Referrals')]));
-  }, [updateTitle, t]);
+  usePageTitle(t('Referrals'));
 
   return (
     <ErrorBoundary feature="referrals">

apps/trading/client-pages/team/index.ts

@@ -1 +0,0 @@
-export { Team } from './team';

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

@@ -1,395 +0,0 @@
-import { useState, type ReactNode, type ButtonHTMLAttributes } from 'react';
-import { Link, useParams } from 'react-router-dom';
-import orderBy from 'lodash/orderBy';
-import countBy from 'lodash/countBy';
-import {
-  TradingButton as Button,
-  Intent,
-  Pill,
-  VegaIcon,
-  VegaIconNames,
-  Tooltip,
-  Splash,
-  truncateMiddle,
-} from '@vegaprotocol/ui-toolkit';
-import classNames from 'classnames';
-import { useT } from '../../lib/use-t';
-import { Table } from '../../components/table';
-import { formatNumberRounded, getDateTimeFormat } from '@vegaprotocol/utils';
-import {
-  useTeam,
-  type Team as TeamType,
-  type TeamStats,
-  type Member,
-  type TeamGame,
-} from './use-team';
-import { DApp, EXPLORER_PARTIES, useLinks } from '@vegaprotocol/environment';
-import BigNumber from 'bignumber.js';
-
-export const Team = () => {
-  const t = useT();
-  const { teamId } = useParams<{ teamId: string }>();
-  const { team, stats, partyInTeam, members, games } = useTeam(teamId);
-
-  if (!team) {
-    return (
-      <Splash>
-        <p>{t('Page not found')}</p>
-      </Splash>
-    );
-  }
-
-  return (
-    <TeamPage
-      team={team}
-      stats={stats}
-      partyInTeam={partyInTeam}
-      members={members}
-      games={games}
-    />
-  );
-};
-
-export const TeamPage = ({
-  team,
-  stats,
-  partyInTeam,
-  members,
-  games,
-}: {
-  team: TeamType;
-  stats?: TeamStats;
-  partyInTeam: boolean;
-  members?: Member[];
-  games?: TeamGame[];
-}) => {
-  const t = useT();
-  const [showGames, setShowGames] = useState(true);
-
-  return (
-    <div className="relative h-full overflow-y-auto">
-      <div className="absolute top-0 left-0 w-full h-[40%] -z-10 bg-[40%_0px] bg-cover bg-no-repeat bg-local bg-[url(/cover.png)]">
-        <div className="absolute top-o left-0 w-full h-full bg-gradient-to-t from-white dark:from-vega-cdark-900 to-transparent from-20% to-60%" />
-      </div>
-      <div className="flex flex-col gap-4 lg:gap-6 container p-4 mx-auto">
-        <header className="flex gap-3 lg:gap-4 pt-5 lg:pt-10">
-          <TeamAvatar imgUrl={team.avatarUrl} />
-          <div className="flex flex-col items-start gap-1 lg:gap-3">
-            <h1 className="calt text-2xl lg:text-3xl xl:text-5xl">
-              {team.name}
-            </h1>
-            <JoinButton joined={partyInTeam} />
-          </div>
-        </header>
-        <StatSection>
-          <StatList>
-            <Stat value={members ? members.length : 0} label={t('Members')} />
-            <Stat
-              value={stats ? stats.totalGamesPlayed : 0}
-              label={t('Total games')}
-              tooltip={t('Total number of games this team has participated in')}
-            />
-            <StatSectionSeparator />
-            <Stat
-              value={
-                stats
-                  ? formatNumberRounded(
-                      new BigNumber(stats.totalQuantumVolume),
-                      '1e3'
-                    )
-                  : 0
-              }
-              label={t('Total volume')}
-            />
-            <Stat
-              value={
-                stats
-                  ? formatNumberRounded(
-                      new BigNumber(stats.totalQuantumRewards),
-                      '1e3'
-                    )
-                  : 0
-              }
-              label={t('Rewards paid')}
-              tooltip={'Total amount of rewards paid out to this team in qUSD'}
-            />
-          </StatList>
-        </StatSection>
-        {games && games.length ? (
-          <StatSection>
-            <FavoriteGame games={games} />
-            <StatSectionSeparator />
-            <LatestResults games={games} />
-          </StatSection>
-        ) : null}
-        <section>
-          <div className="flex gap-4 lg:gap-8 mb-4 border-b border-default">
-            <ToggleButton active={showGames} onClick={() => setShowGames(true)}>
-              {t('Games ({{count}})', { count: games ? games.length : 0 })}
-            </ToggleButton>
-            <ToggleButton
-              active={!showGames}
-              onClick={() => setShowGames(false)}
-            >
-              {t('Members ({{count}})', {
-                count: members ? members.length : 0,
-              })}
-            </ToggleButton>
-          </div>
-          {showGames ? <Games games={games} /> : <Members members={members} />}
-        </section>
-      </div>
-    </div>
-  );
-};
-
-const Games = ({ games }: { games?: TeamGame[] }) => {
-  const t = useT();
-
-  if (!games?.length) {
-    return <p>{t('No games')}</p>;
-  }
-
-  return (
-    <Table
-      columns={[
-        { name: 'rank', displayName: t('Rank') },
-        {
-          name: 'epoch',
-          displayName: t('Epoch'),
-          headerClassName: 'hidden md:block',
-          className: 'hidden md:block',
-        },
-        { name: 'type', displayName: t('Type') },
-        { name: 'amount', displayName: t('Amount earned') },
-        {
-          name: 'teams',
-          displayName: t('No. of participating teams'),
-          headerClassName: 'hidden md:block',
-          className: 'hidden md:block',
-        },
-        { name: 'status', displayName: t('Status') },
-      ]}
-      data={games.map((game) => ({
-        rank: game.team.rank,
-        epoch: game.epoch,
-        type: game.team.rewardMetric,
-        amount: game.team.totalRewardsEarned,
-        teams: game.numberOfParticipants,
-      }))}
-      noCollapse={true}
-    />
-  );
-};
-
-const TeamAvatar = ({ imgUrl }: { imgUrl: string }) => {
-  // TODO: add fallback avatars
-  return (
-    // eslint-disable-next-line @next/next/no-img-element
-    <img
-      src={imgUrl}
-      alt="Team avatar"
-      className="rounded-full w-20 h-20 lg:w-[112px] lg:h-[112px] bg-vega-clight-700 dark:bg-vega-cdark-700 shrink-0"
-    />
-  );
-};
-
-const Members = ({ members }: { members?: Member[] }) => {
-  const t = useT();
-
-  if (!members?.length) {
-    return <p>{t('No members')}</p>;
-  }
-
-  const data = orderBy(
-    members.map((m) => ({
-      referee: <RefereeCell pubkey={m.referee} />,
-      joinedAt: getDateTimeFormat().format(new Date(m.joinedAt)),
-      joinedAtEpoch: Number(m.joinedAtEpoch),
-      explorerLink: <RefereeLink pubkey={m.referee} />,
-    })),
-    'joinedAtEpoch',
-    'desc'
-  );
-
-  return (
-    <Table
-      columns={[
-        { name: 'referee', displayName: t('Referee') },
-        {
-          name: 'joinedAt',
-          displayName: t('Joined at'),
-        },
-        {
-          name: 'joinedAtEpoch',
-          displayName: t('Joined epoch'),
-          headerClassName: 'text-right',
-          className: 'text-right',
-        },
-        {
-          name: 'explorerLink',
-          displayName: '',
-          headerClassName: 'hidden md:block',
-          className: 'hidden md:block text-right',
-        },
-      ]}
-      data={data}
-      noCollapse={true}
-    />
-  );
-};
-
-const RefereeCell = ({ pubkey }: { pubkey: string }) => {
-  return <span title={pubkey}>{truncateMiddle(pubkey)}</span>;
-};
-
-const RefereeLink = ({ pubkey }: { pubkey: string }) => {
-  const t = useT();
-
-  const linkCreator = useLinks(DApp.Explorer);
-  const link = linkCreator(EXPLORER_PARTIES.replace(':id', pubkey));
-
-  return (
-    <Link to={link} className="underline underline-offset-4">
-      {t('View on explorer')}
-    </Link>
-  );
-};
-
-const JoinButton = ({ joined }: { joined: boolean }) => {
-  const t = useT();
-
-  if (joined) {
-    return (
-      <Button intent={Intent.None} disabled={true}>
-        <span className="flex items-center gap-2">
-          {t('Joined')}{' '}
-          <span className="text-vega-green-600 dark:text-vega-green">
-            <VegaIcon name={VegaIconNames.TICK} />
-          </span>
-        </span>
-      </Button>
-    );
-  }
-
-  return <Button intent={Intent.Primary}>{t('Join this team')}</Button>;
-};
-
-const LatestResults = ({ games }: { games: TeamGame[] }) => {
-  const t = useT();
-  const latestGames = games.slice(0, 5);
-
-  return (
-    <dl>
-      <dt className="text-muted text-sm">
-        {t('Last {{count}} game results', { count: latestGames.length })}
-      </dt>
-      <dd className="flex gap-1">
-        {latestGames.map((game) => {
-          return (
-            <Pill key={game.id} className="text-sm">
-              {t('place', { count: game.team.rank, ordinal: true })}
-            </Pill>
-          );
-        })}
-      </dd>
-    </dl>
-  );
-};
-
-const FavoriteGame = ({ games }: { games: TeamGame[] }) => {
-  const t = useT();
-
-  const rewardMetrics = games.map((game) => game.team.rewardMetric);
-  const count = countBy(rewardMetrics);
-
-  let favoriteMetric = '';
-  let mostOccurances = 0;
-
-  for (const key in count) {
-    if (count[key] > mostOccurances) {
-      favoriteMetric = key;
-      mostOccurances = count[key];
-    }
-  }
-
-  if (!favoriteMetric) return null;
-
-  return (
-    <dl>
-      <dt className="text-muted text-sm">{t('Favorite game')}</dt>
-      <dd>
-        <Pill className="flex-inline items-center gap-2 bg-transparent text-sm">
-          <VegaIcon
-            name={VegaIconNames.STAR}
-            className="text-vega-yellow-400"
-          />{' '}
-          {favoriteMetric}
-        </Pill>
-      </dd>
-    </dl>
-  );
-};
-
-const ToggleButton = ({
-  active,
-  ...props
-}: ButtonHTMLAttributes<HTMLButtonElement> & { active: boolean }) => {
-  return (
-    <button
-      {...props}
-      className={classNames('relative top-px uppercase border-b-2 py-4', {
-        'text-muted border-transparent': !active,
-        'border-vega-yellow': active,
-      })}
-    />
-  );
-};
-
-const StatSection = ({ children }: { children: ReactNode }) => {
-  return (
-    <section className="flex flex-col lg:flex-row gap-2 lg:gap-8">
-      {children}
-    </section>
-  );
-};
-
-const StatSectionSeparator = () => {
-  return <div className="hidden md:block border-r border-default" />;
-};
-
-const StatList = ({ children }: { children: ReactNode }) => {
-  return (
-    <dl className="grid grid-cols-[min-content_min-content] md:flex gap-4 md:gap-6 lg:gap-8 whitespace-nowrap">
-      {children}
-    </dl>
-  );
-};
-
-const Stat = ({
-  value,
-  label,
-  tooltip,
-}: {
-  value: ReactNode;
-  label: ReactNode;
-  tooltip?: string;
-}) => {
-  return (
-    <div>
-      <dd className="text-3xl lg:text-4xl">{value}</dd>
-      <dt className="text-sm text-muted">
-        {tooltip ? (
-          <Tooltip description={tooltip} underline={false}>
-            <span className="flex items-center gap-2">
-              {label}
-              <VegaIcon name={VegaIconNames.INFO} size={12} />
-            </span>
-          </Tooltip>
-        ) : (
-          label
-        )}
-      </dt>
-    </div>
-  );
-};

apps/trading/components/bootstrapper/bootstrapper.tsx

@@ -13,6 +13,7 @@ import type { ReactNode } from 'react';
 import { Web3Provider } from './web3-provider';
 import { useT } from '../../lib/use-t';
 import { DataLoader } from './data-loader';
+import { useChainId } from '@vegaprotocol/wallet';
 
 export const Bootstrapper = ({ children }: { children: ReactNode }) => {
   const t = useT();
@@ -26,13 +27,16 @@ export const Bootstrapper = ({ children }: { children: ReactNode }) => {
     CHROME_EXTENSION_URL,
   } = useEnvironment();
 
+  const chainId = useChainId(VEGA_URL);
+
   if (
     !VEGA_URL ||
     !VEGA_WALLET_URL ||
     !VEGA_EXPLORER_URL ||
     !CHROME_EXTENSION_URL ||
     !MOZILLA_EXTENSION_URL ||
-    !DocsLinks
+    !DocsLinks ||
+    !chainId
   ) {
     return <AppLoader />;
   }
@@ -72,6 +76,7 @@ export const Bootstrapper = ({ children }: { children: ReactNode }) => {
               config={{
                 network: VEGA_ENV,
                 vegaUrl: VEGA_URL,
+                chainId,
                 vegaWalletServiceUrl: VEGA_WALLET_URL,
                 links: {
                   explorer: VEGA_EXPLORER_URL,

apps/trading/components/chart-container/chart-container.tsx

@@ -1,5 +1,5 @@
 import invert from 'lodash/invert';
-import { Interval } from '@vegaprotocol/types';
+import { type Interval } from '@vegaprotocol/types';
 import {
   TradingViewContainer,
   ALLOWED_TRADINGVIEW_HOSTNAMES,
@@ -26,12 +26,12 @@ export const ChartContainer = ({ marketId }: { marketId: string }) => {
     overlays,
     studies,
     studySizes,
-    tradingViewStudies,
     setInterval,
     setStudies,
     setStudySizes,
     setOverlays,
-    setTradingViewStudies,
+    state,
+    setState,
   } = useChartSettings();
 
   const pennantChart = (
@@ -65,13 +65,13 @@ export const ChartContainer = ({ marketId }: { marketId: string }) => {
           libraryHash={CHARTING_LIBRARY_HASH}
           marketId={marketId}
           interval={toTradingViewResolution(interval as SupportedInterval)}
-          studies={tradingViewStudies}
           onIntervalChange={(newInterval) => {
             setInterval(fromTradingViewResolution(newInterval));
           }}
-          onAutoSaveNeeded={(data: { studies: string[] }) => {
-            setTradingViewStudies(data.studies);
+          onAutoSaveNeeded={(data) => {
+            setState(data);
           }}
+          state={state}
         />
       );
     }

apps/trading/components/chart-container/chart-menu.spec.tsx

@@ -27,10 +27,10 @@ describe('ChartMenu', () => {
 
     render(<ChartMenu />);
 
-    await userEvent.click(screen.getByRole('button', { name: 'TradingView' }));
+    await userEvent.click(screen.getByTestId('chartlib-toggle-button'));
     expect(useChartSettingsStore.getState().chartlib).toEqual('tradingview');
 
-    await userEvent.click(screen.getByRole('button', { name: 'Vega chart' }));
+    await userEvent.click(screen.getByTestId('chartlib-toggle-button'));
     expect(useChartSettingsStore.getState().chartlib).toEqual('pennant');
   });
 

apps/trading/components/chart-container/chart-menu.tsx

@@ -18,7 +18,7 @@ import {
   TradingDropdownTrigger,
   Icon,
 } from '@vegaprotocol/ui-toolkit';
-import { Interval } from '@vegaprotocol/types';
+import { type Interval } from '@vegaprotocol/types';
 import { useEnvironment } from '@vegaprotocol/environment';
 import { ALLOWED_TRADINGVIEW_HOSTNAMES } from '@vegaprotocol/trading-view';
 import { IconNames, type IconName } from '@blueprintjs/icons';
@@ -60,6 +60,7 @@ export const ChartMenu = () => {
         setChartlib(isPennant ? 'tradingview' : 'pennant');
       }}
       size="extra-small"
+      testId="chartlib-toggle-button"
     >
       {isPennant ? 'TradingView' : t('Vega chart')}
     </TradingButton>

apps/trading/components/chart-container/use-chart-settings.ts

@@ -9,6 +9,7 @@ type StudySizes = { [S in Study]?: number };
 export type Chartlib = 'pennant' | 'tradingview';
 
 interface StoredSettings {
+  state: object | undefined; // Don't see a better type provided from TradingView type definitions
   chartlib: Chartlib;
   // For interval we use the enum from @vegaprotocol/types, this is to make mapping between different
   // chart types easier and more consistent
@@ -17,7 +18,6 @@ interface StoredSettings {
   overlays: Overlay[];
   studies: Study[];
   studySizes: StudySizes;
-  tradingViewStudies: string[];
 }
 
 export const STUDY_SIZE = 90;
@@ -30,13 +30,13 @@ const STUDY_ORDER: Study[] = [
 ];
 
 export const DEFAULT_CHART_SETTINGS = {
+  state: undefined,
   chartlib: 'pennant' as const,
   interval: Interval.INTERVAL_I15M,
   type: ChartType.CANDLE,
   overlays: [Overlay.MOVING_AVERAGE],
   studies: [Study.MACD, Study.VOLUME],
   studySizes: {},
-  tradingViewStudies: ['Volume'],
 };
 
 export const useChartSettingsStore = create<
@@ -47,7 +47,7 @@ export const useChartSettingsStore = create<
     setStudies: (studies?: Study[]) => void;
     setStudySizes: (sizes: number[]) => void;
     setChartlib: (lib: Chartlib) => void;
-    setTradingViewStudies: (studies: string[]) => void;
+    setState: (state: object) => void;
   }
 >()(
   persist(
@@ -95,10 +95,8 @@ export const useChartSettingsStore = create<
           state.chartlib = lib;
         });
       },
-      setTradingViewStudies: (studies: string[]) => {
-        set((state) => {
-          state.tradingViewStudies = studies;
-        });
+      setState: (state) => {
+        set({ state });
       },
     })),
     {
@@ -147,13 +145,13 @@ export const useChartSettings = () => {
     overlays,
     studies,
     studySizes,
-    tradingViewStudies: settings.tradingViewStudies,
     setInterval: settings.setInterval,
     setType: settings.setType,
     setStudies: settings.setStudies,
     setOverlays: settings.setOverlays,
     setStudySizes: settings.setStudySizes,
     setChartlib: settings.setChartlib,
-    setTradingViewStudies: settings.setTradingViewStudies,
+    state: settings.state,
+    setState: settings.setState,
   };
 };

apps/trading/components/competitions/box.tsx

@@ -0,0 +1,21 @@
+import classNames from 'classnames';
+import { type HTMLAttributes } from 'react';
+
+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>) => {
+  return (
+    <div
+      {...props}
+      className={classNames(
+        BORDER_COLOR,
+        GRADIENT,
+        'border rounded-lg',
+        'p-6',
+        props.className
+      )}
+    />
+  );
+};

apps/trading/components/competitions/competitions-cta.tsx

@@ -0,0 +1,41 @@
+import { Box } from './box';
+import { type ComponentProps, type ReactElement, type ReactNode } from 'react';
+import { DudeBadge } from './graphics/dude-badge';
+
+export const CompetitionsActionsContainer = ({
+  children,
+}: {
+  children:
+    | ReactElement<typeof CompetitionsAction>
+    | Iterable<ReactElement<typeof CompetitionsAction>>;
+}) => (
+  <div
+    className="grid grid-cols-1 md:grid-cols-3 grid-rows-4'
+ gap-6 mb-12"
+  >
+    {children}
+  </div>
+);
+
+export const CompetitionsAction = ({
+  variant,
+  title,
+  description,
+  actionElement,
+}: {
+  variant: ComponentProps<typeof DudeBadge>['variant'];
+  title: string;
+  description?: string;
+  actionElement: ReactNode;
+}) => {
+  return (
+    <Box className="grid md:grid-rows-[subgrid] gap-6 row-span-4 text-center">
+      <div className="flex justify-center">
+        <DudeBadge variant={variant} />
+      </div>
+      <h2 className="text-2xl">{title}</h2>
+      {description && <p className="text-muted">{description}</p>}
+      <div className="flex justify-center">{actionElement}</div>
+    </Box>
+  );
+};

apps/trading/components/competitions/competitions-header.tsx

@@ -0,0 +1,27 @@
+import { AnimatedDudeWithWire } from '../../client-pages/referrals/graphics/dude';
+import { type ReactNode } from 'react';
+
+export const CompetitionsHeader = ({
+  title,
+  children,
+}: {
+  title: string;
+  children?: ReactNode;
+}) => {
+  return (
+    <div className="relative mb-4 lg:mb-20">
+      <div
+        aria-hidden
+        className="absolute top-20 right-[220px] md:right-[240px] max-sm:hidden"
+      >
+        <AnimatedDudeWithWire />
+      </div>
+      <div className="pt-6 lg:pt-20 sm:w-1/2">
+        <h1 className="text-3xl lg:text-6xl leading-[1em] font-alpha calt mb-2 lg:mb-10">
+          {title}
+        </h1>
+        {children}
+      </div>
+    </div>
+  );
+};

apps/trading/components/competitions/competitions-leaderboard.tsx

@@ -0,0 +1,71 @@
+import { Link } from 'react-router-dom';
+import { Splash } from '@vegaprotocol/ui-toolkit';
+import { getNumberFormat } from '@vegaprotocol/utils';
+import { type useTeams } from '../../lib/hooks/use-teams';
+import { useT } from '../../lib/use-t';
+import { Table } from '../table';
+import { Rank } from './graphics/rank';
+import { Links } from '../../lib/links';
+import { TeamAvatar } from './team-avatar';
+
+export const CompetitionsLeaderboard = ({
+  data,
+}: {
+  data: ReturnType<typeof useTeams>['data'];
+}) => {
+  const t = useT();
+
+  const num = (n?: number | string) =>
+    !n ? '-' : getNumberFormat(0).format(Number(n));
+
+  if (!data || data.length === 0) {
+    return <Splash>{t('Could not find any teams')}</Splash>;
+  }
+
+  return (
+    <Table
+      columns={[
+        { name: 'rank', displayName: '#' },
+        { name: 'avatar', displayName: '' },
+        { name: 'team', displayName: t('Team') },
+        { name: 'earned', displayName: t('Rewards earned') },
+        { name: 'games', displayName: t('Total games') },
+        { name: 'status', displayName: t('Status') },
+        { name: 'volume', displayName: t('Volume') },
+      ]}
+      data={data.map((td, i) => {
+        // leaderboard place or medal
+        let rank: number | React.ReactNode = i + 1;
+        if (rank === 1) rank = <Rank variant="gold" />;
+        if (rank === 2) rank = <Rank variant="silver" />;
+        if (rank === 3) rank = <Rank variant="bronze" />;
+
+        const avatar = (
+          <TeamAvatar
+            teamId={td.teamId}
+            imgUrl={td.avatarUrl}
+            alt={td.name}
+            size="small"
+          />
+        );
+
+        return {
+          rank,
+          avatar,
+          team: (
+            <Link
+              className="hover:underline"
+              to={Links.COMPETITIONS_TEAM(td.teamId)}
+            >
+              {td.name}
+            </Link>
+          ),
+          earned: num(td.totalQuantumRewards),
+          games: num(td.totalGamesPlayed),
+          status: td.closed ? t('Closed') : t('Open'),
+          volume: num(td.totalQuantumVolume),
+        };
+      })}
+    />
+  );
+};

apps/trading/components/competitions/games-container.tsx

@@ -0,0 +1,44 @@
+import { type TransferNode } from '@vegaprotocol/types';
+import { ActiveRewardCard } from '../rewards-container/active-rewards';
+import { useT } from '../../lib/use-t';
+
+export const GamesContainer = ({
+  data,
+  currentEpoch,
+}: {
+  data: TransferNode[];
+  currentEpoch: number;
+}) => {
+  const t = useT();
+
+  if (!data || data.length === 0) {
+    return (
+      <p className="mb-6 text-muted">
+        {t('There are currently no games available.')}
+      </p>
+    );
+  }
+
+  return (
+    <div className="mb-12 grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+      {data.map((game, i) => {
+        // TODO: Remove `kind` prop from ActiveRewardCard
+        const { transfer } = game;
+        if (
+          transfer.kind.__typename !== 'RecurringTransfer' ||
+          !transfer.kind.dispatchStrategy?.dispatchMetric
+        ) {
+          return null;
+        }
+        return (
+          <ActiveRewardCard
+            key={i}
+            transferNode={game}
+            currentEpoch={currentEpoch}
+            kind={transfer.kind}
+          />
+        );
+      })}
+    </div>
+  );
+};

apps/trading/components/competitions/graphics/dude-badge.tsx

@@ -0,0 +1,40 @@
+import classNames from 'classnames';
+import { DudeWithFlag } from './dude-with-flag';
+
+/**
+ * Pre-defined badge gradients
+ */
+
+export const BADGE_GRADIENT_VARIANT_A =
+  'bg-gradient-to-r from-vega-blue-500 via-vega-purple-500 to-vega-pink-500';
+export const BADGE_GRADIENT_VARIANT_B =
+  'bg-gradient-to-r from-vega-purple-500 via-vega-green-500 to-vega-blue-500';
+export const BADGE_GRADIENT_VARIANT_C =
+  'bg-gradient-to-r from-vega-blue-500 via-vega-purple-500 to-vega-green-500';
+
+/** Badge */
+
+export const DudeBadge = ({
+  variant,
+  className,
+}: {
+  variant: 'A' | 'B' | 'C' | undefined;
+  className?: classNames.Argument;
+}) => {
+  return (
+    <div
+      className={classNames(
+        'w-24 h-24 rounded-full bg-black relative',
+        'rotate-12',
+        {
+          [BADGE_GRADIENT_VARIANT_A]: variant === 'A',
+          [BADGE_GRADIENT_VARIANT_B]: variant === 'B',
+          [BADGE_GRADIENT_VARIANT_C]: variant === 'C',
+        },
+        className
+      )}
+    >
+      <DudeWithFlag className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 -rotate-12" />
+    </div>
+  );
+};

apps/trading/components/competitions/graphics/dude-with-flag.tsx

@@ -0,0 +1,50 @@
+import { theme } from '@vegaprotocol/tailwindcss-config';
+
+type DudeWithFlagProps = {
+  flagColor?: string;
+  withStar?: boolean;
+  className?: string;
+};
+
+const DEFAULT_FLAG_COLOR = theme.colors.vega.green[500];
+
+export const DudeWithFlag = ({
+  flagColor = DEFAULT_FLAG_COLOR,
+  withStar = true,
+  className,
+}: DudeWithFlagProps) => {
+  return (
+    <svg
+      width="49"
+      height="43"
+      viewBox="0 0 49 43"
+      fill="none"
+      className={className}
+    >
+      {withStar && (
+        <>
+          <path d="M3.99992 0H2V1.99993H3.99992V0Z" fill="white" />
+          <path
+            d="M2 1.99993L0 1.99981V3.99974H1.99992L2 1.99993Z"
+            fill="white"
+          />
+          <path
+            d="M3.99995 3.99992L1.99992 3.99974L2 5.99988H3.99995V3.99992Z"
+            fill="white"
+          />
+          <path
+            d="M5.99997 1.99981L3.99992 1.99993L3.99995 3.99992L5.99997 3.99974V1.99981Z"
+            fill="white"
+          />
+        </>
+      )}
+      <path
+        d="M32 4H11V33H15V43H20V33H23V43H28V33H32V4ZM20 17H15V12H20V17ZM28 17H23V12H28V17Z"
+        fill="white"
+      />
+      <path d="M41 25L32 25L32 20L41 20L41 25Z" fill="white" />
+      <path d="M36 29V4H35V29" fill="white" />
+      <path d="M36 13H49L44.55 8.5L49 4H36V13Z" fill={flagColor} />
+    </svg>
+  );
+};

apps/trading/components/competitions/graphics/rank.tsx

@@ -0,0 +1,110 @@
+import { useThemeSwitcher } from '@vegaprotocol/react-helpers';
+import classNames from 'classnames';
+
+export const Rank = ({
+  variant,
+  className,
+}: {
+  variant?: 'gold' | 'silver' | 'bronze';
+  className?: classNames.Argument;
+}) => {
+  const { theme } = useThemeSwitcher();
+  return (
+    <div
+      title={classNames({
+        '1': variant === 'gold',
+        '2': variant === 'silver',
+        '3': variant === 'bronze',
+      })}
+      className={classNames(
+        {
+          'text-yellow-300': variant === 'gold',
+          'text-vega-clight-500': variant === 'silver',
+          'text-vega-orange-500': variant === 'bronze',
+          'text-black dark:text-white': variant === undefined,
+        },
+        className
+      )}
+    >
+      <svg width="18" height="30" viewBox="0 0 18 30" fill="none">
+        <defs>
+          <linearGradient x1="0" y1="0" x2="100%" y2="100%" id="medal">
+            <stop offset="33%" stopColor="transparent" />
+            <stop offset="100%" stopColor="black" stopOpacity="50%" />
+          </linearGradient>
+          <clipPath id="shape">
+            <path d="M2 2H4V4H2V2Z" />
+            <path d="M2 2H4V4H2V2Z" />
+            <path d="M2 2H6V4H2V2Z" />
+            <path d="M2 2H6V4H2V2Z" />
+            <path d="M0 4H4V6H0V4Z" />
+            <path d="M0 4H4V6H0V4Z" />
+            <path d="M4 0H14V2H4V0Z" />
+            <path d="M4 0H14V2H4V0Z" />
+            <path d="M0 14V4H2V14H0Z" />
+            <path d="M0 14V4H2V14H0Z" />
+            <path d="M2 30L2 18H4L4 30H2Z" />
+            <path d="M2 30L2 18H4L4 30H2Z" />
+            <path d="M14 30L14 18H16L16 30H14Z" />
+            <path d="M14 30L14 18H16L16 30H14Z" />
+            <path d="M16 14L16 4H18V14H16Z" />
+            <path d="M16 14L16 4H18V14H16Z" />
+            <path d="M2 6V2H4V6H2Z" />
+            <path d="M2 6V2H4V6H2Z" />
+            <path d="M16 2V6H14V2H16Z" />
+            <path d="M16 2V6H14V2H16Z" />
+            <path d="M12 2H16L16 4H12V2Z" />
+            <path d="M12 2H16L16 4H12V2Z" />
+            <path d="M14 4H18V6H14V4Z" />
+            <path d="M14 4H18V6H14V4Z" />
+            <path d="M16 16H12V14H16V16Z" />
+            <path d="M16 16H12V14H16V16Z" />
+            <path d="M14 18H4L4 16L14 16L14 18Z" />
+            <path d="M14 18H4L4 16L14 16L14 18Z" />
+            <path d="M16 12V16H14V12H16Z" />
+            <path d="M16 12V16H14V12H16Z" />
+            <path d="M6 16H2V14H6V16Z" />
+            <path d="M6 16H2V14H6V16Z" />
+            <path d="M6 28H4L4 26H6V28Z" />
+            <path d="M6 28H4L4 26H6V28Z" />
+            <path d="M8 26H6L6 24H8V26Z" />
+            <path d="M8 26H6L6 24H8V26Z" />
+            <path d="M10 24H8V22H10V24Z" />
+            <path d="M10 24H8V22H10V24Z" />
+            <path d="M12 26H10L10 24H12V26Z" />
+            <path d="M12 26H10L10 24H12V26Z" />
+            <path d="M14 28H12L12 26H14V28Z" />
+            <path d="M14 28H12L12 26H14V28Z" />
+            <path d="M4 14H0L2.04189e-07 12H4V14Z" />
+            <path d="M4 14H0L2.04189e-07 12H4V14Z" />
+            <path d="M6 4H12V14H6V4Z" />
+            <path d="M6 4H12V14H6V4Z" />
+            <path d="M4 6H14V12H4V6Z" />
+            <path d="M4 6H14V12H4V6Z" />
+          </clipPath>
+        </defs>
+        <rect
+          rx="0"
+          ry="0"
+          width="18"
+          height="30"
+          fill="currentColor"
+          clipPath="url(#shape)"
+        />
+        <rect
+          rx="0"
+          ry="0"
+          width="18"
+          height="30"
+          fill="url(#medal)"
+          clipPath="url(#shape)"
+          style={{ mixBlendMode: theme === 'dark' ? 'darken' : 'overlay' }}
+        />
+        <g style={{ mixBlendMode: 'overlay' }}>
+          <path d="M10.5 6H8.5V8H10.5V6Z" fill="white" />
+          <path d="M12.5 8H10.5V10H12.5V8Z" fill="white" />
+        </g>
+      </svg>
+    </div>
+  );
+};

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

@@ -0,0 +1,41 @@
+import classNames from 'classnames';
+
+const NUM_AVATARS = 20;
+const AVATAR_PATHNAME_PATTERN = '/team-avatars/{id}.png';
+
+const getFallbackAvatar = (teamId: string) => {
+  const avatarId = ((parseInt(teamId, 16) % NUM_AVATARS) + 1)
+    .toString()
+    .padStart(2, '0'); // between 01 - 20
+
+  return AVATAR_PATHNAME_PATTERN.replace('{id}', avatarId);
+};
+
+export const TeamAvatar = ({
+  teamId,
+  imgUrl,
+  alt,
+  size = 'large',
+}: {
+  teamId: string;
+  imgUrl: string;
+  alt?: string;
+  size?: 'large' | 'small';
+}) => {
+  const img = imgUrl && imgUrl.length > 0 ? imgUrl : getFallbackAvatar(teamId);
+  return (
+    // eslint-disable-next-line @next/next/no-img-element
+    <img
+      src={img}
+      alt={alt || 'Team avatar'}
+      className={classNames(
+        'rounded-full bg-vega-clight-700 dark:bg-vega-cdark-700 shrink-0',
+        {
+          'w-20 h-20 lg:w-[112px] lg:h-[112px]': size === 'large',
+          'w-10 h-10': size === 'small',
+        }
+      )}
+      referrerPolicy="no-referrer"
+    />
+  );
+};

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

@@ -0,0 +1,195 @@
+import { type ReactNode } from 'react';
+import BigNumber from 'bignumber.js';
+import countBy from 'lodash/countBy';
+import {
+  Pill,
+  VegaIcon,
+  VegaIconNames,
+  Tooltip,
+} from '@vegaprotocol/ui-toolkit';
+import { formatNumberRounded } from '@vegaprotocol/utils';
+import {
+  type TeamStats as ITeamStats,
+  type Member,
+  type TeamGame,
+} from '../../lib/hooks/use-team';
+import { useT } from '../../lib/use-t';
+import { DispatchMetricLabels, type DispatchMetric } from '@vegaprotocol/types';
+
+export const TeamStats = ({
+  stats,
+  members,
+  games,
+}: {
+  stats?: ITeamStats;
+  members?: Member[];
+  games?: TeamGame[];
+}) => {
+  const t = useT();
+  return (
+    <>
+      <StatSection>
+        <StatList>
+          <Stat
+            value={members ? members.length : 0}
+            label={t('Members')}
+            valueTestId="members-count-stat"
+          />
+          <Stat
+            value={stats ? stats.totalGamesPlayed : 0}
+            label={t('Total games')}
+            tooltip={t('Total number of games this team has participated in')}
+            valueTestId="total-games-stat"
+          />
+          <StatSectionSeparator />
+          <Stat
+            value={
+              stats
+                ? formatNumberRounded(
+                    new BigNumber(stats.totalQuantumVolume || 0),
+                    '1e3'
+                  )
+                : 0
+            }
+            label={t('Total volume')}
+            valueTestId="total-volume-stat"
+          />
+          <Stat
+            value={
+              stats
+                ? formatNumberRounded(
+                    new BigNumber(stats.totalQuantumRewards || 0),
+                    '1e3'
+                  )
+                : 0
+            }
+            label={t('Rewards paid out')}
+            tooltip={'Total amount of rewards paid out to this team in qUSD'}
+            valueTestId="rewards-paid-stat"
+          />
+        </StatList>
+      </StatSection>
+      {games && games.length ? (
+        <StatSection>
+          <FavoriteGame games={games} />
+          <StatSectionSeparator />
+          <LatestResults games={games} />
+        </StatSection>
+      ) : null}
+    </>
+  );
+};
+
+const LatestResults = ({ games }: { games: TeamGame[] }) => {
+  const t = useT();
+  const latestGames = games.slice(0, 5);
+
+  return (
+    <dl className="flex flex-col gap-1">
+      <dt className="text-muted text-sm">
+        {t('gameCount', { count: latestGames.length })}
+      </dt>
+      <dd className="flex gap-1">
+        {latestGames.map((game) => {
+          return (
+            <Pill key={game.id} className="text-sm">
+              {t('place', { count: game.team.rank, ordinal: true })}
+            </Pill>
+          );
+        })}
+      </dd>
+    </dl>
+  );
+};
+
+const FavoriteGame = ({ games }: { games: TeamGame[] }) => {
+  const t = useT();
+
+  const rewardMetrics = games.map(
+    (game) => game.team.rewardMetric as DispatchMetric
+  );
+  const count = countBy(rewardMetrics);
+
+  let favoriteMetric = '';
+  let mostOccurances = 0;
+
+  for (const key in count) {
+    if (count[key] > mostOccurances) {
+      favoriteMetric = key;
+      mostOccurances = count[key];
+    }
+  }
+
+  if (!favoriteMetric) return null;
+
+  // rewardMetric is a string, should be typed as DispatchMetric
+  const favoriteMetricLabel =
+    DispatchMetricLabels[favoriteMetric as DispatchMetric];
+
+  return (
+    <dl className="flex flex-col gap-1">
+      <dt className="text-muted text-sm">{t('Favorite game')}</dt>
+      <dd>
+        <Pill className="inline-flex items-center gap-1 bg-transparent text-sm">
+          <VegaIcon
+            name={VegaIconNames.STAR}
+            className="text-vega-yellow-400 relative top-[-1px]"
+          />{' '}
+          {favoriteMetricLabel}
+        </Pill>
+      </dd>
+    </dl>
+  );
+};
+
+const StatSection = ({ children }: { children: ReactNode }) => {
+  return (
+    <section className="flex flex-col lg:flex-row gap-4 lg:gap-8">
+      {children}
+    </section>
+  );
+};
+
+const StatSectionSeparator = () => {
+  return <div className="hidden md:block border-r border-default" />;
+};
+
+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}
+    </dl>
+  );
+};
+
+const Stat = ({
+  value,
+  label,
+  tooltip,
+  valueTestId,
+}: {
+  value: ReactNode;
+  label: ReactNode;
+  tooltip?: string;
+  valueTestId?: string;
+}) => {
+  return (
+    <div>
+      <dd className="text-3xl lg:text-4xl" data-testid={valueTestId}>
+        {value}
+      </dd>
+      <dt className="text-sm text-muted">
+        {tooltip ? (
+          <Tooltip description={tooltip} underline={false}>
+            <span className="flex items-center gap-2">
+              {label}
+              <VegaIcon name={VegaIconNames.INFO} size={12} />
+            </span>
+          </Tooltip>
+        ) : (
+          label
+        )}
+      </dt>
+    </div>
+  );
+};

apps/trading/components/grid-settings/grid-settings.spec.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { GridSettings } from './grid-settings';
+import '@testing-library/jest-dom';
+
+describe('GridSettings', () => {
+  it('calls updateGridStore with correct arguments on button click', async () => {
+    const mockUpdateGridStore = jest.fn();
+    const { getByText } = render(
+      <GridSettings updateGridStore={mockUpdateGridStore} />
+    );
+
+    await userEvent.click(getByText('Reset Columns'));
+
+    expect(mockUpdateGridStore).toHaveBeenCalledWith({
+      columnState: undefined,
+      filterModel: undefined,
+    });
+  });
+});

apps/trading/components/layouts-inner/index.ts

@@ -0,0 +1,2 @@
+export { LayoutWithSky } from './layout-with-sky';
+export { LayoutWithGradient } from './layout-with-gradient';

apps/trading/components/layouts-inner/layout-with-gradient.tsx

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+
+export const LayoutWithGradient = ({ children }: { children: ReactNode }) => {
+  return (
+    <div className="relative h-full pt-5 overflow-y-auto">
+      <div className="absolute top-0 left-0 w-full h-[40%] -z-10 bg-[40%_0px] bg-cover bg-no-repeat bg-local bg-[url(/cover.png)]">
+        <div className="absolute top-o left-0 w-full h-full bg-gradient-to-t from-white dark:from-vega-cdark-900 to-transparent from-20% to-60%" />
+      </div>
+      <div className="flex flex-col gap-4 lg:gap-6 container p-4 mx-auto">
+        {children}
+      </div>
+    </div>
+  );
+};

apps/trading/components/layouts-inner/layout-with-sky.tsx

@@ -1,10 +1,12 @@
 import classNames from 'classnames';
 import type { HTMLAttributes } from 'react';
-import { SKY_BACKGROUND } from './constants';
 import { Outlet } from 'react-router-dom';
 import { TinyScroll } from '@vegaprotocol/ui-toolkit';
 
-export const Layout = ({
+export const SKY_BACKGROUND =
+  'bg-[url(/sky-light.png)] dark:bg-[url(/sky-dark.png)] bg-[37%_0px] bg-[length:1440px] bg-no-repeat bg-local';
+
+const Layout = ({
   className,
   children,
   ...props

apps/trading/components/layouts/index.ts

@@ -1 +1,2 @@
-export * from './layout-with-sidebar';
+export { LayoutWithSidebar } from './layout-with-sidebar';
+export { LayoutCentered } from './layout-centered';