binbot-charts 0.5.2 → 0.5.4

package/dist/components/datafeed.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helpers = require("./helpers.js");
+var _streaming = require("./streaming.js");
+const binanceResolutions = ["1s", "1m", "3m", "5m", "15m", "30m", "1h", "2h", "4h", "6h", "8h", "12h", "1d", "3d", "1w", "1M"];
+const getConfigurationData = async () => {
+  return {
+    supports_marks: true,
+    supports_time: true,
+    supports_timescale_marks: true,
+    supports_time: true,
+    supported_resolutions: ["1S", "1", "3", "5", "15", "30", "60", "120", "240", "360", "480", "720", "1D", "3D", "1W", "12M"],
+    exchanges: [{
+      value: "Binance",
+      name: "Binance",
+      desc: "Binance"
+    }],
+    symbols_types: [{
+      name: "crypto",
+      value: "crypto"
+    }]
+  };
+};
+
+/**
+ * @param timescale { Array }. timescaleMark objects
+ * @param interval { string }. Klines timescale from the list of Binance Enums
+ */
+class Datafeed {
+  constructor() {
+    let timescaleMarks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    let interval = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "1h";
+    this.streaming = null;
+    this.timescaleMarks = timescaleMarks;
+    this.interval = interval;
+  }
+  onReady = async callback => {
+    this.configurationData = await getConfigurationData();
+    callback(this.configurationData);
+  };
+  searchSymbols = async (userInput, exchange, symbolType, onResultReadyCallback) => {
+    const symbols = await (0, _helpers.getAllSymbols)(userInput);
+    onResultReadyCallback(symbols);
+  };
+  resolveSymbol = async (symbolName, onSymbolResolvedCallback, onResolveErrorCallback) => {
+    if (!symbolName) {
+      await onResolveErrorCallback("cannot resolve symbol");
+      return;
+    }
+    const symbolInfo = () => {
+      return {
+        ticker: symbolName,
+        name: symbolName,
+        ticker: symbolName,
+        description: symbolName,
+        type: "crypto",
+        session: "24x7",
+        timezone: "Etc/UTC",
+        exchange: "Binance",
+        minmov: 100,
+        pricescale: 100000,
+        has_daily: true,
+        has_intraday: true,
+        has_no_volume: false,
+        has_seconds: true,
+        seconds_multipliers: [1],
+        volume: "hundreds",
+        volume_precision: 9,
+        data_status: "streaming",
+        resolution: "1h"
+      };
+    };
+    const symbol = await symbolInfo();
+    onSymbolResolvedCallback(symbol);
+  };
+  getBars = async (symbolInfo, resolution, periodParams, onHistoryCallback, onErrorCallback) => {
+    const {
+      from,
+      to,
+      firstDataRequest
+    } = periodParams;
+    let interval = "60"; // 1 hour
+    // Calculate interval using resolution data
+    if (!/[a-zA-Z]$/.test(resolution)) {
+      if (parseInt(resolution) >= 60) {
+        interval = parseInt(resolution) / 60 + "h";
+      } else {
+        interval = resolution + "m";
+      }
+    } else {
+      interval = resolution.toLowerCase().replace(/[a-z]\b/g, c => c.toLowerCase());
+    }
+    let urlParameters = {
+      symbol: symbolInfo.name,
+      interval: interval,
+      startTime: Math.abs(from * 1000),
+      endTime: Math.abs(to * 1000),
+      limit: 600
+    };
+    const query = Object.keys(urlParameters).map(name => `${name}=${encodeURIComponent(urlParameters[name])}`).join("&");
+    try {
+      const data = await (0, _helpers.makeApiRequest)(`api/v3/uiKlines?${query}`);
+      if (data.Response && data.Response === "Error" || data.length === 0) {
+        // "noData" should be set if there is no data in the requested period.
+        onHistoryCallback([], {
+          noData: true
+        });
+        return;
+      }
+      let bars = [];
+      data.forEach(bar => {
+        if (bar[0] >= from * 1000 && bar[0] < to * 1000) {
+          bars = [...bars, {
+            time: bar[0],
+            low: bar[3],
+            high: bar[2],
+            open: bar[1],
+            close: bar[4],
+            volume: bar[5]
+          }];
+        }
+      });
+      onHistoryCallback(bars, {
+        noData: false
+      });
+    } catch (error) {
+      console.log("[getBars]: Get error", error);
+      onErrorCallback(error);
+    }
+  };
+  getTimescaleMarks(symbolInfo, from, to, onDataCallback, resolution) {
+    if (this.timescaleMarks.length > 0) {
+      let timescaleMarks = Object.assign([], this.timescaleMarks);
+      onDataCallback(timescaleMarks);
+    }
+  }
+  async getServerTime(onServertimeCallback) {
+    const data = await (0, _helpers.makeApiRequest)(`api/v3/time`);
+    const serverTime = data.serverTime / 1000;
+    onServertimeCallback(serverTime);
+  }
+  subscribeBars = (symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback) => {
+    (0, _streaming.subscribeOnStream)(symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback, this.interval);
+  };
+  unsubscribeBars = subscriberUID => {
+    (0, _streaming.unsubscribeFromStream)(subscriberUID);
+  };
+}
+exports.default = Datafeed;

package/dist/components/helpers.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAllSymbols = getAllSymbols;
+exports.makeApiRequest = makeApiRequest;
+exports.usePrevious = usePrevious;
+var _react = require("react");
+async function makeApiRequest(path) {
+  try {
+    const response = await fetch(`https://api.binance.com/${path}`);
+    return response.json();
+  } catch (error) {
+    throw new Error(`Binance request error: ${error.status}`);
+  }
+}
+async function getAllSymbols(symbol) {
+  let newSymbols = [];
+  try {
+    const data = await makeApiRequest(`api/v3/exchangeInfo?symbol=${symbol.toUpperCase()}`);
+    data.symbols.forEach(item => {
+      if (item.status === "TRADING") {
+        newSymbols.push({
+          symbol: item.symbol,
+          full_name: `${item.baseAsset}/${item.quoteAsset}`,
+          description: `Precision: ${item.quoteAssetPrecision}`,
+          exchange: "Binance",
+          ticker: item.symbol,
+          type: "crypto"
+        });
+      }
+    });
+  } catch (e) {
+    return newSymbols;
+  }
+  return newSymbols;
+}
+function usePrevious(value) {
+  const ref = (0, _react.useRef)();
+  (0, _react.useEffect)(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}

package/dist/components/streaming.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeOnStream = subscribeOnStream;
+exports.unsubscribeFromStream = unsubscribeFromStream;
+const channelToSubscription = new Map();
+function setupSockets(subRequest) {
+  const socket = new WebSocket("wss://stream.binance.com:9443/ws");
+  window.socket = socket;
+  socket.onopen = event => {
+    console.log("[socket] Connected");
+    socket.send(JSON.stringify(subRequest));
+  };
+  socket.onclose = reason => {
+    console.log("[socket] Disconnected:", reason);
+  };
+  socket.onerror = error => {
+    console.log("[socket] Error:", error);
+  };
+  socket.onmessage = e => {
+    const data = JSON.parse(e.data);
+    if (data.e == undefined) {
+      // skip all non-TRADE events
+      return;
+    }
+    const {
+      s: symbol,
+      t: startTime,
+      T: closeTime,
+      i: interval,
+      o: open,
+      c: close,
+      h: high,
+      l: low,
+      v: volume,
+      n: trades,
+      q: quoteVolume
+    } = data.k;
+    const channelString = `${symbol.toLowerCase()}@kline_${interval}`;
+    const subscriptionItem = channelToSubscription.get(channelString);
+    if (subscriptionItem === undefined) {
+      return;
+    }
+    const bar = {
+      time: startTime,
+      open: open,
+      high: high,
+      low: low,
+      close: close,
+      volume: volume
+    };
+    // send data to every subscriber of that symbol
+    subscriptionItem.handlers.forEach(handler => handler.callback(bar));
+  };
+}
+function subscribeOnStream(symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback, interval) {
+  const channelString = `${symbolInfo.name.toLowerCase()}@kline_${interval}`;
+  const handler = {
+    id: subscribeUID,
+    callback: onRealtimeCallback
+  };
+  let subscriptionItem = channelToSubscription.get(channelString);
+  if (subscriptionItem) {
+    // already subscribed to the channel, use the existing subscription
+    subscriptionItem.handlers.push(handler);
+    return;
+  }
+  subscriptionItem = {
+    subscribeUID,
+    resolution,
+    handlers: [handler]
+  };
+  const subRequest = {
+    method: "SUBSCRIBE",
+    params: [channelString],
+    id: 1
+  };
+  channelToSubscription.set(channelString, subscriptionItem);
+  setupSockets(subRequest);
+}
+function unsubscribeFromStream(subscriberUID) {
+  // find a subscription with id === subscriberUID
+  for (const channelString of channelToSubscription.keys()) {
+    const subscriptionItem = channelToSubscription.get(channelString);
+    const handlerIndex = subscriptionItem.handlers.findIndex(handler => handler.id === subscriberUID);
+    if (handlerIndex !== -1) {
+      // remove from handlers
+      subscriptionItem.handlers.splice(handlerIndex, 1);
+      if (subscriptionItem.handlers.length === 0) {
+        // unsubscribe from the channel, if it was the last handler
+        console.log("[unsubscribeBars]: Unsubscribe from streaming. Channel:", channelString);
+        const subRequest = {
+          method: "UNSUBSCRIBE",
+          params: [channelString],
+          id: 1
+        };
+        window.socket.send(JSON.stringify(subRequest));
+        channelToSubscription.delete(channelString);
+        window.socket = undefined;
+        break;
+      }
+    }
+  }
+}

package/dist/src/{App.jsx → App.js}

@@ -1,32 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importStar(require("react"));
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
 const use_immer_1 = require("use-immer");
 require("./App.css");
 const TVChartContainer_1 = __importDefault(require("./components/TVChartContainer"));
@@ -96,11 +74,6 @@ function App() {
             setSymbolState(e.target.value);
         }
     };
-    return (<>
-      <h1 style={{ textAlign: "center" }}>Test chart</h1>
-      <label htmlFor="symbol">Type symbol</label>
-      <input name="symbol" type="text" onChange={handleChange}/>
-      <TVChartContainer_1.default symbol={symbolState} interval={"1h"} timescaleMarks={testTimeMarks} orderLines={orderLines} onTick={handleTick} getLatestBar={getLatestBar}/>
-    </>);
+    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("h1", Object.assign({ style: { textAlign: "center" } }, { children: "Test chart" })), (0, jsx_runtime_1.jsx)("label", Object.assign({ htmlFor: "symbol" }, { children: "Type symbol" })), (0, jsx_runtime_1.jsx)("input", { name: "symbol", type: "text", onChange: handleChange }), (0, jsx_runtime_1.jsx)(TVChartContainer_1.default, { symbol: symbolState, interval: "1h", timescaleMarks: testTimeMarks, orderLines: orderLines, onTick: handleTick, getLatestBar: getLatestBar })] }));
 }
 exports.default = App;