feat: account hitory poc

apps/token/src/routes/staking/node/__generated___/Staking.ts

@@ -3,14 +3,14 @@ import { Schema as Types } from '@vegaprotocol/types';
 import { gql } from '@apollo/client';
 import * as Apollo from '@apollo/client';
 const defaultOptions = {} as const;
-export type StakingNodeFieldsFragment = { __typename?: 'Node', id: string, name: string, pubkey: string, infoUrl: string, location: string, ethereumAddress: string, stakedByOperator: string, stakedByDelegates: string, stakedTotal: string, pendingStake: string, stakedByOperatorFormatted: string, stakedByDelegatesFormatted: string, stakedTotalFormatted: string, pendingStakeFormatted: string, epochData?: { __typename?: 'EpochData', total: number, offline: number, online: number } | null, rankingScore: { __typename?: 'RankingScore', rankingScore: string, stakeScore: string, performanceScore: string, votingPower: string, status: Types.ValidatorStatus } };
+export type StakingNodeFieldsFragment = { __typename?: 'Node', id: string, name: string, pubkey: string, infoUrl: string, location: string, ethereumAddress: string, stakedByOperator: string, stakedByDelegates: string, stakedTotal: string, pendingStake: string, epochData?: { __typename?: 'EpochData', total: number, offline: number, online: number } | null, rankingScore: { __typename?: 'RankingScore', rankingScore: string, stakeScore: string, performanceScore: string, votingPower: string, status: Types.ValidatorStatus } };
 
 export type StakingQueryVariables = Types.Exact<{
   partyId: Types.Scalars['ID'];
 }>;
 
 
-export type StakingQuery = { __typename?: 'Query', party?: { __typename?: 'Party', id: string, stakingSummary: { __typename?: 'StakingSummary', currentStakeAvailable: string }, delegationsConnection?: { __typename?: 'DelegationsConnection', edges?: Array<{ __typename?: 'DelegationEdge', node: { __typename?: 'Delegation', amount: string, amountFormatted: string, epoch: number, node: { __typename?: 'Node', id: string } } } | null> | null } | null } | null, epoch: { __typename?: 'Epoch', id: string, timestamps: { __typename?: 'EpochTimestamps', start?: string | null, end?: string | null, expiry?: string | null } }, nodesConnection: { __typename?: 'NodesConnection', edges?: Array<{ __typename?: 'NodeEdge', node: { __typename?: 'Node', id: string, name: string, pubkey: string, infoUrl: string, location: string, ethereumAddress: string, stakedByOperator: string, stakedByDelegates: string, stakedTotal: string, pendingStake: string, stakedByOperatorFormatted: string, stakedByDelegatesFormatted: string, stakedTotalFormatted: string, pendingStakeFormatted: string, epochData?: { __typename?: 'EpochData', total: number, offline: number, online: number } | null, rankingScore: { __typename?: 'RankingScore', rankingScore: string, stakeScore: string, performanceScore: string, votingPower: string, status: Types.ValidatorStatus } } } | null> | null }, nodeData?: { __typename?: 'NodeData', stakedTotal: string, stakedTotalFormatted: string, totalNodes: number, inactiveNodes: number, validatingNodes: number, uptime: number } | null };
+export type StakingQuery = { __typename?: 'Query', party?: { __typename?: 'Party', id: string, stakingSummary: { __typename?: 'StakingSummary', currentStakeAvailable: string }, delegationsConnection?: { __typename?: 'DelegationsConnection', edges?: Array<{ __typename?: 'DelegationEdge', node: { __typename?: 'Delegation', amount: string, epoch: number, node: { __typename?: 'Node', id: string } } } | null> | null } | null } | null, epoch: { __typename?: 'Epoch', id: string, timestamps: { __typename?: 'EpochTimestamps', start?: string | null, end?: string | null, expiry?: string | null } }, nodesConnection: { __typename?: 'NodesConnection', edges?: Array<{ __typename?: 'NodeEdge', node: { __typename?: 'Node', id: string, name: string, pubkey: string, infoUrl: string, location: string, ethereumAddress: string, stakedByOperator: string, stakedByDelegates: string, stakedTotal: string, pendingStake: string, epochData?: { __typename?: 'EpochData', total: number, offline: number, online: number } | null, rankingScore: { __typename?: 'RankingScore', rankingScore: string, stakeScore: string, performanceScore: string, votingPower: string, status: Types.ValidatorStatus } } } | null> | null }, nodeData?: { __typename?: 'NodeData', stakedTotal: string, totalNodes: number, inactiveNodes: number, uptime: number } | null };
 
 export const StakingNodeFieldsFragmentDoc = gql`
     fragment StakingNodeFields on Node {

apps/trading/client-pages/portfolio/AccountHistory.graphql

@@ -0,0 +1,24 @@
+query AccountHistory(
+  $partyId: ID!
+  $assetId: ID!
+  $accountTypes: [AccountType!]
+) {
+  balanceChanges(
+    filter: {
+      partyIds: [$partyId]
+      accountTypes: $accountTypes
+      assetId: $assetId
+    }
+  ) {
+    edges {
+      node {
+        timestamp
+        partyId
+        balance
+        marketId
+        assetId
+        accountType
+      }
+    }
+  }
+}

apps/trading/client-pages/portfolio/__generated__/AssetFields.ts

@@ -1,46 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-// @generated
-// This file was automatically generated and should not be edited.
-
-// ====================================================
-// GraphQL fragment: AssetFields
-// ====================================================
-
-export interface AssetFields_source_BuiltinAsset {
-  __typename: "BuiltinAsset";
-}
-
-export interface AssetFields_source_ERC20 {
-  __typename: "ERC20";
-  /**
-   * The address of the ERC20 contract
-   */
-  contractAddress: string;
-}
-
-export type AssetFields_source = AssetFields_source_BuiltinAsset | AssetFields_source_ERC20;
-
-export interface AssetFields {
-  __typename: "Asset";
-  /**
-   * The ID of the asset
-   */
-  id: string;
-  /**
-   * The symbol of the asset (e.g: GBP)
-   */
-  symbol: string;
-  /**
-   * The full name of the asset (e.g: Great British Pound)
-   */
-  name: string;
-  /**
-   * The precision of the asset. Should match the decimal precision of the asset on its native chain, e.g: for ERC20 assets, it is often 18
-   */
-  decimals: number;
-  /**
-   * The origin source of the asset (e.g: an ERC20 asset)
-   */
-  source: AssetFields_source;
-}

apps/trading/client-pages/portfolio/__generated__/WithdrawFormQuery.ts

@@ -1,119 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-// @generated
-// This file was automatically generated and should not be edited.
-
-import { Schema } from "@vegaprotocol/types";
-
-// ====================================================
-// GraphQL query operation: WithdrawFormQuery
-// ====================================================
-
-export interface WithdrawFormQuery_party_withdrawals {
-  __typename: "Withdrawal";
-  /**
-   * The Vega internal ID of the withdrawal
-   */
-  id: string;
-  /**
-   * Hash of the transaction on the foreign chain
-   */
-  txHash: string | null;
-}
-
-export interface WithdrawFormQuery_party_accounts_asset {
-  __typename: "Asset";
-  /**
-   * The ID of the asset
-   */
-  id: string;
-  /**
-   * The symbol of the asset (e.g: GBP)
-   */
-  symbol: string;
-}
-
-export interface WithdrawFormQuery_party_accounts {
-  __typename: "Account";
-  /**
-   * Account type (General, Margin, etc)
-   */
-  type: Schema.AccountType;
-  /**
-   * Balance as string - current account balance (approx. as balances can be updated several times per second)
-   */
-  balance: string;
-  /**
-   * Asset, the 'currency'
-   */
-  asset: WithdrawFormQuery_party_accounts_asset;
-}
-
-export interface WithdrawFormQuery_party {
-  __typename: "Party";
-  /**
-   * Party identifier
-   */
-  id: string;
-  /**
-   * The list of all withdrawals initiated by the party
-   */
-  withdrawals: WithdrawFormQuery_party_withdrawals[] | null;
-  /**
-   * Collateral accounts relating to a party
-   */
-  accounts: WithdrawFormQuery_party_accounts[] | null;
-}
-
-export interface WithdrawFormQuery_assets_source_BuiltinAsset {
-  __typename: "BuiltinAsset";
-}
-
-export interface WithdrawFormQuery_assets_source_ERC20 {
-  __typename: "ERC20";
-  /**
-   * The address of the ERC20 contract
-   */
-  contractAddress: string;
-}
-
-export type WithdrawFormQuery_assets_source = WithdrawFormQuery_assets_source_BuiltinAsset | WithdrawFormQuery_assets_source_ERC20;
-
-export interface WithdrawFormQuery_assets {
-  __typename: "Asset";
-  /**
-   * The ID of the asset
-   */
-  id: string;
-  /**
-   * The symbol of the asset (e.g: GBP)
-   */
-  symbol: string;
-  /**
-   * The full name of the asset (e.g: Great British Pound)
-   */
-  name: string;
-  /**
-   * The precision of the asset. Should match the decimal precision of the asset on its native chain, e.g: for ERC20 assets, it is often 18
-   */
-  decimals: number;
-  /**
-   * The origin source of the asset (e.g: an ERC20 asset)
-   */
-  source: WithdrawFormQuery_assets_source;
-}
-
-export interface WithdrawFormQuery {
-  /**
-   * An entity that is trading on the Vega network
-   */
-  party: WithdrawFormQuery_party | null;
-  /**
-   * The list of all assets in use in the Vega network
-   */
-  assets: WithdrawFormQuery_assets[] | null;
-}
-
-export interface WithdrawFormQueryVariables {
-  partyId: string;
-}

apps/trading/client-pages/portfolio/__generated___/AccountHistory.ts

@@ -0,0 +1,63 @@
+import { Schema as Types } from '@vegaprotocol/types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {} as const;
+export type AccountHistoryQueryVariables = Types.Exact<{
+  partyId: Types.Scalars['ID'];
+  assetId: Types.Scalars['ID'];
+  accountTypes?: Types.InputMaybe<Array<Types.AccountType> | Types.AccountType>;
+}>;
+
+
+export type AccountHistoryQuery = { __typename?: 'Query', balanceChanges: { __typename?: 'AggregatedBalanceConnection', edges: Array<{ __typename?: 'AggregatedBalanceEdge', node: { __typename?: 'AggregatedBalance', timestamp: any, partyId?: string | null, balance: string, marketId?: string | null, assetId?: string | null, accountType?: Types.AccountType | null } } | null> } };
+
+
+export const AccountHistoryDocument = gql`
+    query AccountHistory($partyId: ID!, $assetId: ID!, $accountTypes: [AccountType!]) {
+  balanceChanges(
+    filter: {partyIds: [$partyId], accountTypes: $accountTypes, assetId: $assetId}
+  ) {
+    edges {
+      node {
+        timestamp
+        partyId
+        balance
+        marketId
+        assetId
+        accountType
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useAccountHistoryQuery__
+ *
+ * To run a query within a React component, call `useAccountHistoryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useAccountHistoryQuery` 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 } = useAccountHistoryQuery({
+ *   variables: {
+ *      partyId: // value for 'partyId'
+ *      assetId: // value for 'assetId'
+ *      accountTypes: // value for 'accountTypes'
+ *   },
+ * });
+ */
+export function useAccountHistoryQuery(baseOptions: Apollo.QueryHookOptions<AccountHistoryQuery, AccountHistoryQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<AccountHistoryQuery, AccountHistoryQueryVariables>(AccountHistoryDocument, options);
+      }
+export function useAccountHistoryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AccountHistoryQuery, AccountHistoryQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<AccountHistoryQuery, AccountHistoryQueryVariables>(AccountHistoryDocument, options);
+        }
+export type AccountHistoryQueryHookResult = ReturnType<typeof useAccountHistoryQuery>;
+export type AccountHistoryLazyQueryHookResult = ReturnType<typeof useAccountHistoryLazyQuery>;
+export type AccountHistoryQueryResult = Apollo.QueryResult<AccountHistoryQuery, AccountHistoryQueryVariables>;

apps/trading/client-pages/portfolio/account-history-container.tsx

@@ -0,0 +1,170 @@
+import { fromNanoSeconds, t } from '@vegaprotocol/react-helpers';
+import { useVegaWallet } from '@vegaprotocol/wallet';
+import compact from 'lodash/compact';
+import { extent } from 'd3-array';
+import { scaleLinear, scaleTime } from 'd3-scale';
+import { line } from 'd3-shape';
+import { useMemo, useState } from 'react';
+import type { AccountHistoryQuery } from './__generated___/AccountHistory';
+import { useAccountHistoryQuery } from './__generated___/AccountHistory';
+import { Schema } from '@vegaprotocol/types';
+import type { AssetFieldsFragment } from '@vegaprotocol/assets';
+import { useAssetsDataProvider } from '@vegaprotocol/assets';
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@vegaprotocol/ui-toolkit';
+
+export const AccountHistoryContainer = () => {
+  const { pubKey } = useVegaWallet();
+  const { data: assets } = useAssetsDataProvider();
+
+  if (!pubKey) {
+    return <div>Connect wallet</div>;
+  }
+
+  if (!assets) {
+    return <div>Loading..</div>;
+  }
+
+  return <AccountHistoryManager pubKey={pubKey} assets={assets} />;
+};
+
+const AccountHistoryManager = ({
+  pubKey,
+  assets,
+}: {
+  pubKey: string;
+  assets: AssetFieldsFragment[];
+}) => {
+  const [asset, setAsset] = useState(() => {
+    return assets.find(
+      (a) =>
+        a.id ===
+        'b340c130096819428a62e5df407fd6abe66e444b89ad64f670beb98621c9c663'
+    );
+  });
+  const [accountType, setAccountType] = useState<Schema.AccountType>();
+
+  const { data } = useAccountHistoryQuery({
+    variables: {
+      partyId: pubKey,
+      assetId: asset?.id || '',
+      accountTypes: accountType ? [accountType] : undefined,
+    },
+    skip: !asset,
+  });
+
+  return (
+    <div>
+      <div className="flex gap-2">
+        <DropdownMenu>
+          <DropdownMenuTrigger>
+            {asset ? asset.symbol : t('Select asset')}
+          </DropdownMenuTrigger>
+          <DropdownMenuContent>
+            {assets.map((a) => (
+              <DropdownMenuItem key={a.id} onClick={() => setAsset(a)}>
+                {a.symbol}
+              </DropdownMenuItem>
+            ))}
+          </DropdownMenuContent>
+        </DropdownMenu>
+        <DropdownMenu>
+          <DropdownMenuTrigger>
+            {accountType ? accountType : t('Select account type')}
+          </DropdownMenuTrigger>
+          <DropdownMenuContent>
+            {Object.keys(Schema.AccountType).map((type) => (
+              <DropdownMenuItem
+                key={type}
+                onClick={() => setAccountType(type as Schema.AccountType)}
+              >
+                {type}
+              </DropdownMenuItem>
+            ))}
+          </DropdownMenuContent>
+        </DropdownMenu>
+        <div>TODO: Date range</div>
+      </div>
+      <AccountHistoryChart data={data} />
+    </div>
+  );
+};
+
+const AccountHistoryChart = ({
+  data,
+}: {
+  data: AccountHistoryQuery | undefined;
+}) => {
+  const values = useMemo(() => {
+    if (!data?.balanceChanges.edges.length) {
+      return [];
+    }
+
+    return compact(data.balanceChanges.edges)
+      .filter((edge) => {
+        return (
+          edge.node.accountType === Schema.AccountType.ACCOUNT_TYPE_GENERAL
+        );
+      })
+      .map((edge) => {
+        return {
+          datetime: fromNanoSeconds(edge.node.timestamp), // Date
+          balance: Number(edge.node.balance), // number
+        };
+      });
+    // return [
+    //   // ...res,
+    //   { datetime: new Date('2022-11-20'), balance: 200 },
+    //   { datetime: new Date('2022-11-21'), balance: 300 },
+    //   { datetime: new Date('2022-11-22'), balance: 250 },
+    //   { datetime: new Date('2022-11-23'), balance: 250 },
+    //   { datetime: new Date('2022-11-24'), balance: 650 },
+    //   { datetime: new Date('2022-11-25'), balance: 250 },
+    // ];
+  }, [data]);
+  if (!values.length) {
+    return <div>{t('No data')}</div>;
+  }
+
+  const pathProps = {
+    className: '[vector-effect:non-scaling-stroke] stroke-vega-green',
+    stroke: 'strokeCurrent',
+    strokeWidth: 1,
+    fill: 'transparent',
+  };
+
+  const width = 500;
+  const height = 300;
+  const xExtents = extent(values, (d) => d.datetime) as [Date, Date];
+  const yExtents = extent(values, (d) => d.balance) as [number, number];
+  const xScale = scaleTime().domain(xExtents).range([0, width]);
+  const yScale = scaleLinear().domain(yExtents).range([height, 0]);
+
+  console.log(xExtents, yExtents);
+
+  const lineSeries = line()
+    // @ts-ignore dunno why d3 dont work here
+    .x((d) => xScale(d.datetime))
+    // @ts-ignore dunno why d3 dont work here
+    .y((d) => yScale(d.balance));
+
+  const path = lineSeries(values as any);
+
+  return (
+    <div>
+      <svg
+        className="bg-neutral-100"
+        width={width}
+        height={height}
+        viewBox={`0 0 ${width} ${height}`}
+        preserveAspectRatio="none"
+      >
+        {path && <path {...pathProps} d={path} />}
+      </svg>
+    </div>
+  );
+};

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

@@ -13,6 +13,7 @@ import { LayoutPriority } from 'allotment';
 import { usePageTitleStore } from '../../stores';
 import { LedgerContainer } from '@vegaprotocol/ledger';
 import { AccountsContainer } from '../../components/accounts-container';
+import { AccountHistoryContainer } from './account-history-container';
 
 export const Portfolio = () => {
   const { updateTitle } = usePageTitleStore((store) => ({
@@ -30,6 +31,11 @@ export const Portfolio = () => {
         <ResizableGridPanel minSize={75}>
           <PortfolioGridChild>
             <Tabs>
+              <Tab id="account-history" name={t('Account history')}>
+                <VegaWalletContainer>
+                  <AccountHistoryContainer />
+                </VegaWalletContainer>
+              </Tab>
               <Tab id="positions" name={t('Positions')}>
                 <VegaWalletContainer>
                   <PositionsContainer />

libs/deal-ticket/src/hooks/EstimateOrder.graphql

@@ -5,7 +5,7 @@ query EstimateOrder(
   $size: String!
   $side: Side!
   $timeInForce: OrderTimeInForce!
-  $expiration: Timestamp
+  $expiration: String
   $type: OrderType!
 ) {
   estimateOrder(

libs/deal-ticket/src/hooks/__generated__/EstimateOrder.ts

@@ -10,7 +10,7 @@ export type EstimateOrderQueryVariables = Types.Exact<{
   size: Types.Scalars['String'];
   side: Types.Side;
   timeInForce: Types.OrderTimeInForce;
-  expiration?: Types.InputMaybe<Types.Scalars['Timestamp']>;
+  expiration?: Types.InputMaybe<Types.Scalars['String']>;
   type: Types.OrderType;
 }>;
 
@@ -19,7 +19,7 @@ export type EstimateOrderQuery = { __typename?: 'Query', estimateOrder: { __type
 
 
 export const EstimateOrderDocument = gql`
-    query EstimateOrder($marketId: ID!, $partyId: ID!, $price: String, $size: String!, $side: Side!, $timeInForce: OrderTimeInForce!, $expiration: Timestamp, $type: OrderType!) {
+    query EstimateOrder($marketId: ID!, $partyId: ID!, $price: String, $size: String!, $side: Side!, $timeInForce: OrderTimeInForce!, $expiration: String, $type: OrderType!) {
   estimateOrder(
     marketId: $marketId
     partyId: $partyId

libs/market-list/src/lib/__generated___/market.ts

@@ -3,14 +3,14 @@ import { Schema as Types } from '@vegaprotocol/types';
 import { gql } from '@apollo/client';
 import * as Apollo from '@apollo/client';
 const defaultOptions = {} as const;
-export type SingleMarketFieldsFragment = { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, dataSourceSpecForTradingTermination: { __typename?: 'DataSourceSpec', id: string }, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, name: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: any | null, close?: any | null }, depth: { __typename?: 'MarketDepth', lastTrade?: { __typename?: 'Trade', price: string } | null } };
+export type SingleMarketFieldsFragment = { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, dataSourceSpecForTradingTermination: { __typename?: 'DataSourceSpec', id: string }, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, name: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: string | null, close?: string | null }, depth: { __typename?: 'MarketDepth', lastTrade?: { __typename?: 'Trade', price: string } | null } };
 
 export type MarketQueryVariables = Types.Exact<{
   marketId: Types.Scalars['ID'];
 }>;
 
 
-export type MarketQuery = { __typename?: 'Query', market?: { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, dataSourceSpecForTradingTermination: { __typename?: 'DataSourceSpec', id: string }, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, name: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: any | null, close?: any | null }, depth: { __typename?: 'MarketDepth', lastTrade?: { __typename?: 'Trade', price: string } | null } } | null };
+export type MarketQuery = { __typename?: 'Query', market?: { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, dataSourceSpecForTradingTermination: { __typename?: 'DataSourceSpec', id: string }, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, name: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: string | null, close?: string | null }, depth: { __typename?: 'MarketDepth', lastTrade?: { __typename?: 'Trade', price: string } | null } } | null };
 
 export const SingleMarketFieldsFragmentDoc = gql`
     fragment SingleMarketFields on Market {

libs/market-list/src/lib/__generated___/markets.ts

@@ -3,12 +3,12 @@ import { Schema as Types } from '@vegaprotocol/types';
 import { gql } from '@apollo/client';
 import * as Apollo from '@apollo/client';
 const defaultOptions = {} as const;
-export type MarketFieldsFragment = { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: any | null, close?: any | null } };
+export type MarketFieldsFragment = { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: string | null, close?: string | null } };
 
 export type MarketsQueryVariables = Types.Exact<{ [key: string]: never; }>;
 
 
-export type MarketsQuery = { __typename?: 'Query', marketsConnection?: { __typename?: 'MarketConnection', edges: Array<{ __typename?: 'MarketEdge', node: { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: any | null, close?: any | null } } }> } | null };
+export type MarketsQuery = { __typename?: 'Query', marketsConnection?: { __typename?: 'MarketConnection', edges: Array<{ __typename?: 'MarketEdge', node: { __typename?: 'Market', id: string, decimalPlaces: number, positionDecimalPlaces: number, state: Types.MarketState, tradingMode: Types.MarketTradingMode, fees: { __typename?: 'Fees', factors: { __typename?: 'FeeFactors', makerFee: string, infrastructureFee: string, liquidityFee: string } }, tradableInstrument: { __typename?: 'TradableInstrument', instrument: { __typename?: 'Instrument', id: string, name: string, code: string, metadata: { __typename?: 'InstrumentMetadata', tags?: Array<string> | null }, product: { __typename?: 'Future', quoteName: string, settlementAsset: { __typename?: 'Asset', id: string, symbol: string, decimals: number } } } }, marketTimestamps: { __typename?: 'MarketTimestamps', open?: string | null, close?: string | null } } }> } | null };
 
 export const MarketFieldsFragmentDoc = gql`
     fragment MarketFields on Market {

libs/network-stats/src/components/stats-manager/__generated__/Stats.ts

@@ -6,7 +6,7 @@ const defaultOptions = {} as const;
 export type StatsQueryVariables = Types.Exact<{ [key: string]: never; }>;
 
 
-export type StatsQuery = { __typename?: 'Query', nodeData?: { __typename?: 'NodeData', stakedTotal: string, totalNodes: number, inactiveNodes: number, validatingNodes: number } | null, statistics: { __typename?: 'Statistics', status: string, blockHeight: string, blockDuration: string, backlogLength: string, txPerBlock: string, tradesPerSecond: string, ordersPerSecond: string, averageOrdersPerBlock: string, vegaTime: string, appVersion: string, chainVersion: string, chainId: string, genesisTime: string } };
+export type StatsQuery = { __typename?: 'Query', nodeData?: { __typename?: 'NodeData', stakedTotal: string, totalNodes: number, inactiveNodes: number } | null, statistics: { __typename?: 'Statistics', status: string, blockHeight: string, blockDuration: string, backlogLength: string, txPerBlock: string, tradesPerSecond: string, ordersPerSecond: string, averageOrdersPerBlock: string, vegaTime: string, appVersion: string, chainVersion: string, chainId: string, genesisTime: string } };
 
 
 export const StatsDocument = gql`

libs/types/apollo.config.js

@@ -13,6 +13,7 @@ module.exports = {
     ],
     excludes: [
       '../../apps/explorer/**',
+      '../../apps/trading/**',
       '**/generic-data-provider.ts',
       '**/__generated___/*',
       '../../libs/accounts/**',

libs/types/src/__generated__/types.ts

@@ -1947,6 +1947,8 @@ export type NodeData = {
   totalNodes: Scalars['Int'];
   /** Total uptime for all epochs across all nodes. Or specify a number of epochs */
   uptime: Scalars['Float'];
+  /** Number of nodes validating */
+  validatingNodes: Scalars['Int'];
 };
 
 /** Edge type containing the node and cursor information returned by a NodesConnection */