@tradejs/node 1.0.0

package/dist/backtest.mjs

@@ -0,0 +1,487 @@
+import {
+  BUILTIN_CONNECTOR_NAMES,
+  getConnectorCreatorByName
+} from "./chunk-E2QNOA5M.mjs";
+import {
+  buildMlPayload
+} from "./chunk-PXJJPAQT.mjs";
+import {
+  require_lodash
+} from "./chunk-GKDBAF3A.mjs";
+import {
+  getStrategyCreator
+} from "./chunk-MHCXPD2B.mjs";
+import "./chunk-DE7ADBIR.mjs";
+import {
+  __toESM
+} from "./chunk-6DZX6EAA.mjs";
+
+// src/backtest.ts
+export * from "@tradejs/core/backtest";
+
+// src/testing.ts
+import { alignSortedCandlesByTimestamp } from "@tradejs/core/indicators";
+import { PRELOAD_DAYS } from "@tradejs/core/constants";
+import { getTimestamp } from "@tradejs/core/time";
+import {
+  appendMlDatasetRow,
+  buildMlTrainingRow,
+  trimMlTrainingRowWindows
+} from "@tradejs/infra/ml";
+import { logger } from "@tradejs/infra/logger";
+
+// src/testConnector.ts
+var import_lodash = __toESM(require_lodash());
+import { randomUUID } from "crypto";
+import { TTL_1D } from "@tradejs/core/constants";
+import { round } from "@tradejs/core/math";
+import { redisKeys, setData } from "@tradejs/infra/redis";
+var FEE = 5e-3;
+var INITIAL_AMOUNT = 100;
+var createTestConnector = (connector, context) => {
+  const userName = context?.userName;
+  let state = {};
+  const orderLog = [];
+  const positionLog = [];
+  let currentPosition = null;
+  let amount = INITIAL_AMOUNT;
+  let originalQty = 0;
+  let currentPositionProfit = 0;
+  let takeProfits = [];
+  let stopLossPrice = null;
+  const closedMlResults = [];
+  const logOrder = (data) => {
+    const nextEntry = {
+      ...currentPosition || {},
+      ...data,
+      amount: round(amount),
+      profit: round(data.profit || 0),
+      index: orderLog.length
+    };
+    if (nextEntry.signal) {
+      nextEntry.signal = import_lodash.default.omit(nextEntry.signal, "indicators");
+    }
+    orderLog.push(nextEntry);
+  };
+  const clearPosition = (timestamp) => {
+    takeProfits = [];
+    stopLossPrice = null;
+    originalQty = 0;
+    if (!currentPosition) {
+      return;
+    }
+    if (context?.mlEnabled) {
+      const signalId = currentPosition.signal?.signalId;
+      if (signalId) {
+        closedMlResults.push({
+          signalId,
+          profit: currentPositionProfit
+        });
+      }
+    }
+    positionLog.push({
+      direction: currentPosition.direction,
+      open: {
+        timestamp: currentPosition.timestamp,
+        amount: round(currentPosition.amount)
+      },
+      close: {
+        timestamp,
+        amount: round(amount)
+      }
+    });
+    currentPosition = null;
+    currentPositionProfit = 0;
+  };
+  return {
+    getState: async () => state,
+    setState: async (newState) => {
+      state = {
+        ...state,
+        ...newState
+      };
+    },
+    kline: async (options) => connector.kline(options),
+    getResult: async () => {
+      const orderLogId = randomUUID().slice(-12);
+      const cacheUserName = userName || "root";
+      await setData(
+        redisKeys.cacheOrders(cacheUserName, orderLogId),
+        orderLog,
+        {
+          expire: TTL_1D
+        }
+      );
+      await setData(
+        redisKeys.cachePositions(cacheUserName, orderLogId),
+        positionLog,
+        {
+          expire: TTL_1D
+        }
+      );
+      return {
+        stat: {
+          amount,
+          profit: amount - INITIAL_AMOUNT,
+          orders: positionLog.length
+        },
+        orderLogId
+      };
+    },
+    getPosition: async () => currentPosition || null,
+    checkTp: async (candle) => {
+      if (import_lodash.default.isEmpty(candle) || !currentPosition || !currentPosition.qty) {
+        return;
+      }
+      const isLong = currentPosition.direction === "LONG";
+      const entryPrice = currentPosition.price;
+      const high = candle.high;
+      const low = candle.low;
+      for (const tp of takeProfits) {
+        if (!currentPosition || currentPosition.qty <= 0) break;
+        const targetPrice = tp.price;
+        const reached = isLong ? high >= targetPrice : low <= targetPrice;
+        if (reached) {
+          const qty = originalQty * tp.rate;
+          const profit = isLong ? (targetPrice - entryPrice) * qty : (entryPrice - targetPrice) * qty;
+          amount += profit;
+          currentPositionProfit += profit;
+          currentPosition.qty = parseFloat(
+            (currentPosition.qty - qty).toFixed(8)
+          );
+          logOrder({
+            timestamp: candle.timestamp,
+            qty,
+            price: targetPrice,
+            profit,
+            type: isLong ? "TAKE_PROFIT_LONG" : "TAKE_PROFIT_SHORT"
+          });
+          tp.done = true;
+        }
+      }
+      takeProfits = takeProfits.filter(({ done }) => !done);
+      if (currentPosition && currentPosition.qty <= 0) {
+        clearPosition(candle.timestamp);
+      }
+    },
+    checkSl: async (candle) => {
+      if (!stopLossPrice || !currentPosition || import_lodash.default.isEmpty(candle)) {
+        return;
+      }
+      const isLong = currentPosition.direction === "LONG";
+      const hitStop = isLong ? candle.low <= stopLossPrice : candle.high >= stopLossPrice;
+      if (hitStop) {
+        const qty = currentPosition.qty;
+        const profit = isLong ? (stopLossPrice - currentPosition.price) * qty : (currentPosition.price - stopLossPrice) * qty;
+        amount += profit;
+        currentPositionProfit += profit;
+        logOrder({
+          timestamp: candle.timestamp,
+          qty,
+          profit,
+          price: stopLossPrice,
+          type: isLong ? "STOP_LOSS_LONG" : "STOP_LOSS_SHORT"
+        });
+        clearPosition(candle.timestamp);
+      }
+    },
+    placeOrder: async (order, tp = [], slPrice) => {
+      if (currentPosition) {
+        return false;
+      }
+      const isLong = order.direction === "LONG";
+      takeProfits = import_lodash.default.cloneDeep(tp);
+      stopLossPrice = slPrice || null;
+      currentPosition = { ...order, amount };
+      originalQty = order.qty;
+      const fee = order.price * order.qty * FEE;
+      const profit = fee * -1;
+      amount += profit;
+      currentPositionProfit = profit;
+      logOrder({
+        ...order,
+        profit,
+        fee,
+        type: isLong ? "OPEN_LONG" : "OPEN_SHORT"
+      });
+      return true;
+    },
+    closePosition: async (order) => {
+      if (!currentPosition) {
+        return false;
+      }
+      const isLong = currentPosition.direction === "LONG";
+      const profit = isLong ? (order.price - currentPosition.price) * currentPosition.qty : (currentPosition.price - order.price) * currentPosition.qty;
+      amount += profit;
+      currentPositionProfit += profit;
+      logOrder({
+        ...order,
+        qty: currentPosition.qty,
+        profit,
+        type: isLong ? "CLOSE_LONG" : "CLOSE_SHORT"
+      });
+      clearPosition(order.timestamp);
+      return true;
+    },
+    getTickers: connector.getTickers,
+    getPositions: connector.getPositions,
+    drainMlResultsBatch: async () => closedMlResults.splice(0)
+  };
+};
+
+// src/testing.ts
+var preloadStart = getTimestamp(PRELOAD_DAYS);
+var coinKlineCache = /* @__PURE__ */ new Map();
+var btcKlineCache = /* @__PURE__ */ new Map();
+var btcBinanceKlineCache = /* @__PURE__ */ new Map();
+var btcCoinbaseKlineCache = /* @__PURE__ */ new Map();
+var getKlineCacheKey = (params) => {
+  const { userName, connectorName, symbol, end, interval, cacheOnly } = params;
+  return [
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    end,
+    interval,
+    cacheOnly ? 1 : 0
+  ].join(":");
+};
+var resetTestingKlineCache = () => {
+  coinKlineCache.clear();
+  btcKlineCache.clear();
+  btcBinanceKlineCache.clear();
+  btcCoinbaseKlineCache.clear();
+};
+var testing = async ({
+  userName,
+  symbol,
+  options: { start, end },
+  name,
+  testId,
+  testSuiteId,
+  strategyName,
+  strategyConfig,
+  connectorName,
+  ml = false,
+  chunkId = "single"
+}) => {
+  if (!start) {
+    throw new Error("no start");
+  }
+  const connectorCreator = await getConnectorCreatorByName(connectorName);
+  if (!connectorCreator) {
+    throw new Error(`Unknown connector: ${connectorName}`);
+  }
+  const connector = await connectorCreator({
+    userName
+  });
+  const strategyCreator = await getStrategyCreator(strategyName);
+  if (!strategyCreator) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
+  }
+  const binanceCreator = await getConnectorCreatorByName(
+    BUILTIN_CONNECTOR_NAMES.Binance
+  );
+  const coinbaseCreator = await getConnectorCreatorByName(
+    BUILTIN_CONNECTOR_NAMES.Coinbase
+  );
+  if (!binanceCreator || !coinbaseCreator) {
+    logger.warn(
+      "Binance/Coinbase connectors are unavailable. Reusing %s for BTC references.",
+      connectorName
+    );
+  }
+  const interval = "15";
+  const cacheOnly = true;
+  const coinCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol,
+    end,
+    interval,
+    cacheOnly
+  });
+  const btcCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol: "BTCUSDT",
+    end,
+    interval,
+    cacheOnly
+  });
+  const cachedCoinData = coinKlineCache.get(coinCacheKey);
+  const cachedBtcData = btcKlineCache.get(btcCacheKey);
+  const btcBinanceCacheKey = getKlineCacheKey({
+    userName,
+    connectorName: binanceCreator ? BUILTIN_CONNECTOR_NAMES.Binance : connectorName,
+    symbol: "BTCUSDT",
+    end,
+    interval,
+    cacheOnly
+  });
+  const btcCoinbaseCacheKey = getKlineCacheKey({
+    userName,
+    connectorName: coinbaseCreator ? BUILTIN_CONNECTOR_NAMES.Coinbase : connectorName,
+    symbol: "BTCUSDT",
+    end,
+    interval,
+    cacheOnly
+  });
+  const cachedBtcBinanceData = btcBinanceKlineCache.get(btcBinanceCacheKey);
+  const cachedBtcCoinbaseData = btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
+  const [data, btcData, btcBinanceData, btcCoinbaseData] = await Promise.all([
+    cachedCoinData ? Promise.resolve(cachedCoinData) : connector.kline({
+      symbol,
+      start: preloadStart,
+      end,
+      interval,
+      silent: true,
+      cacheOnly
+    }),
+    cachedBtcData ? Promise.resolve(cachedBtcData) : connector.kline({
+      symbol: "BTCUSDT",
+      start: preloadStart,
+      end,
+      interval,
+      silent: true,
+      cacheOnly
+    }),
+    cachedBtcBinanceData ? Promise.resolve(cachedBtcBinanceData) : binanceCreator ? binanceCreator({ userName }).then(
+      (binanceConnector) => binanceConnector.kline({
+        symbol: "BTCUSDT",
+        start: preloadStart,
+        end,
+        interval,
+        silent: true,
+        cacheOnly
+      })
+    ) : connector.kline({
+      symbol: "BTCUSDT",
+      start: preloadStart,
+      end,
+      interval,
+      silent: true,
+      cacheOnly
+    }),
+    cachedBtcCoinbaseData ? Promise.resolve(cachedBtcCoinbaseData) : coinbaseCreator ? coinbaseCreator({ userName }).then(
+      (coinbaseConnector) => coinbaseConnector.kline({
+        symbol: "BTCUSDT",
+        start: preloadStart,
+        end,
+        interval,
+        silent: true,
+        cacheOnly
+      })
+    ) : connector.kline({
+      symbol: "BTCUSDT",
+      start: preloadStart,
+      end,
+      interval,
+      silent: true,
+      cacheOnly
+    })
+  ]);
+  if (!cachedCoinData) {
+    coinKlineCache.set(coinCacheKey, data);
+  }
+  if (!cachedBtcData) {
+    btcKlineCache.set(btcCacheKey, btcData);
+  }
+  if (!cachedBtcBinanceData) {
+    btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+  }
+  if (!cachedBtcCoinbaseData) {
+    btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+  }
+  const prevDataRaw = data.filter(
+    (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
+  );
+  const btcPrevDataRaw = btcData.filter(
+    (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
+  );
+  const testDataRaw = data.filter(
+    (candle) => candle.timestamp >= start
+  );
+  const btcTestDataRaw = btcData.filter(
+    (candle) => candle.timestamp >= start
+  );
+  const { alignedCoinCandles: prevData, alignedBtcCandles: btcPrevData } = alignSortedCandlesByTimestamp(prevDataRaw, btcPrevDataRaw);
+  const { alignedCoinCandles: testData, alignedBtcCandles: btcTestData } = alignSortedCandlesByTimestamp(testDataRaw, btcTestDataRaw);
+  const { alignedBtcCandles: btcBinancePrevData } = alignSortedCandlesByTimestamp(
+    prevDataRaw,
+    btcBinanceData.filter(
+      (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
+    )
+  );
+  const { alignedBtcCandles: btcCoinbasePrevData } = alignSortedCandlesByTimestamp(
+    prevDataRaw,
+    btcCoinbaseData.filter(
+      (candle) => candle.timestamp >= preloadStart && candle.timestamp < start
+    )
+  );
+  const testConnector = createTestConnector(connector, {
+    userName,
+    mlEnabled: ml
+  });
+  const strategy = await strategyCreator({
+    userName,
+    config: strategyConfig,
+    symbol,
+    data: prevData,
+    btcData: btcPrevData,
+    btcBinanceData: btcBinancePrevData,
+    btcCoinbaseData: btcCoinbasePrevData,
+    connector: testConnector
+  });
+  const pendingMlPayloadBySignalId = /* @__PURE__ */ new Map();
+  const flushMlResultsBatch = async () => {
+    if (!ml) return;
+    const batch = await testConnector.drainMlResultsBatch();
+    if (!batch.length) return;
+    for (const resultRecord of batch) {
+      const payload = pendingMlPayloadBySignalId.get(resultRecord.signalId);
+      if (!payload) continue;
+      pendingMlPayloadBySignalId.delete(resultRecord.signalId);
+      const fullRow = buildMlTrainingRow(payload, {
+        profit: resultRecord.profit
+      });
+      const row = trimMlTrainingRowWindows(fullRow, 5);
+      await appendMlDatasetRow({
+        strategyName,
+        chunkId,
+        row
+      });
+    }
+  };
+  for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
+    const candle = testData[candleIndex];
+    const btcCandle = btcTestData[candleIndex];
+    await testConnector.checkSl(candle);
+    await testConnector.checkTp(candle);
+    const signal = await strategy(candle, btcCandle);
+    if (ml && signal && typeof signal !== "string" && signal.signalId) {
+      const payload = buildMlPayload({
+        signal,
+        context: {
+          userName,
+          testId,
+          testSuiteId,
+          testName: name,
+          symbol,
+          strategyName,
+          strategyConfig,
+          connectorName
+        }
+      });
+      pendingMlPayloadBySignalId.set(signal.signalId, payload);
+    }
+  }
+  await flushMlResultsBatch();
+  return await testConnector.getResult();
+};
+export {
+  createTestConnector,
+  resetTestingKlineCache,
+  testing
+};

package/dist/chunk-4ZPGZWO7.mjs

@@ -0,0 +1,13 @@
+// src/constants.ts
+var { NODE_ENV } = process.env;
+var KLINE_CONCURRENCY_LIMIT = NODE_ENV === "production" ? 5 : 10;
+var TG_CONCURRENCY_LIMIT = 3;
+var AI_CONCURRENCY_LIMIT = 3;
+var SCREENSHOT_CONCURRENCY_LIMIT = NODE_ENV === "production" ? 1 : 2;
+
+export {
+  KLINE_CONCURRENCY_LIMIT,
+  TG_CONCURRENCY_LIMIT,
+  AI_CONCURRENCY_LIMIT,
+  SCREENSHOT_CONCURRENCY_LIMIT
+};

package/dist/chunk-6DZX6EAA.mjs

@@ -0,0 +1,37 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-CVTV6S2V.mjs

@@ -0,0 +1,94 @@
+import {
+  __require
+} from "./chunk-6DZX6EAA.mjs";
+
+// src/pine.ts
+import fs from "fs";
+import path from "path";
+export * from "@tradejs/core/pine";
+var loadPinets = () => {
+  const resolvedPath = __require.resolve("pinets");
+  const cjsPath = resolvedPath.includes("pinets.min.browser") ? resolvedPath.replace(/pinets\.min\.browser(\.es)?\.js$/, "pinets.min.cjs") : resolvedPath;
+  return __require(cjsPath);
+};
+var loadPineScript = (filePath, fallback = "") => {
+  const resolvedPath = String(filePath || "").trim();
+  if (!resolvedPath) {
+    return fallback;
+  }
+  try {
+    return fs.readFileSync(resolvedPath, "utf8").trim();
+  } catch {
+    return fallback;
+  }
+};
+var createLoadPineScript = (baseDir) => {
+  const resolvedBaseDir = path.resolve(baseDir);
+  return (fileNameOrPath, fallback = "") => {
+    const rawPath = String(fileNameOrPath || "").trim();
+    if (!rawPath) {
+      return fallback;
+    }
+    const resolvedPath = path.isAbsolute(rawPath) ? rawPath : path.resolve(resolvedBaseDir, rawPath);
+    return loadPineScript(resolvedPath, fallback);
+  };
+};
+var MINUTE_MS = 6e4;
+var normalizeTimestampMs = (timestamp) => timestamp < 1e12 ? timestamp * 1e3 : timestamp;
+var resolveCandleDuration = (candles) => {
+  if (candles.length < 2) {
+    return MINUTE_MS;
+  }
+  const first = normalizeTimestampMs(candles[0].timestamp);
+  const second = normalizeTimestampMs(candles[1].timestamp);
+  const duration = Math.max(second - first, MINUTE_MS);
+  return Number.isFinite(duration) && duration > 0 ? duration : MINUTE_MS;
+};
+var toPineRuntimeCandles = (candles) => {
+  const candleDuration = resolveCandleDuration(candles);
+  return candles.map((candle) => {
+    const openTime = normalizeTimestampMs(candle.timestamp);
+    return {
+      open: Number(candle.open),
+      high: Number(candle.high),
+      low: Number(candle.low),
+      close: Number(candle.close),
+      volume: Number(candle.volume ?? 0),
+      openTime,
+      closeTime: openTime + candleDuration
+    };
+  });
+};
+var runPineScript = async ({
+  candles,
+  script,
+  symbol = "SYMBOL",
+  timeframe = "15",
+  inputs = {},
+  limit
+}) => {
+  const { PineTS, Indicator } = loadPinets();
+  const trimmedScript = String(script || "").trim();
+  if (!trimmedScript) {
+    throw new Error("Pine script is empty");
+  }
+  if (!Array.isArray(candles) || candles.length === 0) {
+    throw new Error("No candles provided for Pine script execution");
+  }
+  const pineCandles = toPineRuntimeCandles(candles);
+  const pine = new PineTS(
+    pineCandles,
+    symbol,
+    timeframe,
+    Math.max(1, limit ?? pineCandles.length)
+  );
+  const indicator = new Indicator(trimmedScript, inputs);
+  const context = await pine.run(indicator);
+  return context;
+};
+
+export {
+  loadPineScript,
+  createLoadPineScript,
+  runPineScript
+};