chore(trading): update readme and clear session storage

apps/trading/.env.mainnet

@@ -29,5 +29,5 @@ NX_REFERRALS=true
 NX_TENDERMINT_URL=https://be.vega.community
 NX_TENDERMINT_WEBSOCKET_URL=wss://be.vega.community/websocket
 
-NX_CHARTING_LIBRARY_PATH=https://assets.vega.community/trading-view-bundle/v0.0.1/
-NX_CHARTING_LIBRARY_HASH=PDjWaqPFndDp+LCvqbKvntWriaqNzNpZ5i9R/BULzCg=
+# NX_CHARTING_LIBRARY_PATH=https://assets.vega.community/trading-view-bundle/v0.0.1/
+# NX_CHARTING_LIBRARY_HASH=PDjWaqPFndDp+LCvqbKvntWriaqNzNpZ5i9R/BULzCg=

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

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

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

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

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

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

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

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

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

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

libs/environment/src/utils/time.ts

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

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

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

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

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

nx.json

@@ -11,9 +11,7 @@
           "echo $NX_VEGA_URL",
           "echo $NX_TENDERMINT_URL",
           "echo $NX_TENDERMINT_WEBSOCKET_URL",
-          "echo $NX_ETHEREUM_PROVIDER_URL",
-          "echo $NX_CHARTING_LIBRARY_PATH",
-          "echo $NX_CHARTING_LIBRARY_HASH"
+          "echo $NX_ETHEREUM_PROVIDER_URL"
         ]
       }
     }