market-data-tradingview-ws 0.0.1

package/.prettierrc

@@ -0,0 +1,12 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 140,
+  "arrowParens": "always",
+  "overrides": [
+    {
+      "files": ["**/.*rc", "**/*.json"],
+      "options": { "parser": "json" }
+    }
+  ]
+}

package/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+import { Client } from './lib/client.js';
+
+exports.default = Client;
+module.exports = Client;

package/lib/client.js

@@ -0,0 +1,156 @@
+import WebSocket from 'ws';
+import { tradingView } from './tradingView.js';
+
+const tv = new tradingView();
+
+const sessions = {
+  values: new Map(),
+
+  set({ key, data }) {
+    if (data) {
+      this.values.set(key, data);
+    }
+  },
+  get({ key }) {
+    return this.values.get(key);
+  },
+  getKeys() {
+    return this.values.keys();
+  },
+  getKeyByType({ type }) {
+    let session = '';
+    this.values.forEach((value, key) => {
+      if (type === value.type) session = key;
+    });
+    return session;
+  },
+};
+
+export class Client {
+  #ws;
+  #sessions; // = new Map();
+  #token = null;
+  constructor() {
+    this.#sessions = sessions;
+  }
+
+  close() {
+    this.#ws.close();
+  }
+
+  getSession({ key }) {
+    return this.#sessions.get({ key });
+  }
+
+  getSessionKeys() {
+    return this.#sessions.keys();
+  }
+
+  async getToken({ login, pass }) {
+    return tv.getToken({ login, pass });
+  }
+
+  auth(token = ['unauthorized_user_token']) {
+    return tv.formatWSPacket({
+      packet: {
+        m: 'set_auth_token',
+        p: [token],
+      },
+    });
+  }
+
+  async connect({ url, options, login, pass, result }) {
+    this.#token = await this.getToken({ login, pass });
+    if (this.#token.length > 10) {
+      return new Promise((resolv, reject) => {
+        this.#ws = new WebSocket(url, options);
+
+        this.#ws.onclose = () => console.log('disconnected');
+
+        this.#ws.onerror = (error) => reject(console.error('error: ', error));
+        this.#ws.onopen = () => {
+          this.#ws.send(this.auth(this.#token));
+          this.messageListner({ result });
+          resolv('open');
+        };
+      });
+    }
+  }
+
+  createSession({ type }) {
+    const startsWith = type === 'chart' ? 'cs_' : 'qs_';
+    const key = tv.createSession({ startsWith });
+    const session = sessions.set({ key, data: { type, symbols: [] } });
+    // console.log(key, session);
+    if (type === 'chart') {
+      this.#ws.send(tv.wsCreateChartSession({ chartSession: key }));
+      this.#ws.send(tv.switchTimezone({ chartSession: key, tz: 'Etc/UTC' }));
+    } else {
+      this.#ws.send(tv.wsQuoteCreateSession({ session: key }));
+      this.#ws.send(tv.setFieldsChart({ session: key }));
+    }
+    return session;
+  }
+
+  addQuoteSymbols({ symbolIds }) {
+    const key = this.#sessions.getKeyByType({ type: 'quote' });
+    this.#ws.send(tv.quoteAddSymbols({ session: key, symbolIds }));
+
+    const data = this.#sessions.get({ key });
+    // console.log(key, data);
+    symbolIds.forEach((each) => data.symbols.push(each));
+    this.#sessions.set({ key, data });
+  }
+
+  messageListner({ result }) {
+    this.#ws.on('message', (raw) => {
+      if (this.#ws.readyState !== this.#ws.OPEN) return;
+
+      let session = '';
+      tv.parsePacket({ str: raw }).forEach((packet) => {
+        if (packet === undefined) {
+          console.log('undefined: ', raw.toString());
+        } else {
+          if (packet.type === 'ping') {
+            // console.info('pong', packet);
+            this.#ws.send(tv.createPong({ value: packet.data }));
+          } else if (packet.type === 'protocol_error') {
+            console.warn('protocol_error', packet);
+            this.close();
+          } else if (packet.type === 'qsd') {
+            session = sessions.get({ key: packet.data[0] });
+            // console.log('qsd', packet.data, session);
+            const send = packet.data[1].v;
+            send.symbol = packet.data[1].n;
+            // console.log(JSON.stringify([packet.type, send]));
+            result({ packet: send });
+          } else if (['du', 'timescale_update'].includes(packet.type)) {
+            session = sessions.get({ key: packet.data[0] });
+            // console.log('du', packet.data, session);
+            result({ packet });
+            // const arr = [];
+            // for (var key in packet.data[1].s1.s) {
+            //   const send = {
+            // symbol: session.symbolId,
+            // end: packet.data[1].s1.s[key + 1] !== undefined ? packet.data[1].s1.s[key + 1].v[0] : packet.data[1].s1.lbs.bar_close_time,
+            //   };
+            // console.log(key, packet.data[1].s1.s);
+            //   [send.start, send.open, send.low, send.high, send.close, send.passed] = packet.data[1].s1.s[key].v;
+            // console.log(send);
+            //   arr.push(send);
+            // }
+            // [send.start, send.open, send.low, send.high, send.close, send.passed] = packet.data[1].s1.s.v;
+            // console.log(JSON.stringify([packet.type, arr]));
+          } else if (['series', 'symbol', 'quote'].includes(packet.type)) {
+            console.info(packet);
+          } else {
+            console.warn('error', raw.toString());
+          }
+          // else {
+          //   console.log('received: %s', raw);
+          // }
+        }
+      });
+    });
+  }
+}

package/lib/tradingView.js

@@ -0,0 +1,217 @@
+import { Utils } from './utils.js';
+const u = new Utils();
+
+const letters = 'abcdefghijklmnopqrstuvwxyz';
+const cleanerRgx = /~h~/g;
+const splitterRgx = /~m~[0-9]{1,}~m~/g;
+const urlSymbolSearch = 'https://symbol-search.tradingview.com/symbol_search';
+
+export class tradingView {
+  async getToken({ login, pass }) {
+    const url = 'https://www.tradingview.com/accounts/signin/';
+    const headers = {
+      Referer: 'https://www.tradingview.com',
+    };
+
+    const form = new FormData();
+    form.append('username', login);
+    form.append('password', pass);
+    form.append('remember', 'on');
+
+    //   const res = await fetch(url, {
+    //     method: 'POST',
+    //     headers,
+    //     body: form,
+    //   });
+
+    //   if (res.status === 200) {
+    //     const data = await res.json();
+    //     if (data.user.auth_token === undefined) throw new Error('Error get auth_token', data);
+    //     console.log(data.user.auth_token);
+    //     return data.user.auth_token;
+    //   }
+
+    // await u.pause();
+    return 'eyJhbGciOiJSUzUxMiIsImtpZCI6IkdaeFUiLCJ0eXAiOiJKV1QifQ.eyJ1c2VyX2lkIjoxMjI1ODcxMiwiZXhwIjoxNjkwNzkzMjIwLCJpYXQiOjE2OTA3Nzg4MjAsInBsYW4iOiJwcm9fcHJlbWl1bSIsImV4dF9ob3VycyI6MSwicGVybSI6IiIsInN0dWR5X3Blcm0iOiJ0di1jaGFydF9wYXR0ZXJucyx0di1jaGFydHBhdHRlcm5zLHR2LXByb3N0dWRpZXMsdHYtdm9sdW1lYnlwcmljZSIsIm1heF9zdHVkaWVzIjoyNSwibWF4X2Z1bmRhbWVudGFscyI6MCwibWF4X2NoYXJ0cyI6OCwibWF4X2FjdGl2ZV9hbGVydHMiOjQwMCwibWF4X3N0dWR5X29uX3N0dWR5IjoyNCwibWF4X2FjdGl2ZV9wcmltaXRpdmVfYWxlcnRzIjo0MDAsIm1heF9hY3RpdmVfY29tcGxleF9hbGVydHMiOjQwMCwibWF4X2Nvbm5lY3Rpb25zIjo1MH0.pZQgM_oTZMnm1Qb4qBf6CfM9dHKltp2T3O2g_VVoK9l66UngEL8mLdeH7-ZpUZ8Y50rV5yr0ND8WRPsRH2w2izk_SNMD63p6GJzXXGPvILgirXW3SFa7HmaHv8Xp6SPhQTWb-ahyv_2GUIueKTvHWBNF5-eBnqYeoXQeWkRFsLA';
+  }
+
+  async getSymbol({ symbol, type }) {
+    // type = 'stock' | 'futures' | 'forex' | 'cfd' | 'crypto' | 'index' | 'economic'
+    // query = what you want to search!
+    // it returns first matching item
+    const res = await fetch(urlSymbolSearch + '?text=' + symbol + '&type=' + type);
+    if (res.status === 200) {
+      const data = await res.json();
+      // console.log(data);
+      return data[0];
+    }
+
+    return 'Network Error!';
+  }
+
+  getSymbolId({ data }) {
+    const name = data.type === 'futures' ? data.contracts[0].symbol : data.symbol;
+    return data.exchange.toUpperCase() + ':' + name.toUpperCase();
+  }
+
+  createSession({ startsWith }) {
+    let session = startsWith;
+    while (session.length < 12) {
+      session += letters[Math.floor(Math.random() * letters.length)];
+    }
+    return session;
+  }
+
+  formatWSPacket({ packet }) {
+    const msg = typeof packet === 'object' ? JSON.stringify(packet) : packet;
+    return '~m~' + msg.length + '~m~' + msg;
+  }
+
+  parsePacket({ str }) {
+    const messages = [];
+    this.parseWSPacket({ str }).forEach((packet) => {
+      messages.push(this.eachPacket(packet));
+    });
+    return messages;
+  }
+
+  parseWSPacket({ str }) {
+    return str
+      .toString()
+      .replace(cleanerRgx, '')
+      .split(splitterRgx)
+      .map((p) => {
+        if (!p) return false;
+        try {
+          return JSON.parse(p);
+        } catch (error) {
+          console.warn('Cant parse', p);
+          return false;
+        }
+      })
+      .filter((p) => p);
+  }
+
+  eachPacket(packet) {
+    if (typeof packet === 'number') {
+      return { type: 'ping', data: packet }; // Ping
+    } else if (packet.m && packet.p) {
+      // Normal packet
+      if (packet.m.startsWith('du')) return { type: packet.m, data: packet.p };
+      if (packet.m.startsWith('timescale') || packet.m.startsWith('qsd')) return { type: packet.m, data: packet.p };
+      if (packet.m.startsWith('series') || packet.m.startsWith('symbol') || packet.m.startsWith('quote')) {
+        const type = packet.m.split('_');
+        return { type: type[0], data: { sub: type[1], detail: packet.p, time: packet.t_ms ? packet.t_ms : Date.now() } };
+      } else {
+        return { type: 'msg', data: parsed.data };
+      }
+      // const session = packet.p[0];
+
+      // if (session && this.#sessions[session]) {
+      // this.#sessions[session].onData(parsed);
+      //
+      // }
+    } else if (packet.session_id) {
+      return { type: 'session', data: packet };
+    } else if (packet.m === 'protocol_error') {
+      return { type: packet.m, data: packet.p }; // Error
+    } else {
+      return { type: 'msgError', data: packet }; // Error
+    }
+  }
+
+  wsQuoteCreateSession({ session }) {
+    return this.formatWSPacket({ packet: { m: 'quote_create_session', p: [session] } });
+  }
+
+  wsCreateChartSession({ chartSession }) {
+    return this.formatWSPacket({ packet: { m: 'chart_create_session', p: [chartSession, ''] } });
+  }
+
+  setFieldsQuote({ session }) {
+    return this.formatWSPacket({ packet: { m: 'quote_set_fields', p: [session, 'lp'] } });
+  }
+
+  setFieldsChart({ session }) {
+    return this.formatWSPacket({
+      packet: {
+        m: 'quote_set_fields',
+        p: [
+          session,
+          'ch',
+          'chp',
+          'current_session',
+          'description',
+          // 'local_description',
+          // 'language',
+          'exchange',
+          // 'format',
+          // 'fractional',
+          'is_tradable',
+          'lp',
+          'lp_time',
+          // 'minmov',
+          // 'minmove2',
+          'original_name',
+          // 'pricescale',
+          'pro_name',
+          'short_name',
+          'type',
+          // 'update_mode',
+          'volume',
+          'ask',
+          'bid',
+          'high_price',
+          'low_price',
+          'open_price',
+          'prev_close_price',
+          'currency_code',
+          // 'rch',
+          // 'rchp',
+          // 'rtc',
+          'status',
+        ],
+      },
+    });
+  }
+
+  quoteAddSymbols({ session, symbolIds }) {
+    return this.formatWSPacket({ packet: { m: 'quote_add_symbols', p: [session, ...symbolIds] } });
+  }
+
+  quoteRemoveSymbols({ session, symbolId }) {
+    return this.formatWSPacket({ packet: { m: 'quote_remove_symbols', p: [session, symbolId] } });
+  }
+
+  switchTimezone({ chartSession, tz = 'Etc/UTC' }) {
+    return this.formatWSPacket({ packet: { m: 'switch_timezone', p: [chartSession, tz] } });
+  }
+
+  resolveSymbol({ chartSession, rSymbolId, symbolId }) {
+    return this.formatWSPacket({
+      packet: {
+        m: 'resolve_symbol',
+        p: [chartSession, rSymbolId, '={"symbol":"' + symbolId + '","adjustment":"splits","session":"extended"}'],
+      },
+    });
+  }
+
+  createSeries({ chartSession, id = 1, interval = '60', total_candle = 1000 }) {
+    return this.formatWSPacket({
+      packet: { m: 'create_series', p: [chartSession, 's' + id, 's' + id, 'symbol_1', interval, total_candle] },
+    });
+  }
+
+  modifySeries({ chartSession, rSymbolId, symbolId }) {
+    return this.formatWSPacket({
+      packet: {
+        m: 'resolve_symbol',
+        p: [chartSession, 'symbol_' + id, '={"symbol":"' + symbolId + '","adjustment":"splits","session":"extended"}'],
+      },
+    });
+  }
+
+  createPong({ value }) {
+    return this.formatWSPacket({ packet: '~h~' + value });
+  }
+}

package/lib/utils.js

@@ -0,0 +1,39 @@
+import https from 'https';
+
+export class Utils {
+  pause(time = 1000) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, time);
+    });
+  }
+
+  request(options = {}, raw = false, content = '') {
+    return new Promise((cb, err) => {
+      const req = https.request(options, (res) => {
+        let data = '';
+        res.on('data', (c) => {
+          data += c;
+        });
+        res.on('end', () => {
+          if (raw) {
+            cb({ data, cookies: res.headers['set-cookie'] });
+            return;
+          }
+
+          try {
+            data = JSON.parse(data);
+          } catch (error) {
+            console.log(data);
+            err(new Error("Can't parse server response"));
+            return;
+          }
+
+          cb({ data, cookies: res.headers['set-cookie'] });
+        });
+      });
+
+      req.on('error', err);
+      req.end(content);
+    });
+  }
+}

package/old.js

@@ -0,0 +1,141 @@
+'use strict';
+
+process.title = 'socket_client';
+
+const urlWS = 'wss://data.tradingview.com/socket.io/websocket';
+
+const login = 'sulimenko@ptfin.kz';
+const pass = '7n8zGZ8v27pH';
+const token = '';
+const interval = '5';
+const total_candle = 100;
+
+const stop = async () => {
+  const closed = new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(console.log('exit'));
+    }, 1000);
+  });
+
+  for (const sessionKey of sessions.values.keys()) {
+    sessions.values.delete(sessionKey);
+    console.log('session clear: ', sessionKey);
+  }
+  socket.close();
+  await closed;
+  process.exit(1);
+};
+
+function changeWSSymbol({ key, chartkey, symbolId }) {
+  const s = sessions.get({ key });
+  const c = sessions.get({ key: chartkey });
+  const queue = [];
+
+  // console.log(s, symbolId, id, c, chartkey, sessions);
+  if (s.symbolId) queue.push(tv.removeSymbols({ session: s.main, symbolId: s.symbolId }));
+  queue.push(tv.addSymbols({ session: s.main, symbolId }));
+  queue.push(tv.resolveSymbol({ chartSession: c.main, id, symbolId }));
+
+  queue.forEach((each) => {
+    console.log(each);
+    socket.send(each);
+  });
+  id++;
+  sessions.set({ key, val: { main: key, symbolId } });
+  sessions.set({ key: chartkey, val: { main: chartkey, symbolId } });
+}
+
+(async () => {
+
+  // const data = await tv.getSymbol({ symbol: 'TSLA', type: 'stock' }); // NASDAQ:TSLA
+  // const data = await tv.getSymbol({ symbol: 'MRNA', type: 'stock' }); // NASDAQ:MRNA
+  const data = await tv.getSymbol({ symbol: 'BTCUSDT', type: 'crypto' });
+  // console.log('symbol: ', data);
+
+  const symbolId = tv.getSymbolId({ data });
+  console.log(symbolId);
+
+  socket = new WebSocket(urlWS, { origin: 'https://data.tradingview.com' });
+  // // const socket = new WebSocket('wss://data.tradingview.com/socket.io/websocket?&type=chart', { origin: 'https://s.tradingview.com' });
+
+  const sessionKey = tv.createSession({ startsWith: 'qs_' });
+  const chartSessionKey = tv.createSession({ startsWith: 'cs_' });
+  sessions.set({ key: sessionKey, val: { main: sessionKey } });
+  sessions.set({ key: chartSessionKey, val: { main: chartSessionKey } });
+  let session = sessions.get({ key: sessionKey });
+  let chartSession = sessions.get({ key: chartSessionKey });
+  // console.log(session);
+
+  socket.on('open', (e) => {
+    console.log('open');
+    socket.send(auth());
+
+    socket.send(tv.wsCreateChartSession({ chartSession: chartSession.main }));
+    socket.send(tv.switchTimezone({ chartSession: chartSession.main, tz: 'Etc/UTC' }));
+    socket.send(tv.wsCreateSession({ session: session.main }));
+    // socket.send(tv.resolveSymbol({ chartSession, id: 1, symbolId }));
+    changeWSSymbol({ key: session.main, chartkey: chartSession.main, symbolId });
+
+    socket.send(tv.setFieldsChart({ session: session.main }));
+    socket.send(tv.createSeries({ chartSession: chartSession.main, id: 1, interval, total_candle }));
+
+    // setTimeout(() => {
+    // addWSSymbol({ key: session.main, symbolId: 'NASDAQ:TSLA' });
+    setTimeout(() => {
+      changeWSSymbol({ key: session.main, chartkey: chartSession.main, symbolId: 'NASDAQ:TSLA' });
+    }, 10000);
+    // }, 10000);
+  });
+
+  socket.on('message', (raw) => {
+    const response = tv.parsePacket({ readyState: socket.readyState, str: raw });
+    // console.log(response, response === undefined);
+    response.forEach((packet) => {
+      // console.log(packet);
+      if (packet === undefined) {
+        console.log('undefined: ', raw.toString());
+      } else {
+        if (packet.type === 'ping') {
+          // console.log('pong', packet);
+          socket.send(tv.createPong({ value: packet.data }));
+        } else if (packet.type === 'protocol_error') {
+          console.log('protocol_error', packet);
+          socket.close();
+        } else if (packet.type === 'qsd') {
+          session = sessions.get({ key: packet.data[0] });
+          // console.log(packet.data, session, sessions);
+          const send = packet.data[1].v;
+          send.symbol = session.symbolId;
+          console.log(JSON.stringify([packet.type, send]));
+        } else if (['du', 'timescale_update'].includes(packet.type)) {
+          session = sessions.get({ key: packet.data[0] });
+          // console.log(packet.data, session, sessions);
+          const arr = [];
+          for (var key in packet.data[1].s1.s) {
+            const send = {
+              symbol: session.symbolId,
+              end: packet.data[1].s1.s[key + 1] !== undefined ? packet.data[1].s1.s[key + 1].v[0] : packet.data[1].s1.lbs.bar_close_time,
+            };
+            // console.log(key, packet.data[1].s1.s);
+            [send.start, send.open, send.low, send.high, send.close, send.passed] = packet.data[1].s1.s[key].v;
+            // console.log(send);
+            arr.push(send);
+          }
+          // [send.start, send.open, send.low, send.high, send.close, send.passed] = packet.data[1].s1.s.v;
+          console.log(JSON.stringify([packet.type, arr]));
+        } else {
+          console.log('error', raw.toString());
+        }
+        // else {
+        //   console.log('received: %s', raw);
+        // }
+      }
+    });
+  });
+  // //   setTimeout(async () => {
+  // // console.log('exit');
+  // //   }, 3000);
+
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+})();

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "market-data-tradingview-ws",
+  "version": "0.0.1",
+  "description": "marketData from Tradingview ws",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "sulimenkoas@gmail.com",
+  "license": "MIT",
+  "dependencies": {
+    "ws": "^8.13.0"
+  }
+}

package/server.js

@@ -0,0 +1,91 @@
+'use strict';
+
+process.title = 'marketDataClient';
+
+import { Client } from './lib/client.js';
+import { Utils } from './lib/utils.js';
+const u = new Utils();
+
+const url = 'wss://data.tradingview.com/socket.io/websocket';
+const options = { origin: 'https://data.tradingview.com' };
+
+const login = 'sulimenko@ptfin.kz';
+const pass = '7n8zGZ8v27pH';
+
+const interval = '5';
+const total_candle = 100;
+
+const marketData = new Client();
+
+const clients = new Map();
+const symbolQuotes = new Map();
+
+const stop = async () => {
+  const closed = new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(console.log('exit'));
+    }, 1000);
+  });
+
+  // for (const sessionKey of marketData.getSessionKeys()) {
+  //   let data = marketData.getSession({ key: sessionKey });
+  //   console.log('session clear: ', sessionKey, data);
+  // }
+  marketData.close();
+  await closed;
+  console.log(clients, symbolQuotes);
+  process.exit(1);
+};
+
+const result = ({ packet }) => {
+  let data = symbolQuotes.get(packet.symbol);
+  if (!data) data = {};
+  Object.keys(packet).forEach((key) => {
+    // console.log(key, data, packet);
+    data[key] = packet[key];
+  });
+  symbolQuotes.set(packet.symbol, data);
+
+  clients.forEach((each) => {
+    if (each.quote.includes(packet.symbol)) {
+      each.client({ acc: each.acc, packet });
+    }
+  });
+};
+
+// function changeWSSymbol({ key, chartkey, symbolId }) {
+//   const s = sessions.get({ key });
+//   const c = sessions.get({ key: chartkey });
+//   const queue = [];
+
+//   // console.log(s, symbolId, id, c, chartkey, sessions);
+//   if (s.symbolId) queue.push(tv.removeSymbols({ session: s.main, symbolId: s.symbolId }));
+//   queue.push(tv.addSymbols({ session: s.main, symbolId }));
+//   queue.push(tv.resolveSymbol({ chartSession: c.main, id, symbolId }));
+
+//   queue.forEach((each) => {
+//     console.log(each);
+//     socket.send(each);
+//   });
+//   id++;
+//   sessions.set({ key, val: { main: key, symbolId } });
+//   sessions.set({ key: chartkey, val: { main: chartkey, symbolId } });
+// }
+
+(async () => {
+  clients.set('123', { acc: '123', quote: ['NASDAQ:TSLA', 'NASDAQ:META'], client: ({ acc, packet }) => console.log(acc, packet) });
+  clients.set('U444', { acc: 'U444', quote: ['NASDAQ:MRNA', 'NASDAQ:LI'], client: ({ acc, packet }) => console.log(acc, packet) });
+
+  const status = await marketData.connect({ url, options, login, pass, result });
+  console.log(status);
+  // await u.pause(2000);
+  marketData.createSession({ type: 'chart' });
+  marketData.createSession({ type: 'quote' });
+
+  clients.forEach((each) => {
+    marketData.addQuoteSymbols({ symbolIds: each.quote });
+  });
+
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+})();