fix: uncomment tests

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

.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: 90
+    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: 90
+    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 2 --dist loadfile --durations=90
+        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

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-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/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

@@ -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',
@@ -241,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',

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/routes/proposals/components/proposal-detail-header/proposal-header.spec.tsx

@@ -124,7 +124,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';
@@ -12,7 +18,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: ProposalQuery['proposal']) => {

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

@@ -212,7 +212,6 @@ query Proposal(
           }
           positionDecimalPlaces
           linearSlippageFactor
-          quadraticSlippageFactor
         }
         ... on UpdateMarket {
           marketId

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

@@ -22,7 +22,12 @@ NX_WALLETCONNECT_PROJECT_ID=fe8091dc35738863e509fc4947525c72
 NX_SUCCESSOR_MARKETS=true
 NX_STOP_ORDERS=true
 NX_ICEBERG_ORDERS=true
-# NX_PRODUCT_PERPETUALS
 NX_METAMASK_SNAPS=true
 NX_REFERRALS=true
-NX_TEAM_COMPETITION=true
+# NX_DISABLE_CLOSE_POSITION=false
+
+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/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

@@ -25,12 +25,12 @@ export const ChartContainer = ({ marketId }: { marketId: string }) => {
     overlays,
     studies,
     studySizes,
-    tradingViewStudies,
     setInterval,
     setStudies,
     setStudySizes,
     setOverlays,
-    setTradingViewStudies,
+    state,
+    setState,
   } = useChartSettings();
 
   const pennantChart = (
@@ -64,13 +64,13 @@ export const ChartContainer = ({ marketId }: { marketId: string }) => {
           libraryHash={CHARTING_LIBRARY_HASH}
           marketId={marketId}
           interval={toTradingViewResolution(interval)}
-          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

@@ -68,6 +68,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/navbar/navbar.tsx

@@ -162,6 +162,8 @@ const NavbarMenu = ({ onClick }: { onClick: () => void }) => {
   const envNameMapping = useEnvNameMapping();
   const { VEGA_ENV, VEGA_NETWORKS, GITHUB_FEEDBACK_URL } = useEnvironment();
   const marketId = useGlobalStore((store) => store.marketId);
+  const GOVERNANCE_LINK = useLinks(DApp.Governance)();
+  const EXPLORER_LINK = useLinks(DApp.Explorer)();
 
   return (
     <div className="gap-3 lg:flex lg:h-full">
@@ -220,7 +222,7 @@ const NavbarMenu = ({ onClick }: { onClick: () => void }) => {
           </NavbarLink>
         </NavbarItem>
         <NavbarItem>
-          <NavbarLinkExternal to={useLinks(DApp.Governance)()}>
+          <NavbarLinkExternal to={GOVERNANCE_LINK}>
             {t('Governance')}
           </NavbarLinkExternal>
         </NavbarItem>
@@ -228,6 +230,13 @@ const NavbarMenu = ({ onClick }: { onClick: () => void }) => {
           <NavbarTrigger>{t('Resources')}</NavbarTrigger>
           <NavbarContent data-testid="navbar-content-resources">
             <ul className="lg:p-4">
+              {EXPLORER_LINK && (
+                <NavbarSubItem>
+                  <NavbarLinkExternal to={EXPLORER_LINK}>
+                    {t('Explorer')}
+                  </NavbarLinkExternal>
+                </NavbarSubItem>
+              )}
               {DocsLinks?.NEW_TO_VEGA && (
                 <NavbarSubItem>
                   <NavbarLinkExternal to={DocsLinks?.NEW_TO_VEGA}>

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

@@ -98,6 +98,7 @@ describe('ActiveRewards', () => {
         transferNode={mockTransferNode}
         currentEpoch={1}
         kind={mockRecurringTransfer}
+        allMarkets={{}}
       />
     );
 

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

@@ -1,48 +1,46 @@
-import {
-  useActiveRewardsQuery,
-  useMarketForRewardsQuery,
-} from './__generated__/Rewards';
+import { useActiveRewardsQuery } from './__generated__/Rewards';
 import { useT } from '../../lib/use-t';
 import { addDecimalsFormatNumber } from '@vegaprotocol/utils';
 import classNames from 'classnames';
 import {
-  Icon,
   type IconName,
+  type VegaIconSize,
+  Icon,
   Intent,
   Tooltip,
   VegaIcon,
   VegaIconNames,
-  type VegaIconSize,
   TradingInput,
   TinyScroll,
 } from '@vegaprotocol/ui-toolkit';
 import { IconNames } from '@blueprintjs/icons';
 import {
+  type Maybe,
+  type Transfer,
+  type TransferNode,
+  type RecurringTransfer,
   DistributionStrategyDescriptionMapping,
   DistributionStrategyMapping,
   EntityScope,
   EntityScopeMapping,
-  type Maybe,
-  type Transfer,
-  type TransferNode,
   TransferStatus,
   TransferStatusMapping,
   DispatchMetric,
   DispatchMetricDescription,
   DispatchMetricLabels,
-  type RecurringTransfer,
   EntityScopeLabelMapping,
+  MarketState,
 } from '@vegaprotocol/types';
 import { Card } from '../card/card';
 import { useMemo, useState } from 'react';
 import {
   type AssetFieldsFragment,
-  useAssetDataProvider,
   useAssetsMapProvider,
 } from '@vegaprotocol/assets';
 import {
   type MarketFieldsFragment,
   useMarketsMapProvider,
+  getAsset,
 } from '@vegaprotocol/markets';
 
 export type Filter = {
@@ -74,7 +72,7 @@ export const isActiveReward = (node: TransferNode, currentEpoch: number) => {
 export const applyFilter = (
   node: TransferNode & {
     asset?: AssetFieldsFragment | null;
-    marketIds?: (MarketFieldsFragment | null)[];
+    markets?: (MarketFieldsFragment | null)[];
   },
   filter: Filter
 ) => {
@@ -85,6 +83,7 @@ export const applyFilter = (
   ) {
     return false;
   }
+
   if (
     DispatchMetricLabels[transfer.kind.dispatchStrategy.dispatchMetric]
       .toLowerCase()
@@ -98,7 +97,7 @@ export const applyFilter = (
     node.asset?.name
       .toLocaleLowerCase()
       .includes(filter.searchTerm.toLowerCase()) ||
-    node.marketIds?.some((m) =>
+    node.markets?.some((m) =>
       m?.tradableInstrument?.instrument?.name
         .toLocaleLowerCase()
         .includes(filter.searchTerm.toLowerCase())
@@ -124,7 +123,7 @@ export const ActiveRewards = ({ currentEpoch }: { currentEpoch: number }) => {
   const { data: assets } = useAssetsMapProvider();
   const { data: markets } = useMarketsMapProvider();
 
-  const transfers = activeRewardsData?.transfersConnection?.edges
+  const enrichedTransfers = activeRewardsData?.transfersConnection?.edges
     ?.map((e) => e?.node as TransferNode)
     .filter((node) => isActiveReward(node, currentEpoch))
     .map((node) => {
@@ -138,19 +137,19 @@ export const ActiveRewards = ({ currentEpoch }: { currentEpoch: number }) => {
           node.transfer.kind.dispatchStrategy?.dispatchMetricAssetId || ''
         ];
 
-      const marketIds =
+      const marketsInScope =
         node.transfer.kind.dispatchStrategy?.marketIdsInScope?.map(
           (id) => markets && markets[id]
         );
 
-      return { ...node, asset, marketIds };
+      return { ...node, asset, markets: marketsInScope };
     });
 
-  if (!transfers || !transfers.length) return null;
+  if (!enrichedTransfers || !enrichedTransfers.length) return null;
 
   return (
     <Card title={t('Active rewards')} className="lg:col-span-full">
-      {transfers.length > 1 && (
+      {enrichedTransfers.length > 1 && (
         <TradingInput
           onChange={(e) =>
             setFilter((curr) => ({ ...curr, searchTerm: e.target.value }))
@@ -166,7 +165,7 @@ export const ActiveRewards = ({ currentEpoch }: { currentEpoch: number }) => {
         />
       )}
       <TinyScroll className="grid gap-x-8 gap-y-10 h-fit grid-cols-[repeat(auto-fill,_minmax(230px,_1fr))] md:grid-cols-[repeat(auto-fill,_minmax(230px,_1fr))] lg:grid-cols-[repeat(auto-fill,_minmax(320px,_1fr))] xl:grid-cols-[repeat(auto-fill,_minmax(335px,_1fr))] max-h-[40rem] overflow-auto pr-2">
-        {transfers
+        {enrichedTransfers
           .filter((n) => applyFilter(n, filter))
           .map((node, i) => {
             const { transfer } = node;
@@ -184,6 +183,7 @@ export const ActiveRewards = ({ currentEpoch }: { currentEpoch: number }) => {
                   transferNode={node}
                   kind={transfer.kind}
                   currentEpoch={currentEpoch}
+                  allMarkets={markets || {}}
                 />
               )
             );
@@ -207,14 +207,8 @@ const StatusIndicator = ({
     switch (status) {
       case TransferStatus.STATUS_DONE:
         return { icon: IconNames.TICK_CIRCLE, intent: Intent.Success };
-      case TransferStatus.STATUS_CANCELLED:
-        return { icon: IconNames.MOON, intent: Intent.None };
-      case TransferStatus.STATUS_PENDING:
-        return { icon: IconNames.HELP, intent: Intent.Primary };
       case TransferStatus.STATUS_REJECTED:
         return { icon: IconNames.ERROR, intent: Intent.Danger };
-      case TransferStatus.STATUS_STOPPED:
-        return { icon: IconNames.ERROR, intent: Intent.Danger };
       default:
         return { icon: IconNames.HELP, intent: Intent.Primary };
     }
@@ -253,49 +247,117 @@ export const ActiveRewardCard = ({
   transferNode,
   currentEpoch,
   kind,
+  allMarkets,
 }: {
-  transferNode: TransferNode;
+  transferNode: TransferNode & {
+    asset?: AssetFieldsFragment | null;
+    markets?: (MarketFieldsFragment | null)[];
+  };
   currentEpoch: number;
   kind: RecurringTransfer;
+  allMarkets?: Record<string, MarketFieldsFragment | null>;
 }) => {
   const t = useT();
 
   const { transfer } = transferNode;
   const { dispatchStrategy } = kind;
-  const marketIds = dispatchStrategy?.marketIdsInScope;
 
-  const { data: marketNameData } = useMarketForRewardsQuery({
-    variables: {
-      marketId: marketIds ? marketIds[0] : '',
-    },
-  });
+  const marketIdsInScope = dispatchStrategy?.marketIdsInScope;
+  const firstMarketData = transferNode.markets?.[0];
 
-  const marketName = useMemo(() => {
-    if (marketNameData && marketIds && marketIds.length > 1) {
-      return 'Specific markets';
-    } else if (
-      marketNameData &&
-      marketIds &&
-      marketNameData &&
-      marketIds.length === 1
+  const specificMarkets = useMemo(() => {
+    if (
+      !firstMarketData ||
+      !marketIdsInScope ||
+      marketIdsInScope.length === 0
     ) {
-      return marketNameData?.market?.tradableInstrument?.instrument?.name || '';
+      return null;
     }
-    return '';
-  }, [marketIds, marketNameData]);
+    if (marketIdsInScope.length > 1) {
+      const marketNames =
+        allMarkets &&
+        marketIdsInScope
+          .map((id) => allMarkets[id]?.tradableInstrument?.instrument?.name)
+          .join(', ');
 
-  const { data: dispatchAsset } = useAssetDataProvider(
-    dispatchStrategy?.dispatchMetricAssetId || ''
-  );
+      return (
+        <Tooltip description={marketNames}>
+          <span>Specific markets</span>
+        </Tooltip>
+      );
+    }
+    return (
+      <span>{firstMarketData?.tradableInstrument?.instrument?.name || ''}</span>
+    );
+  }, [firstMarketData, marketIdsInScope, allMarkets]);
+
+  const dispatchAsset = transferNode.asset;
 
   if (!dispatchStrategy) {
     return null;
   }
 
-  const { gradientClassName, mainClassName } = getGradientClasses(
-    dispatchStrategy.dispatchMetric
+  // Gray out/hide the cards that are related to not trading markets
+  const marketSettled = transferNode.markets?.some(
+    (m) =>
+      m?.state &&
+      [
+        MarketState.STATE_TRADING_TERMINATED,
+        MarketState.STATE_SETTLED,
+        MarketState.STATE_CANCELLED,
+        MarketState.STATE_CLOSED,
+      ].includes(m.state)
   );
 
+  const assetInSettledMarket =
+    allMarkets &&
+    Object.values(allMarkets).some((m: MarketFieldsFragment | null) => {
+      if (m && getAsset(m).id === dispatchStrategy.dispatchMetricAssetId) {
+        return (
+          m?.state &&
+          [
+            MarketState.STATE_TRADING_TERMINATED,
+            MarketState.STATE_SETTLED,
+            MarketState.STATE_CANCELLED,
+            MarketState.STATE_CLOSED,
+          ].includes(m.state)
+        );
+      }
+      return false;
+    });
+
+  if (marketSettled) {
+    return null;
+  }
+
+  // Gray out the cards that are related to suspended markets
+  const suspended = transferNode.markets?.some(
+    (m) =>
+      m?.state === MarketState.STATE_SUSPENDED ||
+      m?.state === MarketState.STATE_SUSPENDED_VIA_GOVERNANCE
+  );
+
+  const assetInSuspendedMarket =
+    allMarkets &&
+    Object.values(allMarkets).some((m: MarketFieldsFragment | null) => {
+      if (m && getAsset(m).id === dispatchStrategy.dispatchMetricAssetId) {
+        return (
+          m?.state === MarketState.STATE_SUSPENDED ||
+          m?.state === MarketState.STATE_SUSPENDED_VIA_GOVERNANCE
+        );
+      }
+      return false;
+    });
+
+  // Gray out the cards that are related to suspended markets
+  const { gradientClassName, mainClassName } =
+    suspended || assetInSuspendedMarket || assetInSettledMarket
+      ? {
+          gradientClassName: 'from-vega-cdark-500 to-vega-clight-400',
+          mainClassName: 'from-vega-cdark-400 dark:from-vega-cdark-600 to-20%',
+        }
+      : getGradientClasses(dispatchStrategy.dispatchMetric);
+
   const entityScope = dispatchStrategy.entityScope;
   return (
     <div>
@@ -373,8 +435,20 @@ export const ActiveRewardCard = ({
 
           <span className="border-[0.5px] border-gray-700" />
           <span>
-            {DispatchMetricLabels[dispatchStrategy.dispatchMetric]}
-            {marketName ? ` • ${marketName}` : ` • ${dispatchAsset?.name}`}
+            {DispatchMetricLabels[dispatchStrategy.dispatchMetric]} •{' '}
+            <Tooltip
+              underline={suspended}
+              description={
+                (suspended || assetInSuspendedMarket) &&
+                (specificMarkets
+                  ? t('Eligible market(s) currently suspended')
+                  : assetInSuspendedMarket
+                  ? t('Currently no markets eligible for reward')
+                  : '')
+              }
+            >
+              <span>{specificMarkets || dispatchAsset?.name}</span>
+            </Tooltip>
           </span>
 
           <div className="flex items-center gap-8 flex-wrap">

apps/trading/e2e/tests/get_started/test_get_started.py

@@ -10,15 +10,18 @@ import logging
 
 logger = logging.getLogger()
 
+
 @pytest.fixture(scope="class")
 def vega():
     with init_vega() as vega:
         yield vega
 
+
 @pytest.fixture(scope="class")
 def simple_market(vega: VegaServiceNull):
     return setup_simple_market(vega)
 
+
 class TestGetStarted:
     def test_get_started_interactive(self, vega: VegaServiceNull, page: Page):
         page.goto("/")
@@ -30,7 +33,8 @@ class TestGetStarted:
         expect(page.locator(".list-none")).to_contain_text(
             "1.Connect2.Deposit funds3.Open a position"
         )
-        DEFAULT_WALLET_NAME = "MarketSim"  # This is the default wallet name within VegaServiceNull and CANNOT be changed
+        # This is the default wallet name within VegaServiceNull and CANNOT be changed
+        DEFAULT_WALLET_NAME = "MarketSim"
 
         # Calling get_keypairs will internally call _load_tokens for the given wallet
         keypairs = vega.wallet.get_keypairs(DEFAULT_WALLET_NAME)
@@ -137,7 +141,8 @@ class TestGetStarted:
     def test_get_started_seen_already(self, simple_market, page: Page):
         page.goto(f"/#/markets/{simple_market}")
         get_started_locator = page.get_by_test_id("connect-vega-wallet")
-        page.wait_for_selector('[data-testid="connect-vega-wallet"]', state="attached")
+        page.wait_for_selector(
+            '[data-testid="connect-vega-wallet"]', state="attached")
         expect(get_started_locator).to_be_enabled
         expect(get_started_locator).to_be_visible
         # 0007-FUGS-015

apps/trading/e2e/tests/market/test_market_info.py

@@ -36,16 +36,19 @@ def validate_info_section(page: Page, fields: [[str, str]]):
     for rowNumber, field in enumerate(fields):
         name, value = field
         expect(
-            page.get_by_test_id("key-value-table-row").nth(rowNumber).locator("dt")
+            page.get_by_test_id(
+                "key-value-table-row").nth(rowNumber).locator("dt")
         ).to_contain_text(name)
         expect(
-            page.get_by_test_id("key-value-table-row").nth(rowNumber).locator("dd")
+            page.get_by_test_id(
+                "key-value-table-row").nth(rowNumber).locator("dd")
         ).to_contain_text(value)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_current_fees(page: Page):
     # 6002-MDET-101
-    page.get_by_test_id(market_title_test_id).get_by_text("Current fees").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Current fees").click()
     fields = [
         ["Maker Fee", "10%"],
         ["Infrastructure Fee", "0.05%"],
@@ -54,10 +57,11 @@ def test_market_info_current_fees(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_market_price(page: Page):
     # 6002-MDET-102
-    page.get_by_test_id(market_title_test_id).get_by_text("Market price").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Market price").click()
     fields = [
         ["Mark Price", "107.50"],
         ["Best Bid Price", "101.50"],
@@ -66,10 +70,11 @@ def test_market_info_market_price(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_market_volume(page: Page):
     # 6002-MDET-103
-    page.get_by_test_id(market_title_test_id).get_by_text("Market volume").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Market volume").click()
     fields = [
         ["24 Hour Volume", "-"],
         ["Open Interest", "1"],
@@ -80,17 +85,19 @@ def test_market_info_market_volume(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_insurance_pool(page: Page):
     # 6002-MDET-104
-    page.get_by_test_id(market_title_test_id).get_by_text("Insurance pool").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Insurance pool").click()
     fields = [["Balance", "0.00 tDAI"]]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_key_details(page: Page, vega: VegaServiceNull):
     # 6002-MDET-201
-    page.get_by_test_id(market_title_test_id).get_by_text("Key details").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Key details").click()
     market_id = vega.find_market_id("BTC:DAI_2023")
     short_market_id = market_id[:6] + "…" + market_id[-4:]
     fields = [
@@ -106,7 +113,7 @@ def test_market_info_key_details(page: Page, vega: VegaServiceNull):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_instrument(page: Page):
     # 6002-MDET-202
     page.get_by_test_id(market_title_test_id).get_by_text("Instrument").click()
@@ -121,7 +128,7 @@ def test_market_info_instrument(page: Page):
 
 # @pytest.mark.skip("oracle test to be fixed")
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_oracle(page: Page):
     # 6002-MDET-203
     page.get_by_test_id(market_title_test_id).get_by_text("Oracle").click()
@@ -135,10 +142,11 @@ def test_market_info_oracle(page: Page):
     #     "href", re.compile(rf'(\/oracles\/{vega.find_market_id("BTC:DAI_2023")})')
     # )
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_settlement_asset(page: Page, vega: VegaServiceNull):
     # 6002-MDET-206
-    page.get_by_test_id(market_title_test_id).get_by_text("Settlement asset").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Settlement asset").click()
     tdai_id = vega.find_asset_id("tDAI")
     tdai_id_short = tdai_id[:6] + "…" + tdai_id[-4:]
     fields = [
@@ -155,7 +163,7 @@ def test_market_info_settlement_asset(page: Page, vega: VegaServiceNull):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_metadata(page: Page):
     # 6002-MDET-207
     page.get_by_test_id(market_title_test_id).get_by_text("Metadata").click()
@@ -164,7 +172,7 @@ def test_market_info_metadata(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_risk_model(page: Page):
     # 6002-MDET-208
     page.get_by_test_id(market_title_test_id).get_by_text("Risk model").click()
@@ -175,7 +183,7 @@ def test_market_info_risk_model(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_margin_scaling_factors(page: Page):
     # 6002-MDET-209
     page.get_by_test_id(market_title_test_id).get_by_text(
@@ -183,17 +191,17 @@ def test_market_info_margin_scaling_factors(page: Page):
     ).click()
     fields = [
         ["Linear Slippage Factor", "0.001"],
-        ["Quadratic Slippage Factor", "0"],
         ["Search Level", "1.1"],
         ["Initial Margin", "1.5"],
         ["Collateral Release", "1.7"],
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_risk_factors(page: Page):
     # 6002-MDET-210
-    page.get_by_test_id(market_title_test_id).get_by_text("Risk factors").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Risk factors").click()
     fields = [
         ["Long", "0.05153"],
         ["Short", "0.05422"],
@@ -204,7 +212,7 @@ def test_market_info_risk_factors(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_price_monitoring_bounds(page: Page):
     # 6002-MDET-211
     page.get_by_test_id(market_title_test_id).get_by_text(
@@ -213,27 +221,27 @@ def test_market_info_price_monitoring_bounds(page: Page):
     expect(page.locator("p.col-span-1").nth(0)).to_contain_text(
         "99.9999% probability price bounds"
     )
-    expect(page.locator("p.col-span-1").nth(1)).to_contain_text("Within 86,400 seconds")
+    expect(page.locator("p.col-span-1").nth(1)
+           ).to_contain_text("Within 86,400 seconds")
     fields = [
         ["Highest Price", "138.66685 BTC"],
         ["Lowest Price", "83.11038 BTC"],
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_liquidity_monitoring_parameters(page: Page):
     # 6002-MDET-212
     page.get_by_test_id(market_title_test_id).get_by_text(
         "Liquidity monitoring parameters"
     ).click()
     fields = [
-        ["Triggering Ratio", "0.7"],
         ["Time Window", "3,600"],
         ["Scaling Factor", "1"],
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 # Liquidity resolves to 3 results
 def test_market_info_liquidit(page: Page):
     # 6002-MDET-213
@@ -246,7 +254,7 @@ def test_market_info_liquidit(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_liquidity_price_range(page: Page):
     # 6002-MDET-214
     page.get_by_test_id(market_title_test_id).get_by_text(
@@ -259,19 +267,22 @@ def test_market_info_liquidity_price_range(page: Page):
     ]
     validate_info_section(page, fields)
 
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_proposal(page: Page, vega: VegaServiceNull):
     # 6002-MDET-301
     page.get_by_test_id(market_title_test_id).get_by_text("Proposal").click()
     first_link = (
-        page.get_by_test_id("accordion-content").get_by_test_id("external-link").first
+        page.get_by_test_id(
+            "accordion-content").get_by_test_id("external-link").first
     )
     second_link = (
-        page.get_by_test_id("accordion-content").get_by_test_id("external-link").nth(1)
+        page.get_by_test_id(
+            "accordion-content").get_by_test_id("external-link").nth(1)
     )
     expect(first_link).to_have_text("View governance proposal")
     expect(first_link).to_have_attribute(
-        "href", re.compile(rf'(\/proposals\/{vega.find_market_id("BTC:DAI_2023")})')
+        "href", re.compile(
+            rf'(\/proposals\/{vega.find_market_id("BTC:DAI_2023")})')
     )
     expect(second_link).to_have_text("Propose a change to market")
 
@@ -280,13 +291,14 @@ def test_market_info_proposal(page: Page, vega: VegaServiceNull):
         "href", re.compile(r"(\/proposals\/propose\/update-market)")
     )
 
-    
-@pytest.mark.skip("tbd-market-sim")
+
 def test_market_info_succession_line(page: Page, vega: VegaServiceNull):
-    page.get_by_test_id(market_title_test_id).get_by_text("Succession line").click()
+    page.get_by_test_id(market_title_test_id).get_by_text(
+        "Succession line").click()
     market_id = vega.find_market_id("BTC:DAI_2023")
     succession_line = page.get_by_test_id("succession-line-item")
-    expect(succession_line.get_by_test_id("external-link")).to_have_text("BTC:DAI_2023")
+    expect(succession_line.get_by_test_id(
+        "external-link")).to_have_text("BTC:DAI_2023")
     expect(succession_line.get_by_test_id("external-link")).to_have_attribute(
         "href", re.compile(rf"(\/proposals\/{market_id})")
     )

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

@@ -0,0 +1,67 @@
+import pytest
+import vega_sim.proto.vega as vega_protos
+from playwright.sync_api import Page, expect
+from vega_sim.null_service import VegaServiceNull
+from actions.utils import next_epoch
+from wallet_config import MM_WALLET, PARTY_A, PARTY_B
+from vega_sim.service import MarketStateUpdateType
+import vega_sim.api.governance as governance
+
+
+@pytest.mark.usefixtures("risk_accepted", "auth")
+def test_filtered_cards(continuous_market, vega: VegaServiceNull, page: Page):
+    tDAI_asset_id = vega.find_asset_id(symbol="tDAI")
+    vega.update_network_parameter(
+        MM_WALLET.name, parameter="reward.asset", new_value=tDAI_asset_id
+    )
+    vega.mint(key_name=PARTY_B.name, asset=tDAI_asset_id, amount=100000)
+    vega.mint(key_name=PARTY_A.name, asset=tDAI_asset_id, amount=100000)
+    next_epoch(vega=vega)
+    vega.recurring_transfer(
+        from_key_name=PARTY_A.name,
+        from_account_type=vega_protos.vega.ACCOUNT_TYPE_GENERAL,
+        to_account_type=vega_protos.vega.ACCOUNT_TYPE_REWARD_MAKER_PAID_FEES,
+        asset=tDAI_asset_id,
+        reference="reward",
+        markets=[continuous_market],
+        asset_for_metric=tDAI_asset_id,
+        metric=vega_protos.vega.DISPATCH_METRIC_MAKER_FEES_PAID,
+        lock_period=5,
+        amount=100,
+        factor=1.0,
+    )
+    vega.submit_order(
+        trading_key=PARTY_B.name,
+        market_id=continuous_market,
+        order_type="TYPE_MARKET",
+        time_in_force="TIME_IN_FORCE_IOC",
+        side="SIDE_BUY",
+        volume=1,
+    )
+    vega.submit_order(
+        trading_key=PARTY_A.name,
+        market_id=continuous_market,
+        order_type="TYPE_MARKET",
+        time_in_force="TIME_IN_FORCE_IOC",
+        side="SIDE_BUY",
+        volume=1,
+    )
+    next_epoch(vega=vega)
+
+    vega.update_market_state(
+        market_id=continuous_market,
+        proposal_key=MM_WALLET.name,
+        market_state=MarketStateUpdateType.Suspend,
+        forward_time_to_enactment=True,
+    )
+    next_epoch(vega=vega)
+    page.goto("/#/rewards")
+    expect(page.locator(".from-vega-cdark-400")).to_be_visible()
+    governance.submit_oracle_data(
+        wallet=vega.wallet,
+        payload={"trading.terminated": "true"},
+        key_name="FJMKnwfZdd48C8NqvYrG",
+    )
+    next_epoch(vega=vega)
+    page.reload()
+    expect(page.locator(".from-vega-cdark-400")).not_to_be_in_viewport()

apps/trading/e2e/tests/successor_market/test_succession_line.py

@@ -8,7 +8,7 @@ from actions.utils import next_epoch
 
 market_banner = "market-banner"
 
-@pytest.mark.skip("tbd")
+
 @pytest.mark.usefixtures("risk_accepted")
 def test_succession_line(vega: VegaServiceNull, page: Page):
     parent_market_id = setup_continuous_market(vega)
@@ -20,12 +20,14 @@ def test_succession_line(vega: VegaServiceNull, page: Page):
     expect(page.get_by_test_id(market_banner)).not_to_be_attached()
 
     successor_name = "successor market name"
-    successor_id = propose_successor(vega, parent_market_id, tdai_id, successor_name)
+    successor_id = propose_successor(
+        vega, parent_market_id, tdai_id, successor_name)
 
     # Check that the banner notifying about the successor proposal is shown
     banner = page.get_by_test_id(market_banner)
     expect(banner).to_be_attached()
-    expect(banner.get_by_text("A successor to this market has been proposed")).to_be_visible()
+    expect(banner.get_by_text(
+        "A successor to this market has been proposed")).to_be_visible()
 
     next_epoch(vega)
 
@@ -45,7 +47,6 @@ def test_succession_line(vega: VegaServiceNull, page: Page):
     # the succession line
     page.reload()
 
-    #tbd issue - 5546
     page.get_by_test_id("Info").click()
 
     page.get_by_role("button", name="Succession line").click()
@@ -78,6 +79,7 @@ def test_succession_line(vega: VegaServiceNull, page: Page):
     page.wait_for_selector('[data-testid="market-banner"]', state="attached")
     expect(banner.get_by_text("This market has been succeeded")).to_be_visible()
 
+
 @pytest.mark.usefixtures("risk_accepted")
 def test_banners(vega: VegaServiceNull, page: Page):
 
@@ -91,9 +93,9 @@ def test_banners(vega: VegaServiceNull, page: Page):
     expect(page.get_by_test_id(market_banner)).not_to_be_attached()
 
     vega.submit_termination_and_settlement_data(
-    settlement_key=GOVERNANCE_WALLET.name,
-    settlement_price=100,
-    market_id=parent_market_id,
+        settlement_key=GOVERNANCE_WALLET.name,
+        settlement_price=100,
+        market_id=parent_market_id,
     )
 
     successor_name = "successor market name"
@@ -108,7 +110,7 @@ def test_banners(vega: VegaServiceNull, page: Page):
     # Check that the banner notifying about the successor proposal and market has been settled are shown still after reload
     page.reload()
     expect(banner.get_by_text(banner_successor_text)).to_be_visible()
-    expect(banner.get_by_text("1/2")).to_be_visible() 
+    expect(banner.get_by_text("1/2")).to_be_visible()
     # Check that the banner notifying about the successor proposal is not visible after close those banners
     banner.get_by_test_id("icon-cross").click()
     expect(banner.get_by_text("This market has been settled")).to_be_visible()
@@ -119,7 +121,8 @@ def test_banners(vega: VegaServiceNull, page: Page):
     expect(page.get_by_test_id(market_banner)).not_to_be_attached()
     page.reload()
     expect(banner).to_be_attached()
-    expect(banner.get_by_text(banner_successor_text)).to_be_visible() 
+    expect(banner.get_by_text(banner_successor_text)).to_be_visible()
+
 
 def propose_successor(
     vega: VegaServiceNull, parent_market_id, tdai_id, market_name
@@ -137,6 +140,7 @@ def propose_successor(
     )
     return market_id
 
+
 def provide_successor_liquidity(
     vega: VegaServiceNull, market_id
 ):

apps/trading/lib/hooks/use-wallet-disconnected-toasts.tsx

@@ -1,62 +0,0 @@
-import {
-  Intent,
-  useToasts,
-  ToastHeading,
-  CLOSE_AFTER,
-} from '@vegaprotocol/ui-toolkit';
-import { useVegaWallet } from '@vegaprotocol/wallet';
-import { useEffect, useMemo } from 'react';
-import { useT } from '../use-t';
-import { VegaWalletConnectButton } from '../../components/vega-wallet-connect-button';
-
-const WALLET_DISCONNECTED_TOAST_ID = 'WALLET_DISCONNECTED_TOAST_ID';
-
-export const useWalletDisconnectedToasts = () => {
-  const t = useT();
-  const [hasToast, setToast, updateToast] = useToasts((state) => [
-    state.hasToast,
-    state.setToast,
-    state.update,
-  ]);
-  const { isAlive } = useVegaWallet();
-
-  const toast = useMemo(
-    () => ({
-      id: WALLET_DISCONNECTED_TOAST_ID,
-      intent: Intent.Danger,
-      content: (
-        <>
-          <ToastHeading>{t('Wallet connection lost')}</ToastHeading>
-          <p>{t('The connection to the Vega wallet has been lost.')}</p>
-          <p className="mt-2">
-            <VegaWalletConnectButton
-              intent={Intent.Danger}
-              onClick={() => {
-                updateToast(WALLET_DISCONNECTED_TOAST_ID, {
-                  hidden: true,
-                });
-              }}
-            />
-          </p>
-        </>
-      ),
-      onClose: () => {
-        updateToast(WALLET_DISCONNECTED_TOAST_ID, {
-          hidden: true,
-        });
-      },
-      closeAfter: CLOSE_AFTER,
-    }),
-    [t, updateToast]
-  );
-
-  useEffect(() => {
-    if (isAlive === false) {
-      if (hasToast(WALLET_DISCONNECTED_TOAST_ID)) {
-        updateToast(WALLET_DISCONNECTED_TOAST_ID, { hidden: false });
-      } else {
-        setToast(toast);
-      }
-    }
-  }, [hasToast, isAlive, setToast, t, toast, updateToast]);
-};

apps/trading/pages/toasts-manager.tsx

@@ -1,4 +1,4 @@
-import { ToastsContainer, useToasts } from '@vegaprotocol/ui-toolkit';
+import { Intent, ToastsContainer, useToasts } from '@vegaprotocol/ui-toolkit';
 import { useProposalToasts } from '@vegaprotocol/proposals';
 import { useVegaTransactionToasts } from '@vegaprotocol/web3';
 import { useEthereumTransactionToasts } from '@vegaprotocol/web3';
@@ -6,7 +6,26 @@ import { useEthereumWithdrawApprovalsToasts } from '@vegaprotocol/web3';
 import { useReadyToWithdrawalToasts } from '@vegaprotocol/withdraws';
 import { Links } from '../lib/links';
 import { useReferralToasts } from '../client-pages/referrals/hooks/use-referral-toasts';
-import { useWalletDisconnectedToasts } from '../lib/hooks/use-wallet-disconnected-toasts';
+import {
+  useWalletDisconnectToastActions,
+  useWalletDisconnectedToasts,
+} from '@vegaprotocol/web3';
+import { VegaWalletConnectButton } from '../components/vega-wallet-connect-button';
+
+const WalletDisconnectAdditionalContent = () => {
+  const { hideToast } = useWalletDisconnectToastActions();
+  return (
+    <p className="mt-2">
+      <VegaWalletConnectButton
+        intent={Intent.Danger}
+        onClick={() => {
+          // hide toast when clicked on `Connect`
+          hideToast();
+        }}
+      />
+    </p>
+  );
+};
 
 export const ToastsManager = () => {
   useProposalToasts();
@@ -17,7 +36,7 @@ export const ToastsManager = () => {
     withdrawalsLink: Links.PORTFOLIO(),
   });
   useReferralToasts();
-  useWalletDisconnectedToasts();
+  useWalletDisconnectedToasts(<WalletDisconnectAdditionalContent />);
 
   const toasts = useToasts((store) => store.toasts);
   return <ToastsContainer order="desc" toasts={toasts} />;

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

@@ -29,6 +29,7 @@ export const assetsProvider = makeDataProvider<
 >({
   query: AssetsDocument,
   getData,
+  errorPolicy: 'all',
 });
 
 export const assetsMapProvider = makeDerivedDataProvider<

libs/data-provider/src/generic-data-provider.spec.ts

@@ -22,11 +22,9 @@ import {
   type QueryOptions,
   type ApolloClient,
 } from '@apollo/client';
-import { ApolloError } from '@apollo/client';
-import type { GraphQLErrors } from '@apollo/client/errors';
+import { type ApolloError } from '@apollo/client';
 import { GraphQLError } from 'graphql';
 import { type Subscription, type Observable } from 'zen-observable-ts';
-import { waitFor } from '@testing-library/react';
 
 type Item = {
   cursor: string;
@@ -117,24 +115,6 @@ const paginatedSubscribe = makeDataProvider<
   },
 });
 
-const mockErrorPolicyGuard: (errors: GraphQLErrors) => boolean = jest
-  .fn()
-  .mockImplementation(() => true);
-const errorGuardedSubscribe = makeDataProvider<
-  QueryData,
-  Data,
-  SubscriptionData,
-  Delta,
-  Variables
->({
-  query,
-  subscriptionQuery,
-  update,
-  getData,
-  getDelta,
-  errorPolicyGuard: mockErrorPolicyGuard,
-});
-
 const derivedSubscribe = makeDerivedDataProvider(
   [paginatedSubscribe, subscribe],
   combineData,
@@ -404,34 +384,6 @@ describe('data provider', () => {
 
     subscription.unsubscribe();
   });
-
-  it('should retry with ignore error policy if errorPolicyGuard returns true', async () => {
-    const subscription = errorGuardedSubscribe(callback, client, variables);
-    const graphQLError = new GraphQLError(
-      '',
-      undefined,
-      undefined,
-      undefined,
-      ['market', 'data'],
-      undefined,
-      {
-        type: 'Internal',
-      }
-    );
-    const graphQLErrors = [graphQLError];
-    const error = new ApolloError({ graphQLErrors });
-
-    await rejectQuery(error);
-    const data = generateData(0, 5);
-    await resolveQuery({
-      data,
-    });
-    expect(mockErrorPolicyGuard).toHaveBeenNthCalledWith(1, graphQLErrors);
-    await waitFor(() =>
-      expect(getData).toHaveBeenCalledWith({ data }, variables)
-    );
-    subscription.unsubscribe();
-  });
 });
 
 describe('derived data provider', () => {

libs/data-provider/src/generic-data-provider.ts

@@ -9,7 +9,6 @@ import type {
   ApolloQueryResult,
   QueryOptions,
 } from '@apollo/client';
-import type { GraphQLErrors } from '@apollo/client/errors';
 import type { Subscription } from 'zen-observable-ts';
 import isEqualWith from 'lodash/isEqualWith';
 import { isNotFoundGraphQLError } from './helpers';
@@ -161,7 +160,7 @@ interface DataProviderParams<
   resetDelay?: number;
   pollInterval?: number;
   additionalContext?: Record<string, unknown>;
-  errorPolicyGuard?: (graphqlErrors: GraphQLErrors) => boolean;
+  errorPolicy?: ErrorPolicy;
   getQueryVariables?: (variables: Variables) => QueryVariables;
   getSubscriptionVariables?: (
     variables: Variables
@@ -176,7 +175,7 @@ interface DataProviderParams<
  * @param fetchPolicy
  * @param resetDelay
  * @param additionalContext add property to the context of the query, ie. 'isEnlargedTimeout'
- * @param errorPolicyGuard indicate which gql errors can be tolerate
+ * @param errorPolicy Apollos error policy, will be used when querying
  * @returns subscribe function
  */
 function makeDataProviderInternal<
@@ -197,7 +196,7 @@ function makeDataProviderInternal<
   fetchPolicy,
   resetDelay,
   additionalContext,
-  errorPolicyGuard,
+  errorPolicy = 'none',
   getQueryVariables,
   getSubscriptionVariables,
   pollInterval,
@@ -331,20 +330,10 @@ function makeDataProviderInternal<
   const callQuery = (
     pagination?: Pagination,
     policy?: ErrorPolicy
-  ): Promise<ApolloQueryResult<QueryData>> =>
-    client
-      .query<QueryData>(getQueryOptions(pagination, policy))
-      .catch((err) => {
-        if (
-          err.graphQLErrors &&
-          errorPolicyGuard &&
-          errorPolicyGuard(err.graphQLErrors)
-        ) {
-          return callQuery(pagination, 'ignore');
-        } else {
-          throw err;
-        }
-      });
+  ): Promise<ApolloQueryResult<QueryData>> => {
+    const options = getQueryOptions(pagination, policy);
+    return client.query<QueryData>(options);
+  };
 
   const load = async () => {
     if (!pagination) {
@@ -364,7 +353,7 @@ function makeDataProviderInternal<
       }
     }
 
-    const res = await callQuery(paginationVariables);
+    const res = await callQuery(paginationVariables, errorPolicy);
 
     const insertionData = getData(res.data, variables);
     const insertionPageInfo = pagination.getPageInfo(res.data);
@@ -417,12 +406,14 @@ function makeDataProviderInternal<
     const paginationVariables = pagination
       ? { first: pagination.first }
       : undefined;
+
     if (pollInterval) {
-      callWatchQuery();
+      callWatchQuery(paginationVariables, errorPolicy);
       return;
     }
+
     try {
-      onNext(await callQuery(paginationVariables));
+      onNext(await callQuery(paginationVariables, errorPolicy));
     } catch (e) {
       onError(e as Error);
     } finally {

libs/data-provider/src/helpers.ts

@@ -27,10 +27,3 @@ const hasNotFoundGraphQLErrors = (errors: GraphQLErrors, path?: string[]) => {
       (!path || path.every((item, i) => item === e?.path?.[i]))
   );
 };
-
-export const marketDataErrorPolicyGuard = (errors: GraphQLErrors) =>
-  errors.every(
-    (e) =>
-      e.message.match(/no market data for market:/i) ||
-      e.message.match(/Conditions list is empty/)
-  );

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

@@ -131,6 +131,7 @@ export const useEtherscanLink = () => {
 export const CONSOLE_TRANSFER = '#/portfolio/assets/transfer';
 export const CONSOLE_TRANSFER_ASSET =
   '#/portfolio/assets/transfer?assetId=:assetId';
+export const CONSOLE_MARKET_PAGE = '#/markets/:marketId';
 
 // Governance pages
 export const TOKEN_NEW_MARKET_PROPOSAL = '/proposals/propose/new-market';

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

@@ -799,6 +799,8 @@
   "unsupportedVersion": "Looks like you're running an outdated version of GoWallet. You're running {{version}} but {{requiredVersion}} is required.",
   "UpdateAsset": "Update asset",
   "UpdateAssetProposal": "Update asset proposal",
+  "UpdateToMarket": "Update to market ID",
+  "OpenInConsole": "Open in Console",
   "UpdateMarket": "Update market",
   "UpdateMarketProposal": "Update market proposal",
   "UpdateMarketState": "Update market state",

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

@@ -30,6 +30,7 @@
   "How often the quality of liquidity supplied by each liquidity provider is evaluated and the fees arising from that period are earmarked for specific providers. This is a market parameter. ": "How often the quality of liquidity supplied by each liquidity provider is evaluated and the fees arising from that period are earmarked for specific providers. This is a market parameter. ",
   "Instrument": "Instrument",
   "Insurance pool": "Insurance pool",
+  "Insurance Pool Balance": "Insurance Pool Balance",
   "Internal conditions": "Internal conditions",
   "Invalid data source": "Invalid data source",
   "involvedInMarkets_one": "Involved in {{count}} market",

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

@@ -53,7 +53,7 @@
   "Use the Desktop App/CLI": "Use the Desktop App/CLI",
   "User rejected": "User rejected",
   "Vega browser extension not installed": "Vega browser extension not installed",
-  "Vega Wallet <0>full featured<0>": "Vega Wallet <0>full featured<0>",
+  "Vega Wallet <0>full featured</0>": "Vega Wallet <0>full featured</0>",
   "Verifying chain": "Verifying chain",
   "View as party": "View as party",
   "VIEW AS VEGA USER": "VIEW AS VEGA USER",

libs/markets/src/lib/components/market-info/MarketInfo.graphql

@@ -139,7 +139,6 @@ query MarketInfo($marketId: ID!) {
     state
     tradingMode
     linearSlippageFactor
-    quadraticSlippageFactor
     proposal {
       id
       rationale {

libs/markets/src/lib/components/market-info/market-info-data-provider.ts

@@ -1,7 +1,6 @@
 import {
   makeDataProvider,
   makeDerivedDataProvider,
-  marketDataErrorPolicyGuard,
 } from '@vegaprotocol/data-provider';
 import {
   MarketInfoDocument,
@@ -33,7 +32,7 @@ export const marketInfoProvider = makeDataProvider<
 >({
   query: MarketInfoDocument,
   getData,
-  errorPolicyGuard: marketDataErrorPolicyGuard,
+  errorPolicy: 'all',
   pollInterval: 5000,
 });
 

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

@@ -177,7 +177,7 @@ export const InsurancePoolInfoPanel = ({
   return (
     <MarketInfoTable
       data={{
-        balance: account.balance,
+        insurancePoolBalance: account.balance,
       }}
       assetSymbol={asset.symbol}
       decimalPlaces={asset.decimals}
@@ -551,7 +551,6 @@ export const MarginScalingFactorsPanel = ({
 }: MarketInfoProps) => {
   const data = {
     linearSlippageFactor: market.linearSlippageFactor,
-    quadraticSlippageFactor: market.quadraticSlippageFactor,
     searchLevel:
       market.tradableInstrument.marginCalculator?.scalingFactors.searchLevel,
     initialMargin:
@@ -564,7 +563,6 @@ export const MarginScalingFactorsPanel = ({
   const parentData = parentMarket
     ? {
         linearSlippageFactor: parentMarket?.linearSlippageFactor,
-        quadraticSlippageFactor: parentMarket?.quadraticSlippageFactor,
         searchLevel:
           parentMarket?.tradableInstrument.marginCalculator?.scalingFactors
             .searchLevel,

libs/markets/src/lib/components/market-info/market-info.mock.ts

@@ -24,7 +24,6 @@ export const marketInfoQuery = (
         },
       },
       linearSlippageFactor: '0.01',
-      quadraticSlippageFactor: '0.0001',
       marketTimestamps: {
         __typename: 'MarketTimestamps',
         open: '2022-11-15T02:15:24.543614154Z',

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

@@ -1,4 +1,3 @@
-import { marketDataErrorPolicyGuard } from '@vegaprotocol/data-provider';
 import { makeDataProvider } from '@vegaprotocol/data-provider';
 import {
   MarketsDataDocument,
@@ -54,7 +53,7 @@ export const marketsDataProvider = makeDataProvider<
 >({
   query: MarketsDataDocument,
   getData,
-  errorPolicyGuard: marketDataErrorPolicyGuard,
+  errorPolicy: 'all',
 });
 
 type Variables = { marketIds: string[] };
@@ -73,7 +72,7 @@ export const marketsLiveDataProvider = makeDataProvider<
   getData,
   getDelta,
   update,
-  errorPolicyGuard: marketDataErrorPolicyGuard,
+  errorPolicy: 'all',
   getQueryVariables: () => ({}),
   getSubscriptionVariables: ({ marketIds }: Variables) =>
     marketIds.map((marketId) => ({ marketId })),

libs/markets/src/lib/markets-provider.ts

@@ -2,7 +2,6 @@ import { useYesterday } from '@vegaprotocol/react-helpers';
 import {
   makeDataProvider,
   makeDerivedDataProvider,
-  marketDataErrorPolicyGuard,
   useDataProvider,
 } from '@vegaprotocol/data-provider';
 import {
@@ -45,7 +44,7 @@ export const marketsProvider = makeDataProvider<
   query: MarketsDocument,
   getData,
   fetchPolicy: 'cache-first',
-  errorPolicyGuard: marketDataErrorPolicyGuard,
+  errorPolicy: 'all',
 });
 
 export const marketsMapProvider = makeDerivedDataProvider<

libs/proposals/src/lib/proposals-data-provider/Proposals.graphql

@@ -137,7 +137,6 @@ fragment NewMarketFields on NewMarket {
   #   auctionExtensionSecs
   # }
   # linearSlippageFactor
-  # quadraticSlippageFactor
   successorConfiguration {
     parentMarketId
   }

libs/proposals/src/lib/proposals-data-provider/proposals-data-provider.tsx

@@ -39,8 +39,7 @@ export const proposalsDataProvider = makeDataProvider<
    *
    * GQL Path: `terms.change.instrument.futureProduct.settlementAsset`
    */
-  errorPolicyGuard: (errors) =>
-    errors.every((e) => e.message.match(/failed to get asset for ID/)),
+  errorPolicy: 'all',
 });
 
 const ProposalTypeMap: Record<

libs/trading-view/.eslintrc.json

@@ -1,6 +1,6 @@
 {
   "extends": ["plugin:@nx/react", "../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*", "__generated__"],
+  "ignorePatterns": ["!**/*", "__generated__", "charting-library.d.ts"],
   "overrides": [
     {
       "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],

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

@@ -9,17 +9,17 @@ export const TradingViewContainer = ({
   libraryHash,
   marketId,
   interval,
-  studies,
   onIntervalChange,
   onAutoSaveNeeded,
+  state,
 }: {
   libraryPath: string;
   libraryHash: string;
   marketId: string;
   interval: ResolutionString;
-  studies: string[];
   onIntervalChange: (interval: string) => void;
   onAutoSaveNeeded: OnAutoSaveNeededCallback;
+  state: object | undefined;
 }) => {
   const t = useT();
   const scriptState = useScript(
@@ -48,9 +48,9 @@ export const TradingViewContainer = ({
       libraryPath={libraryPath}
       marketId={marketId}
       interval={interval}
-      studies={studies}
       onIntervalChange={onIntervalChange}
       onAutoSaveNeeded={onAutoSaveNeeded}
+      state={state}
     />
   );
 };

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

@@ -1,127 +1,167 @@
 import { useEffect, useRef } from 'react';
 import {
+  usePrevious,
   useScreenDimensions,
   useThemeSwitcher,
 } from '@vegaprotocol/react-helpers';
 import { useLanguage } from './use-t';
 import { useDatafeed } from './use-datafeed';
 import { type ResolutionString } from './constants';
+import {
+  type ChartingLibraryFeatureset,
+  type LanguageCode,
+  type ChartingLibraryWidgetOptions,
+  type IChartingLibraryWidget,
+  type ChartPropertiesOverrides,
+  type ResolutionString as TVResolutionString,
+} from '../charting-library';
 
-export type OnAutoSaveNeededCallback = (data: { studies: string[] }) => void;
+const noop = () => {};
+
+export type OnAutoSaveNeededCallback = (data: object) => void;
 
 export const TradingView = ({
   marketId,
   libraryPath,
   interval,
-  studies,
   onIntervalChange,
   onAutoSaveNeeded,
+  state,
 }: {
   marketId: string;
   libraryPath: string;
   interval: ResolutionString;
-  studies: string[];
   onIntervalChange: (interval: string) => void;
   onAutoSaveNeeded: OnAutoSaveNeededCallback;
+  state: object | undefined;
 }) => {
   const { isMobile } = useScreenDimensions();
   const { theme } = useThemeSwitcher();
   const language = useLanguage();
-  const chartContainerRef =
-    useRef<HTMLDivElement>() as React.MutableRefObject<HTMLInputElement>;
-  // Cant get types as charting_library is externally loaded
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const widgetRef = useRef<any>();
+  const chartContainerRef = useRef<HTMLDivElement>(null);
+  const widgetRef = useRef<IChartingLibraryWidget>();
 
   const datafeed = useDatafeed();
 
-  useEffect(
-    () => {
-      const disableOnSmallScreens = isMobile ? ['left_toolbar'] : [];
+  const prevMarketId = usePrevious(marketId);
+  const prevTheme = usePrevious(theme);
 
-      const overrides = getOverrides(theme);
-
-      const widgetOptions = {
-        symbol: marketId,
-        datafeed,
-        interval: interval,
-        container: chartContainerRef.current,
-        library_path: libraryPath,
-        custom_css_url: 'vega_styles.css',
-        // Trading view accepts just 'en' rather than 'en-US' which is what react-i18next provides
-        // https://www.tradingview.com/charting-library-docs/latest/core_concepts/Localization?_highlight=language#supported-languages
-        locale: language.split('-')[0],
-        enabled_features: ['tick_resolution'],
-        disabled_features: [
-          'header_symbol_search',
-          'header_compare',
-          'show_object_tree',
-          'timeframes_toolbar',
-          ...disableOnSmallScreens,
-        ],
-        fullscreen: false,
-        autosize: true,
-        theme,
-        overrides,
-        loading_screen: {
-          backgroundColor: overrides['paneProperties.background'],
-        },
-      };
-
-      // @ts-ignore parent component loads TradingView onto window obj
-      widgetRef.current = new window.TradingView.widget(widgetOptions);
-
-      widgetRef.current.onChartReady(() => {
-        widgetRef.current.applyOverrides(getOverrides(theme));
-
-        widgetRef.current.subscribe('onAutoSaveNeeded', () => {
-          const studies = widgetRef.current
-            .activeChart()
-            .getAllStudies()
-            .map((s: { id: string; name: string }) => s.name);
-          onAutoSaveNeeded({ studies });
-        });
-
-        const activeChart = widgetRef.current.activeChart();
-
-        // Show volume study by default, second bool arg adds it as a overlay on top of the chart
-        studies.forEach((study) => {
-          activeChart.createStudy(study);
-        });
-
-        // Subscribe to interval changes so it can be persisted in chart settings
-        activeChart.onIntervalChanged().subscribe(null, onIntervalChange);
-      });
-
-      return () => {
-        if (!widgetRef.current) return;
-        widgetRef.current.remove();
-      };
-    },
-
-    // No theme in deps to avoid full chart reload when the theme changes
-    // Instead the theme is changed programmitcally in a separate useEffect
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [datafeed, marketId, language, libraryPath, isMobile]
-  );
-
-  // Update the trading view theme every time the app theme updates, doen separately
-  // to avoid full chart reload
   useEffect(() => {
-    if (!widgetRef.current || !widgetRef.current._ready) return;
+    // Widget already created
+    if (widgetRef.current !== undefined) {
+      // Update the symbol if changed
+      if (marketId !== prevMarketId) {
+        widgetRef.current.setSymbol(
+          marketId,
+          (interval ? interval : '15') as TVResolutionString,
+          noop
+        );
+      }
 
-    // Calling changeTheme will reset the default dark/light background to the TV default
-    // so we need to re-apply the pane bg override. A promise is also required
-    // https://github.com/tradingview/charting_library/issues/6546#issuecomment-1139517908
-    widgetRef.current.changeTheme(theme).then(() => {
-      widgetRef.current.applyOverrides(getOverrides(theme));
+      // Update theme theme if changed
+      if (theme !== prevTheme) {
+        widgetRef.current.changeTheme(theme).then(() => {
+          if (!widgetRef.current) return;
+          widgetRef.current.applyOverrides(getOverrides(theme));
+        });
+      }
+
+      return;
+    }
+
+    if (!chartContainerRef.current) {
+      return;
+    }
+
+    // Create widget
+    const overrides = getOverrides(theme);
+
+    const disabledOnSmallScreens: ChartingLibraryFeatureset[] = isMobile
+      ? ['left_toolbar']
+      : [];
+    const disabledFeatures: ChartingLibraryFeatureset[] = [
+      'header_symbol_search',
+      'header_compare',
+      'show_object_tree',
+      'timeframes_toolbar',
+      ...disabledOnSmallScreens,
+    ];
+
+    const widgetOptions: ChartingLibraryWidgetOptions = {
+      symbol: marketId,
+      datafeed,
+      interval: interval as TVResolutionString,
+      container: chartContainerRef.current,
+      library_path: libraryPath,
+      custom_css_url: 'vega_styles.css',
+      // Trading view accepts just 'en' rather than 'en-US' which is what react-i18next provides
+      // https://www.tradingview.com/charting-library-docs/latest/core_concepts/Localization?_highlight=language#supported-languages
+      locale: language.split('-')[0] as LanguageCode,
+      enabled_features: ['tick_resolution'],
+      disabled_features: disabledFeatures,
+      fullscreen: false,
+      autosize: true,
+      theme,
+      overrides,
+      loading_screen: {
+        backgroundColor: overrides['paneProperties.background'],
+      },
+      auto_save_delay: 1,
+      saved_data: state,
+    };
+
+    widgetRef.current = new window.TradingView.widget(widgetOptions);
+
+    widgetRef.current.onChartReady(() => {
+      if (!widgetRef.current) return;
+
+      const activeChart = widgetRef.current.activeChart();
+
+      if (!state) {
+        // If chart has loaded with no state, create a volume study
+        activeChart.createStudy('Volume');
+      }
+
+      // Subscribe to interval changes so it can be persisted in chart settings
+      activeChart.onIntervalChanged().subscribe(null, onIntervalChange);
     });
-  }, [theme]);
+
+    widgetRef.current.subscribe('onAutoSaveNeeded', () => {
+      if (!widgetRef.current) return;
+
+      widgetRef.current.save((newState) => {
+        onAutoSaveNeeded(newState);
+      });
+    });
+  }, [
+    state,
+    datafeed,
+    interval,
+    prevTheme,
+    prevMarketId,
+    marketId,
+    theme,
+    language,
+    libraryPath,
+    isMobile,
+    onAutoSaveNeeded,
+    onIntervalChange,
+  ]);
+
+  useEffect(() => {
+    return () => {
+      if (!widgetRef.current) return;
+      widgetRef.current.remove();
+      widgetRef.current = undefined;
+    };
+  }, []);
 
   return <div ref={chartContainerRef} className="w-full h-full" />;
 };
 
-const getOverrides = (theme: 'dark' | 'light') => {
+const getOverrides = (
+  theme: 'dark' | 'light'
+): Partial<ChartPropertiesOverrides> => {
   return {
     // colors set here, trading view lets the user set a color
     'paneProperties.background': theme === 'dark' ? '#05060C' : '#fff',

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

@@ -2,15 +2,6 @@ import { useEffect, useMemo, useRef } from 'react';
 import compact from 'lodash/compact';
 import { useApolloClient } from '@apollo/client';
 import { type Subscription } from 'zen-observable-ts';
-/*
- * TODO: figure out how we can get the chart types
-import {
-  type LibrarySymbolInfo,
-  type IBasicDataFeed,
-  type ResolutionString,
-  type SeriesFormat,
-} from '../charting_library/charting_library';
-*/
 import {
   GetBarsDocument,
   LastBarDocument,
@@ -27,6 +18,12 @@ import {
   type SymbolQueryVariables,
 } from './__generated__/Symbol';
 import { getMarketExpiryDate, toBigNum } from '@vegaprotocol/utils';
+import {
+  type IBasicDataFeed,
+  type DatafeedConfiguration,
+  type LibrarySymbolInfo,
+  type ResolutionString,
+} from '../charting-library';
 
 const EXCHANGE = 'VEGA';
 
@@ -42,12 +39,8 @@ const resolutionMap: Record<string, Interval> = {
 
 const supportedResolutions = Object.keys(resolutionMap);
 
-const configurationData = {
-  // only showing Vega ofc
-  exchanges: [EXCHANGE],
-
+const configurationData: DatafeedConfiguration = {
   // Represents the resolutions for bars supported by your datafeed
-  // @ts-ignore cant import types as chartin_library is external
   supported_resolutions: supportedResolutions as ResolutionString[],
 } as const;
 
@@ -57,9 +50,7 @@ export const useDatafeed = () => {
   const client = useApolloClient();
 
   const datafeed = useMemo(() => {
-    // @ts-ignore cant import types as chartin_library is external
     const feed: IBasicDataFeed = {
-      // @ts-ignore cant import types as chartin_library is external
       onReady: (callback) => {
         setTimeout(() => callback(configurationData));
       },
@@ -69,11 +60,8 @@ export const useDatafeed = () => {
       },
 
       resolveSymbol: async (
-        // @ts-ignore cant import types as chartin_library is external
         marketId,
-        // @ts-ignore cant import types as chartin_library is external
         onSymbolResolvedCallback,
-        // @ts-ignore cant import types as chartin_library is external
         onResolveErrorCallback
       ) => {
         try {
@@ -110,9 +98,8 @@ export const useDatafeed = () => {
           const expirationDate = getMarketExpiryDate(instrument.metadata.tags);
           const expirationTimestamp = expirationDate
             ? Math.floor(expirationDate.getTime() / 1000)
-            : null;
+            : undefined;
 
-          // @ts-ignore cant import types as chartin_library is external
           const symbolInfo: LibrarySymbolInfo = {
             ticker: market.id, // use ticker as our unique identifier so that code/name can be used for name/description
             name: instrument.code,
@@ -120,10 +107,9 @@ export const useDatafeed = () => {
             description: instrument.name,
             listed_exchange: EXCHANGE,
             expired: productType === 'Perpetual' ? false : true,
-            expirationDate: expirationTimestamp,
+            expiration_date: expirationTimestamp,
 
-            // @ts-ignore cant import types as chartin_library is external
-            format: 'price' as SeriesFormat,
+            format: 'price',
             type,
             session: '24x7',
             timezone: 'Etc/UTC',
@@ -151,15 +137,10 @@ export const useDatafeed = () => {
       },
 
       getBars: async (
-        // @ts-ignore cant import types as chartin_library is external
         symbolInfo,
-        // @ts-ignore cant import types as chartin_library is external
         resolution,
-        // @ts-ignore cant import types as chartin_library is external
         periodParams,
-        // @ts-ignore cant import types as chartin_library is external
         onHistoryCallback,
-        // @ts-ignore cant import types as chartin_library is external
         onErrorCallback
       ) => {
         if (!symbolInfo.ticker) {
@@ -211,13 +192,9 @@ export const useDatafeed = () => {
       },
 
       subscribeBars: (
-        // @ts-ignore cant import types as chartin_library is external
         symbolInfo,
-        // @ts-ignore cant import types as chartin_library is external
         resolution,
-        // @ts-ignore cant import types as chartin_library is external
         onTick
-
         // subscriberUID,  // chart will subscribe and unsbuscribe when the parent market of the page changes so we don't need to use subscriberUID as of now
       ) => {
         if (!symbolInfo.ticker) {

libs/ui-toolkit/src/components/slider/leverage-slider.tsx

@@ -15,8 +15,11 @@ export const LeverageSlider = (
       className="relative flex items-center select-none touch-none h-10 pb-5 w-full"
     >
       <SliderPrimitive.Track className=" relative grow h-[4px]">
-        <span className="bg-vega-clight-500 dark:bg-vega-cdark-500 absolute left-2 right-2 top-0 bottom-0"></span>
-        <span className="block absolute top-[-2px] left-[8px] right-[8px]">
+        <span className="bg-vega-clight-700 dark:bg-vega-cdark-700 absolute left-2 right-2 top-0 bottom-0"></span>
+        <SliderPrimitive.Range className="absolute h-full">
+          <span className="absolute left-2 right-0 h-full bg-vega-clight-100 dark:bg-vega-cdark-100"></span>
+        </SliderPrimitive.Range>
+        <span className="block absolute top-[-3px] left-[8px] right-[8px]">
           {step &&
             new Array(Math.floor(props.max / step) + 1)
               .fill(null)
@@ -34,25 +37,24 @@ export const LeverageSlider = (
                   >
                     <span
                       className={classNames(
-                        'block w-[8px] h-[8px] border-[4px] rotate-45',
+                        'block w-[10px] h-[10px] rounded-full',
                         {
-                          'border-black dark:border-white bg-white dark:bg-white':
-                            !higherThanValue,
-                          'border-vega-clight-500 dark:border-vega-cdark-500 bg-vega-clight-500 dark:bg-vega-cdark-500':
+                          'bg-vega-clight-500 dark:bg-vega-cdark-500':
                             higherThanValue,
+                          'bg-vega-clight-50 dark:bg-vega-cdark-50':
+                            !higherThanValue,
                         }
                       )}
                     ></span>
-                    <span className="text-sm mt-1">{labelValue}x</span>
+                    <span className="text-xs font-alpha mt-1 text-vega-clight-100 dark:text-vega-cdark-100 ">
+                      {labelValue}x
+                    </span>
                   </span>
                 );
               })}
         </span>
-        <SliderPrimitive.Range className="absolute h-full">
-          <span className="absolute left-2 right-0 h-full bg-black dark:bg-white"></span>
-        </SliderPrimitive.Range>
       </SliderPrimitive.Track>
-      <SliderPrimitive.Thumb className="block w-[16px] h-[16px] border-[3px] border-black dark:border-white bg-white dark:bg-black rotate-45 focus-visible:outline-0" />
+      <SliderPrimitive.Thumb className="block w-[18px] h-[18px] border-[2px] rounded-full border-white dark:border-vega-cdark-900 bg-vega-clight-50 dark:bg-vega-cdark-50 focus-visible:outline-0" />
     </SliderPrimitive.Root>
   );
 };

libs/ui-toolkit/src/components/slider/slider.tsx

@@ -40,7 +40,8 @@ export const SliderTrack = ({
   className,
   ...props
 }: SliderTrackProps) => {
-  const defaultStyles = 'bg-black dark:bg-white relative grow h-[3px]';
+  const defaultStyles =
+    'bg-vega-clight-700 dark:bg-vega-cdark-700 relative grow h-[4px]';
   return (
     <SliderPrimitive.Track
       className={classNames(defaultStyles, className)}
@@ -52,7 +53,8 @@ export const SliderTrack = ({
 };
 
 export const SliderRange = ({ className, ...props }: SliderRangeProps) => {
-  const defaultStyles = 'absolute bg-blue h-full';
+  const defaultStyles =
+    'absolute bg-vega-clight-100 dark:bg-vega-cdark-100 h-full';
   return (
     <SliderPrimitive.Range
       className={classNames(defaultStyles, className)}
@@ -63,7 +65,7 @@ export const SliderRange = ({ className, ...props }: SliderRangeProps) => {
 
 export const SliderThumb = ({ className, ...props }: SliderThumbProps) => {
   const defaultStyles =
-    'block w-[20px] h-[20px] border-2 border-black dark:border-white bg-white dark:bg-black rounded-full';
+    'block w-[18px] h-[18px] border-[2px] rounded-full border-white dark:border-vega-cdark-900 bg-vega-clight-50 dark:bg-vega-cdark-50 focus-visible:outline-0';
   return (
     <SliderPrimitive.Thumb
       className={classNames(defaultStyles, className)}

libs/ui-toolkit/src/components/trading-button/trading-button.tsx

@@ -16,6 +16,7 @@ type TradingButtonProps = {
   subLabel?: ReactNode;
   fill?: boolean;
   minimal?: boolean;
+  testId?: string;
 };
 
 const getClassName = (
@@ -120,6 +121,7 @@ export const TradingButton = forwardRef<
       className,
       subLabel,
       fill,
+      testId,
       ...props
     },
     ref
@@ -132,6 +134,7 @@ export const TradingButton = forwardRef<
         { size, subLabel, intent, fill, minimal },
         className
       )}
+      data-testid={testId}
       {...props}
     >
       <Content icon={icon} subLabel={subLabel} children={children} />

libs/utils/src/lib/format/number.spec.ts

@@ -84,6 +84,14 @@ describe('number utils', () => {
     expect(formatNumberPercentage(v, d)).toStrictEqual(o);
   });
 
+  it('formatNumberPercentage returns "-" when value is null', () => {
+    expect(formatNumberPercentage(null)).toStrictEqual('-');
+  });
+
+  it('formatNumberPercentage returns "-" when value is undefined', () => {
+    expect(formatNumberPercentage(undefined)).toStrictEqual('-');
+  });
+
   describe('toNumberParts', () => {
     it.each([
       { v: null, d: 3, o: ['0', '000', '.'] },

libs/utils/src/lib/format/number.ts

@@ -156,7 +156,14 @@ export const addDecimalsFixedFormatNumber = (
   return formatNumberFixed(x, formatDecimals);
 };
 
-export const formatNumberPercentage = (value: BigNumber, decimals?: number) => {
+export const formatNumberPercentage = (
+  value: BigNumber | null | undefined,
+  decimals?: number
+) => {
+  if (!value) {
+    return '-';
+  }
+
   const decimalPlaces =
     typeof decimals === 'undefined' ? value.dp() || 0 : decimals;
   return `${formatNumber(value, decimalPlaces)}%`;

libs/wallet/src/connect-dialog/connect-dialog.spec.tsx

@@ -22,7 +22,7 @@ const mockUpdateDialogOpen = jest.fn();
 const mockCloseVegaDialog = jest.fn();
 
 let mockIsDesktopRunning = true;
-const mockChainId = 'chain-id';
+const mockChainId = 'VEGA_CHAIN_ID';
 
 jest.mock('../use-is-wallet-service-running', () => ({
   useIsWalletServiceRunning: jest
@@ -30,10 +30,6 @@ jest.mock('../use-is-wallet-service-running', () => ({
     .mockImplementation(() => mockIsDesktopRunning),
 }));
 
-jest.mock('./use-chain-id', () => ({
-  useChainId: jest.fn().mockImplementation(() => mockChainId),
-}));
-
 let defaultProps: VegaConnectDialogProps;
 
 const INITIAL_KEY = 'some-key';
@@ -71,6 +67,7 @@ const defaultConfig: VegaWalletConfig = {
     chromeExtensionUrl: 'chrome-link',
     mozillaExtensionUrl: 'mozilla-link',
   },
+  chainId: 'VEGA_CHAIN_ID',
 };
 
 function generateJSX(
@@ -214,7 +211,12 @@ describe('VegaConnectDialog', () => {
         .mockClear()
         .mockImplementation(() =>
           delayedReject(
-            new WalletError('User error', 3001, 'The user rejected the request')
+            new WalletError(
+              'User error',
+              3001,
+              'The user rejected the request'
+            ),
+            delay
           )
         );
 
@@ -323,13 +325,6 @@ describe('VegaConnectDialog', () => {
       render(generateJSX());
       await selectInjected();
 
-      // Chain check
-      expect(screen.getByText('Verifying chain')).toBeInTheDocument();
-      expect(vegaWindow.getChainId).toHaveBeenCalled();
-      await act(async () => {
-        jest.advanceTimersByTime(delay);
-      });
-
       // Await user connect
       expect(screen.getByText('Connecting...')).toBeInTheDocument();
       expect(vegaWindow.connectWallet).toHaveBeenCalled();
@@ -350,43 +345,6 @@ describe('VegaConnectDialog', () => {
       expect(mockCloseVegaDialog).toHaveBeenCalledWith();
     });
 
-    it('handles invalid chain', async () => {
-      const delay = 100;
-      const invalidChain = 'invalid chain';
-      const vegaWindow = {
-        getChainId: jest.fn(() =>
-          delayedResolve({ chainID: invalidChain }, delay)
-        ),
-        connectWallet: jest.fn(() => delayedResolve(null, delay)),
-        disconnectWallet: jest.fn(() => delayedResolve(undefined, delay)),
-        listKeys: jest.fn(() =>
-          delayedResolve(
-            {
-              keys: [{ name: 'test key', publicKey: '0x123' }],
-            },
-            100
-          )
-        ),
-      };
-      mockBrowserWallet(vegaWindow);
-      render(generateJSX());
-      await selectInjected();
-
-      // Chain check
-      expect(screen.getByText('Verifying chain')).toBeInTheDocument();
-      expect(vegaWindow.getChainId).toHaveBeenCalled();
-      await act(async () => {
-        jest.advanceTimersByTime(delay);
-      });
-
-      expect(screen.getByText('Wrong network')).toBeInTheDocument();
-      expect(
-        screen.getByText(
-          new RegExp(`set your wallet network in your app to "${mockChainId}"`)
-        )
-      ).toBeInTheDocument();
-    });
-
     async function selectInjected() {
       expect(await screen.findByRole('dialog')).toBeInTheDocument();
       fireEvent.click(await screen.findByTestId('connector-injected'));

libs/wallet/src/connect-dialog/connect-dialog.tsx

@@ -44,7 +44,6 @@ import { isBrowserWalletInstalled } from '../utils';
 import { useIsWalletServiceRunning } from '../use-is-wallet-service-running';
 import { SnapStatus, useSnapStatus } from '../use-snap-status';
 import { useVegaWalletDialogStore } from './vega-wallet-dialog-store';
-import { useChainId } from './use-chain-id';
 import { useT } from '../use-t';
 import { Trans } from 'react-i18next';
 
@@ -65,7 +64,7 @@ export const VegaConnectDialog = ({
   contentOnly,
   onClose,
 }: VegaConnectDialogProps) => {
-  const { disconnect, acknowledgeNeeded } = useVegaWallet();
+  const { chainId, disconnect, acknowledgeNeeded } = useVegaWallet();
   const vegaWalletDialogOpen = useVegaWalletDialogStore(
     (store) => store.vegaWalletDialogOpen
   );
@@ -85,10 +84,6 @@ export const VegaConnectDialog = ({
     [updateVegaWalletDialog, acknowledgeNeeded, disconnect]
   );
 
-  // Ensure we have a chain Id so we can compare with wallet chain id.
-  // This value will already be in the cache, if it failed the app wont render
-  const chainId = useChainId();
-
   const content = chainId && (
     <ConnectDialogContainer
       connectors={connectors}
@@ -268,7 +263,7 @@ const ConnectorList = ({
             onClick={() => onSelect('injected')}
             title={
               <Trans
-                defaults="Vega Wallet <0>full featured<0>"
+                defaults="Vega Wallet <0>full featured</0>"
                 components={[<span className="text-xs">full featured</span>]}
               />
             }
@@ -281,7 +276,7 @@ const ConnectorList = ({
           <div>
             <h1 className="mb-1 text-lg">
               <Trans
-                defaults="Vega Wallet <0>full featured<0>"
+                defaults="Vega Wallet <0>full featured</0>"
                 components={[<span className="text-xs">full featured</span>]}
               />
             </h1>

libs/wallet/src/connect-dialog/use-chain-id.spec.ts

@@ -1,72 +0,0 @@
-import { renderHook, waitFor } from '@testing-library/react';
-import { useVegaWallet } from '../use-vega-wallet';
-import { useChainId } from './use-chain-id';
-
-global.fetch = jest.fn();
-const mockFetch = global.fetch as jest.Mock;
-mockFetch.mockImplementation((url: string) => {
-  return Promise.resolve({ ok: true });
-});
-
-jest.mock('../use-vega-wallet', () => {
-  const original = jest.requireActual('../use-vega-wallet');
-  return {
-    ...original,
-    useVegaWallet: jest.fn(),
-  };
-});
-
-describe('useChainId', () => {
-  it('does not call fetch when statistics url could not be determined', async () => {
-    (useVegaWallet as jest.Mock).mockReturnValue({
-      vegaUrl: '',
-    });
-    renderHook(() => useChainId());
-    await waitFor(() => {
-      expect(mockFetch).toHaveBeenCalledTimes(0);
-    });
-  });
-
-  it('calls fetch with correct statistics url', async () => {
-    (useVegaWallet as jest.Mock).mockReturnValue({
-      vegaUrl: 'http://localhost:1234/graphql',
-    });
-    renderHook(() => useChainId());
-    await waitFor(() => {
-      expect(mockFetch).toHaveBeenCalledWith(
-        'http://localhost:1234/statistics'
-      );
-    });
-  });
-
-  it('does not return chain id when chain id is not present in response', async () => {
-    (useVegaWallet as jest.Mock).mockReturnValue({
-      vegaUrl: 'http://localhost:1234/graphql',
-    });
-    const { result } = renderHook(() => useChainId());
-    await waitFor(() => {
-      expect(result.current).toBeUndefined();
-    });
-  });
-
-  it('returns chain id when chain id is present in response', async () => {
-    (useVegaWallet as jest.Mock).mockReturnValue({
-      vegaUrl: 'http://localhost:1234/graphql',
-    });
-    mockFetch.mockImplementation(() => {
-      return Promise.resolve({
-        ok: true,
-        json: () => ({
-          statistics: {
-            chainId: '1234',
-          },
-        }),
-      });
-    });
-    const { result } = renderHook(() => useChainId());
-    await waitFor(() => {
-      expect(result.current).not.toBeUndefined();
-      expect(result.current).toEqual('1234');
-    });
-  });
-});

libs/wallet/src/connectors/injected-connector.ts

@@ -1,10 +1,11 @@
 import { clearConfig, setConfig } from '../storage';
 import type { Transaction, VegaConnector } from './vega-connector';
 
+type VegaWalletEvent = 'client.disconnected';
+
 declare global {
   interface Vega {
-    getChainId: () => Promise<{ chainID: string }>;
-    connectWallet: () => Promise<null>;
+    connectWallet: (args: { chainId: string }) => Promise<null>;
     disconnectWallet: () => Promise<void>;
     listKeys: () => Promise<{
       keys: Array<{ name: string; publicKey: string }>;
@@ -34,6 +35,9 @@ declare global {
       };
       transactionHash: string;
     }>;
+
+    on: (event: VegaWalletEvent, callback: () => void) => void;
+    isConnected?: () => Promise<boolean>;
   }
 
   interface Window {
@@ -47,15 +51,60 @@ export const InjectedConnectorErrors = {
   INVALID_CHAIN: new Error('Invalid chain'),
 };
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const wait = (ms: number) =>
+  new Promise<boolean>((_, reject) => {
+    setTimeout(() => {
+      reject(false);
+    }, ms);
+  });
+
+const INJECTED_CONNECTOR_TIMEOUT = 1000;
+
 export class InjectedConnector implements VegaConnector {
+  isConnected = false;
+  chainId: string | null = null;
   description = 'Connects using the Vega wallet browser extension';
+  alive: ReturnType<typeof setInterval> | undefined = undefined;
 
-  async getChainId() {
-    return window.vega.getChainId();
-  }
+  async connectWallet(chainId: string) {
+    this.chainId = chainId;
+    try {
+      await window.vega.connectWallet({ chainId });
+      this.isConnected = true;
+      window.vega.on('client.disconnected', () => {
+        this.isConnected = false;
+      });
 
-  connectWallet() {
-    return window.vega.connectWallet();
+      this.alive = setInterval(async () => {
+        try {
+          const connected = await Promise.race([
+            // FIXME: All of the `window.vega` initiated promises are `pending`
+            // while waiting for the user action when transaction is sent.
+            // (Probably due to the FIFO queue  of the `PortServer`?)
+            // Because of that we cannot `wait` here as while waiting for the
+            // user action in wallet this will `reject`. It'd be cool if the
+            // `window.vega` was not blocking the api calls.
+
+            // wait(INJECTED_CONNECTOR_TIMEOUT),
+
+            // `isConnected` is only available in the newer versions
+            // of the browser wallet
+            'isConnected' in window.vega &&
+            typeof window.vega.isConnected === 'function'
+              ? window.vega.isConnected()
+              : window.vega.listKeys(),
+          ]);
+          this.isConnected = Boolean(connected);
+        } catch {
+          this.isConnected = false;
+        }
+      }, INJECTED_CONNECTOR_TIMEOUT * 2);
+    } catch {
+      throw new Error(
+        `could not connect to the vega wallet on chain: ${chainId}`
+      );
+    }
   }
 
   async connect() {
@@ -69,19 +118,11 @@ export class InjectedConnector implements VegaConnector {
   }
 
   async isAlive() {
-    try {
-      const keys = await window.vega.listKeys();
-      if (keys.keys.length > 0) {
-        return true;
-      }
-    } catch (err) {
-      return false;
-    }
-
-    return false;
+    return this.isConnected;
   }
 
   disconnect() {
+    clearInterval(this.alive);
     clearConfig();
     return window.vega.disconnectWallet();
   }

libs/wallet/src/connectors/vega-connector.ts

@@ -130,6 +130,7 @@ interface ProposalNewMarketTerms {
       decimalPlaces: string;
       positionDecimalPlaces: string;
       linearSlippageFactor: string;
+      // FIXME: workaround because of https://github.com/vegaprotocol/vega/issues/10343
       quadraticSlippageFactor: string;
       instrument: {
         name: string;
@@ -167,6 +168,7 @@ interface ProposalUpdateMarketTerms {
     marketId: string;
     changes: {
       linearSlippageFactor: string;
+      // FIXME: workaround because of https://github.com/vegaprotocol/vega/issues/10343
       quadraticSlippageFactor: string;
       instrument: {
         code: string;

libs/wallet/src/context.ts

@@ -13,6 +13,9 @@ export interface VegaWalletContextShape {
   /** Url of current connected node */
   vegaUrl: string;
 
+  /** Vega chain id */
+  chainId: string;
+
   /** Url of running wallet service */
   vegaWalletServiceUrl: string;
 

libs/wallet/src/index.ts

@@ -7,3 +7,4 @@ export * from './provider';
 export * from './connect-dialog';
 export * from './utils';
 export * from './storage';
+export * from './use-chain-id';

libs/wallet/src/provider.spec.tsx

@@ -22,6 +22,7 @@ const defaultConfig: VegaWalletConfig = {
     chromeExtensionUrl: 'chrome-link',
     mozillaExtensionUrl: 'mozilla-link',
   },
+  chainId: 'VEGA_CHAIN_ID',
 };
 
 const setup = (config?: Partial<VegaWalletConfig>) => {
@@ -68,6 +69,7 @@ describe('VegaWalletProvider', () => {
     expect(result.current).toEqual({
       network: defaultConfig.network,
       vegaUrl: defaultConfig.vegaUrl,
+      chainId: defaultConfig.chainId,
       vegaWalletServiceUrl: defaultConfig.vegaWalletServiceUrl,
       acknowledgeNeeded: false,
       pubKey: null,

libs/wallet/src/provider.tsx

@@ -39,6 +39,7 @@ interface VegaWalletLinks {
 export interface VegaWalletConfig {
   network: Networks;
   vegaUrl: string;
+  chainId: string;
   vegaWalletServiceUrl: string;
   links: VegaWalletLinks;
   keepAlive?: number;
@@ -168,6 +169,7 @@ export const VegaWalletProvider = ({
   const contextValue = useMemo<VegaWalletContextShape>(() => {
     return {
       vegaUrl: config.vegaUrl,
+      chainId: config.chainId,
       vegaWalletServiceUrl: config.vegaWalletServiceUrl,
       network: config.network,
       links: {

libs/wallet/src/test-helpers.ts

@@ -1,6 +1,5 @@
 export function mockBrowserWallet(overrides?: Partial<Vega>) {
   const vega: Vega = {
-    getChainId: jest.fn().mockReturnValue(Promise.resolve({ chainID: '1' })),
     connectWallet: jest.fn().mockReturnValue(Promise.resolve(null)),
     disconnectWallet: jest.fn().mockReturnValue(Promise.resolve()),
     listKeys: jest
@@ -14,6 +13,8 @@ export function mockBrowserWallet(overrides?: Partial<Vega>) {
       success: true,
       txHash: '0x123',
     }),
+    on: jest.fn(),
+    isConnected: jest.fn().mockRejectedValue(Promise.resolve(true)),
     ...overrides,
   };
   // @ts-ignore globalThis has no index signature

libs/wallet/src/use-chain-id.spec.ts

@@ -0,0 +1,100 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { MAX_FETCH_ATTEMPTS, useChainId } from './use-chain-id';
+
+global.fetch = jest.fn();
+const mockFetch = global.fetch as jest.Mock;
+mockFetch.mockImplementation((url: string) => {
+  return Promise.resolve({ ok: true });
+});
+
+describe('useChainId', () => {
+  it('does not call fetch when statistics url could not be determined', async () => {
+    renderHook(() => useChainId(''));
+    await waitFor(() => {
+      expect(mockFetch).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  it('calls fetch with correct statistics url', async () => {
+    renderHook(() => useChainId('http://localhost:1234/graphql'));
+    await waitFor(() => {
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:1234/statistics'
+      );
+    });
+  });
+
+  it('does not return chain id when chain id is not present in response', async () => {
+    const { result } = renderHook(() =>
+      useChainId('http://localhost:1234/graphql')
+    );
+    await waitFor(() => {
+      expect(result.current).toBeUndefined();
+    });
+  });
+
+  it('returns chain id when chain id is present in response', async () => {
+    mockFetch.mockImplementation(() => {
+      return Promise.resolve({
+        ok: true,
+        json: () => ({
+          statistics: {
+            chainId: '1234',
+          },
+        }),
+      });
+    });
+    const { result } = renderHook(() =>
+      useChainId('http://localhost:1234/graphql')
+    );
+    await waitFor(() => {
+      expect(result.current).not.toBeUndefined();
+      expect(result.current).toEqual('1234');
+    });
+  });
+
+  it('returns chain id when within max number of attempts', async () => {
+    mockFetch.mockImplementation(() => {
+      if (mockFetch.mock.calls.length < MAX_FETCH_ATTEMPTS) {
+        return Promise.reject();
+      }
+      return Promise.resolve({
+        ok: true,
+        json: () => ({
+          statistics: {
+            chainId: '1234',
+          },
+        }),
+      });
+    });
+    const { result } = renderHook(() =>
+      useChainId('http://localhost:1234/graphql')
+    );
+    await waitFor(() => {
+      expect(result.current).not.toBeUndefined();
+      expect(result.current).toEqual('1234');
+    });
+  });
+
+  it('does not return chain id when max number of attempts exceeded', async () => {
+    mockFetch.mockImplementation(() => {
+      if (mockFetch.mock.calls.length < MAX_FETCH_ATTEMPTS + 10) {
+        return Promise.reject();
+      }
+      return Promise.resolve({
+        ok: true,
+        json: () => ({
+          statistics: {
+            chainId: '1234',
+          },
+        }),
+      });
+    });
+    const { result } = renderHook(() =>
+      useChainId('http://localhost:5678/graphql')
+    );
+    await waitFor(() => {
+      expect(result.current).toBeUndefined();
+    });
+  });
+});

libs/wallet/src/use-chain-id.ts

@@ -1,5 +1,6 @@
 import { useEffect, useState } from 'react';
-import { useVegaWallet } from '../use-vega-wallet';
+
+export const MAX_FETCH_ATTEMPTS = 3;
 
 const cache: Record<string, string> = {};
 
@@ -18,16 +19,17 @@ const getNodeStatisticsUrl = (vegaUrl: string) => {
   }
 };
 
-export const useChainId = () => {
-  const { vegaUrl } = useVegaWallet();
-  const [chainId, setChainId] = useState<undefined | string>(cache[vegaUrl]);
-  const [fetchAttempt, setFetchAttempt] = useState(1);
+export const useChainId = (vegaUrl: string | undefined) => {
+  const [chainId, setChainId] = useState<undefined | string>(
+    vegaUrl ? cache[vegaUrl] : undefined
+  );
+  const [fetchAttempts, setFetchAttempts] = useState(1);
 
-  const statisticsUrl = getNodeStatisticsUrl(vegaUrl);
+  const statisticsUrl = vegaUrl ? getNodeStatisticsUrl(vegaUrl) : undefined;
 
   useEffect(() => {
     // abort when `/statistics` URL could not be determined
-    if (!statisticsUrl) return;
+    if (!statisticsUrl || !vegaUrl) return;
     let isCancelled = false;
     if (cache[vegaUrl]) {
       setChainId(cache[vegaUrl]);
@@ -42,16 +44,19 @@ export const useChainId = () => {
         if (!response?.statistics?.chainId) {
           throw new Error('statistics.chainId not present in fetched response');
         }
-        setChainId(response?.statistics?.chainId);
+
+        const chainId = response.statistics.chainId;
+        cache[vegaUrl] = chainId;
+        setChainId(chainId);
       })
       .catch(() => {
-        if (fetchAttempt < 3) {
-          setFetchAttempt((value) => (value += 1));
+        if (fetchAttempts < MAX_FETCH_ATTEMPTS) {
+          setFetchAttempts((value) => (value += 1));
         }
       });
     return () => {
       isCancelled = true;
     };
-  }, [fetchAttempt, statisticsUrl, vegaUrl]);
+  }, [fetchAttempts, statisticsUrl, vegaUrl]);
   return chainId;
 };

libs/wallet/src/use-eager-connect.ts

@@ -7,7 +7,7 @@ import { useVegaWallet } from './use-vega-wallet';
 
 export function useEagerConnect(connectors: Connectors) {
   const [connecting, setConnecting] = useState(true);
-  const { vegaUrl, connect, acknowledgeNeeded } = useVegaWallet();
+  const { vegaUrl, chainId, connect, acknowledgeNeeded } = useVegaWallet();
 
   useEffect(() => {
     const attemptConnect = async () => {
@@ -33,7 +33,7 @@ export function useEagerConnect(connectors: Connectors) {
 
       try {
         if (connector instanceof InjectedConnector) {
-          await connector.connectWallet();
+          await connector.connectWallet(chainId);
           await connect(connector);
         } else if (connector instanceof SnapConnector) {
           connector.nodeAddress = new URL(vegaUrl).origin;
@@ -51,7 +51,7 @@ export function useEagerConnect(connectors: Connectors) {
     if (typeof window !== 'undefined') {
       attemptConnect();
     }
-  }, [connect, connectors, acknowledgeNeeded, vegaUrl]);
+  }, [connect, connectors, acknowledgeNeeded, vegaUrl, chainId]);
 
   return connecting;
 }

libs/wallet/src/use-injected-connector.spec.tsx

@@ -16,6 +16,7 @@ const defaultConfig: VegaWalletConfig = {
     chromeExtensionUrl: 'chrome-link',
     mozillaExtensionUrl: 'mozilla-link',
   },
+  chainId: 'VEGA_CHAIN_ID',
 };
 
 const setup = (callback = jest.fn(), config?: Partial<VegaWalletConfig>) => {
@@ -46,20 +47,10 @@ describe('useInjectedConnector', () => {
     expect(result.current.status).toBe(Status.Error);
   });
 
-  it('errors if chain ids dont match', async () => {
-    mockBrowserWallet();
-    const { result } = setup();
-    await act(async () => {
-      result.current.connect(injected, '2'); // default mock chainId is '1'
-    });
-    expect(result.current.error?.message).toBe('Invalid chain');
-    expect(result.current.status).toBe(Status.Error);
-  });
-
   it('errors if connection throws', async () => {
     const callback = jest.fn();
     mockBrowserWallet({
-      getChainId: () => Promise.reject('failed'),
+      connectWallet: jest.fn().mockReturnValue(Promise.reject()),
     });
     const { result } = setup(callback);
 
@@ -67,7 +58,9 @@ describe('useInjectedConnector', () => {
       result.current.connect(injected, '1'); // default mock chainId is '1'
     });
     expect(result.current.status).toBe(Status.Error);
-    expect(result.current.error?.message).toBe('injected connection failed');
+    expect(result.current.error?.message).toBe(
+      'could not connect to the vega wallet on chain: 1'
+    );
   });
 
   it('connects', async () => {
@@ -78,7 +71,6 @@ describe('useInjectedConnector', () => {
     act(() => {
       result.current.connect(injected, '1'); // default mock chainId is '1'
     });
-    expect(result.current.status).toBe(Status.GettingChainId);
 
     await waitFor(() => {
       expect(vega.connectWallet).toHaveBeenCalled();

libs/wallet/src/use-injected-connector.ts

@@ -40,17 +40,19 @@ export const useInjectedConnector = (onConnect: () => void) => {
           connector.nodeAddress = new URL(vegaUrl).origin;
         }
 
-        setStatus(Status.GettingChainId);
-
-        const { chainID } = await connector.getChainId();
-        if (chainID !== appChainId) {
-          throw InjectedConnectorErrors.INVALID_CHAIN;
+        // check the chain id for snap connector
+        if (connector instanceof SnapConnector) {
+          setStatus(Status.GettingChainId);
+          const { chainID } = await connector.getChainId();
+          if (chainID !== appChainId) {
+            throw InjectedConnectorErrors.INVALID_CHAIN;
+          }
         }
 
         setStatus(Status.Connecting);
         if (connector instanceof InjectedConnector) {
           // extra step for injected connector - authorize wallet
-          await connector.connectWallet();
+          await connector.connectWallet(appChainId);
         }
         await connect(connector); // connect with keys
 

libs/web3/src/index.ts

@@ -1,7 +1,11 @@
+export * from './lib/__generated__/TransactionResult';
+export * from './lib/__generated__/WithdrawalApproval';
 export * from './lib/constants';
+export * from './lib/default-web3-provider';
 export * from './lib/eip-1193-custom-bridge';
 export * from './lib/ethereum-error';
 export * from './lib/ethereum-transaction-dialog';
+export * from './lib/types';
 export * from './lib/url-connector';
 export * from './lib/use-bridge-contract';
 export * from './lib/use-eager-connect';
@@ -19,7 +23,12 @@ export * from './lib/use-get-withdraw-delay';
 export * from './lib/use-get-withdraw-threshold';
 export * from './lib/use-token-contract';
 export * from './lib/use-token-decimals';
+export * from './lib/use-transaction-result';
+export * from './lib/use-vega-transaction-manager';
+export * from './lib/use-vega-transaction-store';
 export * from './lib/use-vega-transaction-toasts';
+export * from './lib/use-vega-transaction-updater';
+export * from './lib/use-wallet-disconnected-toasts';
 export * from './lib/use-web3-disconnect';
 export * from './lib/web3-connect-dialog';
 export * from './lib/web3-connect-store';
@@ -27,11 +36,3 @@ export * from './lib/web3-connectors';
 export * from './lib/web3-provider';
 export * from './lib/withdrawal-approval-dialog';
 export * from './lib/withdrawal-approval-status';
-export * from './lib/default-web3-provider';
-export * from './lib/use-vega-transaction-manager';
-export * from './lib/use-vega-transaction-store';
-export * from './lib/use-vega-transaction-updater';
-export * from './lib/use-transaction-result';
-export * from './lib/types';
-export * from './lib/__generated__/TransactionResult';
-export * from './lib/__generated__/WithdrawalApproval';

libs/web3/src/lib/use-wallet-disconnected-toasts.tsx

@@ -0,0 +1,78 @@
+import {
+  Intent,
+  useToasts,
+  ToastHeading,
+  CLOSE_AFTER,
+  type Toast,
+} from '@vegaprotocol/ui-toolkit';
+import { useVegaWallet } from '@vegaprotocol/wallet';
+import { useEffect, useMemo } from 'react';
+import { useT } from './use-t';
+import { usePrevious } from '@vegaprotocol/react-helpers';
+
+export const WALLET_DISCONNECTED_TOAST_ID = 'WALLET_DISCONNECTED_TOAST_ID';
+
+export const useWalletDisconnectToastActions = () => {
+  const [hasToast, updateToast] = useToasts((state) => [
+    state.hasToast,
+    state.update,
+  ]);
+  const hideToast = () => {
+    if (!hasToast(WALLET_DISCONNECTED_TOAST_ID)) return;
+    updateToast(WALLET_DISCONNECTED_TOAST_ID, {
+      hidden: true,
+    });
+  };
+  const showToast = () => {
+    if (!hasToast(WALLET_DISCONNECTED_TOAST_ID)) return;
+    updateToast(WALLET_DISCONNECTED_TOAST_ID, {
+      hidden: false,
+    });
+  };
+  return { showToast, hideToast };
+};
+
+export const useWalletDisconnectedToasts = (
+  additionalContent?: JSX.Element
+) => {
+  const t = useT();
+  const [hasToast, setToast] = useToasts((state) => [
+    state.hasToast,
+    state.setToast,
+    state.update,
+  ]);
+  const { showToast, hideToast } = useWalletDisconnectToastActions();
+
+  const { isAlive } = useVegaWallet();
+  const wasAlive = usePrevious(isAlive);
+  const disconnected = wasAlive && !isAlive;
+
+  const toast: Toast = useMemo(
+    () => ({
+      id: WALLET_DISCONNECTED_TOAST_ID,
+      intent: Intent.Danger,
+      content: (
+        <>
+          <ToastHeading>{t('Wallet connection lost')}</ToastHeading>
+          <p>{t('The connection to the Vega wallet has been lost.')}</p>
+          {additionalContent}
+        </>
+      ),
+      onClose: () => {
+        hideToast();
+      },
+      closeAfter: CLOSE_AFTER,
+    }),
+    [additionalContent, hideToast, t]
+  );
+
+  useEffect(() => {
+    if (disconnected) {
+      if (hasToast(WALLET_DISCONNECTED_TOAST_ID)) {
+        showToast();
+      } else {
+        setToast(toast);
+      }
+    }
+  }, [disconnected, hasToast, isAlive, setToast, showToast, t, toast]);
+};