@tradejs/cli 1.0.0

package/dist/lib/runBot.js

@@ -0,0 +1,157 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runBot.ts
+var runBot_exports = {};
+__export(runBot_exports, {
+  runBot: () => runBot
+});
+module.exports = __toCommonJS(runBot_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_connectors = require("@tradejs/node/connectors");
+var import_json = require("@tradejs/core/json");
+var import_strategies = require("@tradejs/node/strategies");
+var import_async = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var import_logger = require("@tradejs/infra/logger");
+var import_redis = require("@tradejs/infra/redis");
+var runBot = async () => {
+  const botResults = [];
+  const preloadStart = (0, import_time.getTimestamp)(import_constants.BOT_PRELOAD_DAYS);
+  const end = (0, import_time.getTimestamp)();
+  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.botsPrefix());
+  const botKeys = keys.filter((key) => key.endsWith(":bots"));
+  await (0, import_async.delay)(5e3);
+  import_logger.logger.log("info", "files count: %s", botKeys.length);
+  for await (const key of botKeys) {
+    const userName = key.split(":")[1];
+    import_logger.logger.log("info", "user: %s", userName);
+    const botConfig = await (0, import_redis.getData)(import_redis.redisKeys.bots(userName));
+    if (import_lodash.default.isEmpty(botConfig)) {
+      import_logger.logger.log("error", "botConfig is empty: %s", userName);
+      continue;
+    }
+    import_logger.logger.log("info", "bots count: %s", botConfig.length);
+    for await (const bot of botConfig) {
+      const { symbol, strategyName, strategyConfig, connectorName, disabled } = bot;
+      import_logger.logger.log("info", "bot %s", symbol);
+      if (disabled) {
+        import_logger.logger.log("error", "bot %s disabled", symbol);
+        continue;
+      }
+      try {
+        const strategyCreator = await (0, import_strategies.getStrategyCreator)(strategyName);
+        if (!strategyCreator) {
+          throw new Error(`Unknown strategy: ${strategyName}`);
+        }
+        const connectorCreator = await (0, import_connectors.getConnectorCreatorByName)(connectorName);
+        if (!connectorCreator) {
+          throw new Error(`Unknown connector: ${connectorName}`);
+        }
+        const connector = await connectorCreator({
+          userName
+        });
+        const binanceConnectorCreator = await (0, import_connectors.getConnectorCreatorByName)(
+          import_connectors.BUILTIN_CONNECTOR_NAMES.Binance
+        );
+        const coinbaseConnectorCreator = await (0, import_connectors.getConnectorCreatorByName)(
+          import_connectors.BUILTIN_CONNECTOR_NAMES.Coinbase
+        );
+        if (!binanceConnectorCreator || !coinbaseConnectorCreator) {
+          throw new Error("Binance/Coinbase connectors are required");
+        }
+        const [binanceConnector, coinbaseConnector] = await Promise.all([
+          binanceConnectorCreator({
+            userName
+          }),
+          coinbaseConnectorCreator({
+            userName
+          })
+        ]);
+        const interval = "15";
+        const data = await connector.kline({
+          symbol,
+          start: preloadStart,
+          end,
+          interval
+        });
+        const [btcData, btcBinanceData, btcCoinbaseData] = await Promise.all([
+          connector.kline({
+            symbol: "BTCUSDT",
+            start: preloadStart,
+            end,
+            interval
+          }),
+          binanceConnector.kline({
+            symbol: "BTCUSDT",
+            start: preloadStart,
+            end,
+            interval
+          }),
+          coinbaseConnector.kline({
+            symbol: "BTCUSDT",
+            start: preloadStart,
+            end,
+            interval
+          })
+        ]);
+        const candle = data.pop();
+        const btcCandle = btcData.pop();
+        const strategy = await strategyCreator({
+          userName,
+          config: strategyConfig,
+          symbol,
+          data,
+          btcData,
+          btcBinanceData,
+          btcCoinbaseData,
+          connector
+        });
+        import_logger.logger.log("info", "strategy created");
+        if (!candle || !btcCandle) {
+          throw new Error("Candle is empty");
+        }
+        const status = await strategy(candle, btcCandle);
+        botResults.push({
+          symbol,
+          status: JSON.stringify(status)
+        });
+      } catch (err) {
+        import_logger.logger.log("error", "bot %s error: %s", bot.symbol, (0, import_json.toJson)(err, false));
+      }
+    }
+  }
+  import_logger.logger.log("info", "botResults: %s", (0, import_json.toJson)(botResults, true));
+  return botResults;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBot
+});