@tradejs/core 1.0.0

package/dist/strategies.js

@@ -0,0 +1,1080 @@
+"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/strategies.ts
+var strategies_exports = {};
+__export(strategies_exports, {
+  buildDefaultIndicatorPeriods: () => buildDefaultIndicatorPeriods,
+  buildEntrySignalDecision: () => buildEntrySignalDecision,
+  buildStrategySignal: () => buildStrategySignal,
+  calculateRiskRatio: () => calculateRiskRatio,
+  createLastTradeController: () => createLastTradeController,
+  createStrategyAPI: () => createStrategyAPI,
+  createStrategyIndicatorsState: () => createStrategyIndicatorsState,
+  getDirectionalTpSlPrices: () => getDirectionalTpSlPrices,
+  getStrategyMarketSnapshot: () => getStrategyMarketSnapshot,
+  mapAiRuntimeFromConfig: () => mapAiRuntimeFromConfig,
+  mapMlRuntimeFromConfig: () => mapMlRuntimeFromConfig
+});
+module.exports = __toCommonJS(strategies_exports);
+
+// src/utils/math.ts
+var import_lodash = __toESM(require("lodash"));
+var round = (value, precision = 2) => precision > 0 ? Math.round(value * 10 ** precision) / 10 ** precision : Math.round(value);
+
+// src/utils/correlation.ts
+var alignSortedCandlesByTimestamp = (coinCandles, btcCandles) => {
+  const alignedCoinCandles = [];
+  const alignedBtcCandles = [];
+  let coinIndex = 0;
+  let btcIndex = 0;
+  while (coinIndex < coinCandles.length && btcIndex < btcCandles.length) {
+    const coinTimestampMs = coinCandles[coinIndex].timestamp;
+    const btcTimestampMs = btcCandles[btcIndex].timestamp;
+    if (coinTimestampMs === btcTimestampMs) {
+      alignedCoinCandles.push(coinCandles[coinIndex]);
+      alignedBtcCandles.push(btcCandles[btcIndex]);
+      coinIndex += 1;
+      btcIndex += 1;
+    } else if (coinTimestampMs < btcTimestampMs) {
+      coinIndex += 1;
+    } else {
+      btcIndex += 1;
+    }
+  }
+  return {
+    alignedCoinCandles,
+    alignedBtcCandles
+  };
+};
+var buildReturnsFromCandles = (candles) => {
+  const returns = [];
+  for (let candleIndex = 1; candleIndex < candles.length; candleIndex += 1) {
+    const previousClose = candles[candleIndex - 1].close;
+    const currentClose = candles[candleIndex].close;
+    if (!Number.isFinite(previousClose) || !Number.isFinite(currentClose)) {
+      continue;
+    }
+    const change = (currentClose - previousClose) / previousClose;
+    returns.push(change);
+  }
+  return returns;
+};
+var calculatePearsonCorrelation = (firstSeries, secondSeries) => {
+  if (firstSeries.length !== secondSeries.length) {
+    throw new Error(
+      "calculatePearsonCorrelation: series lengths are different"
+    );
+  }
+  const length = firstSeries.length;
+  if (length === 0) return null;
+  if (length === 1) return null;
+  const sumFirst = firstSeries.reduce((sum, value) => sum + value, 0);
+  const sumSecond = secondSeries.reduce((sum, value) => sum + value, 0);
+  const meanFirst = sumFirst / length;
+  const meanSecond = sumSecond / length;
+  let covariance = 0;
+  let varianceFirst = 0;
+  let varianceSecond = 0;
+  for (let index = 0; index < length; index += 1) {
+    const deltaFirst = firstSeries[index] - meanFirst;
+    const deltaSecond = secondSeries[index] - meanSecond;
+    covariance += deltaFirst * deltaSecond;
+    varianceFirst += deltaFirst * deltaFirst;
+    varianceSecond += deltaSecond * deltaSecond;
+  }
+  if (varianceFirst === 0 || varianceSecond === 0) {
+    return null;
+  }
+  const correlation = covariance / Math.sqrt(varianceFirst * varianceSecond);
+  return correlation;
+};
+var calculateCoinBtcCorrelation = (coinCandles, btcCandles) => {
+  const { alignedCoinCandles, alignedBtcCandles } = alignSortedCandlesByTimestamp(coinCandles, btcCandles);
+  const MIN_LENGTH_FOR_CORRELATION = 10;
+  if (alignedCoinCandles.length <= MIN_LENGTH_FOR_CORRELATION) {
+    return {
+      correlation: null,
+      alignedCoinCandles,
+      alignedBtcCandles,
+      coinReturns: [],
+      btcReturns: []
+    };
+  }
+  const coinReturns = buildReturnsFromCandles(alignedCoinCandles);
+  const btcReturns = buildReturnsFromCandles(alignedBtcCandles);
+  const minReturnsLength = Math.min(coinReturns.length, btcReturns.length);
+  const slicedCoinReturns = coinReturns.slice(-minReturnsLength);
+  const slicedBtcReturns = btcReturns.slice(-minReturnsLength);
+  const correlation = calculatePearsonCorrelation(
+    slicedCoinReturns,
+    slicedBtcReturns
+  );
+  return {
+    correlation: correlation ? round(correlation) : correlation,
+    alignedCoinCandles,
+    alignedBtcCandles,
+    coinReturns: slicedCoinReturns,
+    btcReturns: slicedBtcReturns
+  };
+};
+
+// src/utils/indicators.ts
+var import_technicalindicators = require("technicalindicators");
+
+// src/constants/index.ts
+var FEE_PERCENT = 5e-3;
+var CORRELATION_WINDOW = 50;
+var ML_BASE_CANDLES_WINDOW = 50;
+
+// src/utils/array.ts
+var import_lodash2 = __toESM(require("lodash"));
+var cloneArrayValues = (record) => Object.fromEntries(
+  Object.entries(record).map(([key, value]) => [
+    key,
+    Array.isArray(value) ? value.slice() : value
+  ])
+);
+
+// src/utils/indicatorPlugins.ts
+var pluginIndicatorEntries = /* @__PURE__ */ new Map();
+var getRegisteredIndicatorEntries = () => [
+  ...pluginIndicatorEntries.values()
+];
+
+// src/utils/spread.ts
+var DEFAULT_SPREAD_WINDOW = 50;
+var toFinitePrice = (value) => {
+  if (value == null) return null;
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+};
+var toFiniteSpread = (value) => {
+  if (value == null) return null;
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+};
+var createSpreadSmoother = (window = DEFAULT_SPREAD_WINDOW) => {
+  const binanceWindow = [];
+  const coinbaseWindow = [];
+  let binanceSum = 0;
+  let coinbaseSum = 0;
+  const next = (params) => {
+    const binance = toFinitePrice(params.binancePrice);
+    const coinbase = toFinitePrice(params.coinbasePrice);
+    if (binance != null && coinbase != null) {
+      binanceWindow.push(binance);
+      coinbaseWindow.push(coinbase);
+      binanceSum += binance;
+      coinbaseSum += coinbase;
+      if (binanceWindow.length > window) {
+        binanceSum -= binanceWindow.shift() ?? 0;
+        coinbaseSum -= coinbaseWindow.shift() ?? 0;
+      }
+    }
+    let spread = toFiniteSpread(params.fallbackSpread);
+    if (binanceWindow.length > 0 && coinbaseWindow.length > 0) {
+      const avgBinance = binanceSum / binanceWindow.length;
+      const avgCoinbase = coinbaseSum / coinbaseWindow.length;
+      if (Number.isFinite(avgBinance) && avgBinance > 0) {
+        spread = (avgCoinbase - avgBinance) / avgBinance;
+      }
+    }
+    return toFiniteSpread(spread);
+  };
+  return { next };
+};
+
+// src/utils/indicators.ts
+var CANDLE_WINDOW = ML_BASE_CANDLES_WINDOW;
+var BASE_INTERVAL_MINUTES = 15;
+var INDICATOR_TIMEFRAMES = [
+  { minutes: 60, suffix: "1h" },
+  { minutes: 240, suffix: "4h" },
+  { minutes: 1440, suffix: "1d" }
+];
+var DEFAULT_INDICATOR_PERIODS = {
+  maFast: 14,
+  maMedium: 49,
+  maSlow: 50,
+  obvSma: 10,
+  atr: 14,
+  atrPctShort: 7,
+  atrPctLong: 30,
+  bb: 20,
+  bbStd: 2,
+  macdFast: 12,
+  macdSlow: 26,
+  macdSignal: 9,
+  levelLookback: 20,
+  levelDelay: 2
+};
+var ONE_HOUR_MS = 36e5;
+var ONE_DAY_MS = 864e5;
+var toMlCandle = (candle) => ({
+  open: Number(candle.open) || 0,
+  high: Number(candle.high) || 0,
+  low: Number(candle.low) || 0,
+  close: Number(candle.close) || 0,
+  volume: Number(candle.volume) || 0,
+  turnover: Number(candle.turnover) || 0,
+  timestamp: Number(candle.timestamp) || 0
+});
+var resampleCandles = (candles, targetMinutes) => {
+  if (targetMinutes <= BASE_INTERVAL_MINUTES) return candles.map(toMlCandle);
+  const bucketMs = targetMinutes * 6e4;
+  const buckets = /* @__PURE__ */ new Map();
+  for (const raw of candles) {
+    const candle = toMlCandle(raw);
+    const ts = candle.timestamp;
+    if (!Number.isFinite(ts) || ts <= 0) continue;
+    const bucket = Math.floor(ts / bucketMs) * bucketMs;
+    const current = buckets.get(bucket);
+    if (!current) {
+      buckets.set(bucket, { ...candle, timestamp: bucket });
+      continue;
+    }
+    current.high = Math.max(current.high, candle.high);
+    current.low = Math.min(current.low, candle.low);
+    current.close = candle.close;
+    current.volume += candle.volume;
+    current.turnover += candle.turnover;
+  }
+  return [...buckets.entries()].sort((a, b) => a[0] - b[0]).map(([, candle]) => candle);
+};
+var buildMlCandleIndicators = (candles, btcCandles) => ({
+  candles15m: candles.slice(-CANDLE_WINDOW).map(toMlCandle),
+  candles1h: resampleCandles(candles, 60).slice(-CANDLE_WINDOW),
+  candles4h: resampleCandles(candles, 240).slice(-CANDLE_WINDOW),
+  candles1d: resampleCandles(candles, 1440).slice(-CANDLE_WINDOW),
+  btcCandles15m: btcCandles.slice(-CANDLE_WINDOW).map(toMlCandle),
+  btcCandles1h: resampleCandles(btcCandles, 60).slice(-CANDLE_WINDOW),
+  btcCandles4h: resampleCandles(btcCandles, 240).slice(-CANDLE_WINDOW),
+  btcCandles1d: resampleCandles(btcCandles, 1440).slice(-CANDLE_WINDOW)
+});
+var percentChange = (current, previous) => {
+  if (!Number.isFinite(current) || !Number.isFinite(previous) || previous === 0) {
+    return null;
+  }
+  return (current - previous) / previous * 100;
+};
+var applyIndicatorsToHistory = (indicators, pushIndicator) => {
+  pushIndicator("maFast", indicators.maFast);
+  pushIndicator("maMedium", indicators.maMedium);
+  pushIndicator("maSlow", indicators.maSlow);
+  pushIndicator("atr", indicators.atr);
+  pushIndicator("atrPct", indicators.atrPct);
+  pushIndicator("bbUpper", indicators.bbUpper);
+  pushIndicator("bbMiddle", indicators.bbMiddle);
+  pushIndicator("bbLower", indicators.bbLower);
+  pushIndicator("obv", indicators.obv);
+  pushIndicator("smaObv", indicators.smaObv);
+  pushIndicator("macd", indicators.macd);
+  pushIndicator("macdSignal", indicators.macdSignal);
+  pushIndicator("macdHistogram", indicators.macdHistogram);
+  pushIndicator("price24hPcnt", indicators.price24hPcnt ?? void 0);
+  pushIndicator("price1hPcnt", indicators.price1hPcnt ?? void 0);
+  pushIndicator("highPrice1h", indicators.highPrice1h ?? void 0);
+  pushIndicator("lowPrice1h", indicators.lowPrice1h ?? void 0);
+  pushIndicator("volume1h", indicators.volume1h ?? void 0);
+  pushIndicator("highPrice24h", indicators.highPrice24h ?? void 0);
+  pushIndicator("lowPrice24h", indicators.lowPrice24h ?? void 0);
+  pushIndicator("volume24h", indicators.volume24h ?? void 0);
+  pushIndicator("highLevel", indicators.highLevel ?? void 0);
+  pushIndicator("lowLevel", indicators.lowLevel ?? void 0);
+  pushIndicator("prevClose", indicators.prevClose ?? void 0);
+  pushIndicator("correlation", indicators.correlation ?? void 0);
+  pushIndicator("spread", indicators.spread ?? void 0);
+};
+var createIndicators = (data, btcData = [], options = {}) => {
+  const indicatorPluginEntries = getRegisteredIndicatorEntries();
+  const includeMlPayload = options.includeMlPayload !== false;
+  const indicatorPeriods = {
+    ...DEFAULT_INDICATOR_PERIODS,
+    ...options.periods || {}
+  };
+  const closes = [];
+  const highs = [];
+  const lows = [];
+  const volumes = [];
+  const timestamps = [];
+  const candlesHistory = [];
+  const btcCandlesHistory = [];
+  const btcBinanceCandles = (options.btcBinanceData ?? []).map(toMlCandle);
+  const btcCoinbaseCandles = (options.btcCoinbaseData ?? []).map(toMlCandle);
+  const spreadSmoother = createSpreadSmoother();
+  let btcBinanceCursor = 0;
+  let btcCoinbaseCursor = 0;
+  const obv = new import_technicalindicators.OBV({ close: [], volume: [] });
+  const smaObv = new import_technicalindicators.SMA({ period: indicatorPeriods.obvSma, values: [] });
+  const ma14 = new import_technicalindicators.SMA({ period: indicatorPeriods.maFast, values: [] });
+  const ma49 = new import_technicalindicators.SMA({ period: indicatorPeriods.maMedium, values: [] });
+  const ma50 = new import_technicalindicators.SMA({ period: indicatorPeriods.maSlow, values: [] });
+  const atr = new import_technicalindicators.ATR({
+    period: indicatorPeriods.atr,
+    high: [],
+    low: [],
+    close: []
+  });
+  const atrPctShort = new import_technicalindicators.SMA({
+    period: indicatorPeriods.atrPctShort,
+    values: []
+  });
+  const atrPctLong = new import_technicalindicators.SMA({
+    period: indicatorPeriods.atrPctLong,
+    values: []
+  });
+  const bb = new import_technicalindicators.BollingerBands({
+    period: indicatorPeriods.bb,
+    values: [],
+    stdDev: indicatorPeriods.bbStd
+  });
+  const macd = new import_technicalindicators.MACD({
+    fastPeriod: indicatorPeriods.macdFast,
+    slowPeriod: indicatorPeriods.macdSlow,
+    signalPeriod: indicatorPeriods.macdSignal,
+    values: [],
+    SimpleMAOscillator: false,
+    SimpleMASignal: false
+  });
+  const indicatorHistory = {};
+  const indicatorPluginErrorShown = /* @__PURE__ */ new Set();
+  const pushIndicator = (key, value) => {
+    if (value == null) {
+      return;
+    }
+    if (!indicatorHistory[key]) {
+      indicatorHistory[key] = [];
+    }
+    indicatorHistory[key].push(value);
+    if (indicatorHistory[key].length > ML_BASE_CANDLES_WINDOW) {
+      indicatorHistory[key].splice(
+        0,
+        indicatorHistory[key].length - ML_BASE_CANDLES_WINDOW
+      );
+    }
+  };
+  const resolveCloseAtOrBefore = (candles, cursor, targetTs) => {
+    let idx = cursor;
+    while (idx + 1 < candles.length && candles[idx + 1].timestamp <= targetTs) {
+      idx += 1;
+    }
+    const close = idx < candles.length && candles[idx].timestamp <= targetTs ? candles[idx].close : null;
+    return { close, cursor: idx };
+  };
+  let window1hStart = 0;
+  let window24hStart = 0;
+  const computeWindow = (currentTimestamp, windowMs, startIdx) => {
+    const windowStart = currentTimestamp - windowMs;
+    if (timestamps.length === 0 || timestamps[0] > windowStart) {
+      return {
+        startIdx,
+        high: null,
+        low: null,
+        volume: null,
+        startClose: null,
+        hasFullWindow: false
+      };
+    }
+    let idx = startIdx;
+    while (idx < timestamps.length && timestamps[idx] < windowStart) {
+      idx += 1;
+    }
+    let high = -Infinity;
+    let low = Infinity;
+    let volume = 0;
+    for (let i = idx; i < highs.length; i += 1) {
+      const highValue = highs[i];
+      const lowValue = lows[i];
+      const volumeValue = volumes[i];
+      if (highValue > high) high = highValue;
+      if (lowValue < low) low = lowValue;
+      volume += volumeValue;
+    }
+    return {
+      startIdx: idx,
+      high,
+      low,
+      volume,
+      startClose: closes[idx],
+      hasFullWindow: true
+    };
+  };
+  const findNearestStartClose = (currentTimestamp, windowMs) => {
+    if (timestamps.length === 0) {
+      return { startClose: null, startIdx: 0 };
+    }
+    const windowStart = currentTimestamp - windowMs;
+    let idx = 0;
+    while (idx < timestamps.length && timestamps[idx] < windowStart) {
+      idx += 1;
+    }
+    if (idx <= 0) {
+      return { startClose: closes[0], startIdx: 0 };
+    }
+    if (idx >= timestamps.length) {
+      const lastIdx = timestamps.length - 1;
+      return { startClose: closes[lastIdx], startIdx: lastIdx };
+    }
+    const prevIdx = idx - 1;
+    const currentIdx = timestamps.length - 1;
+    if (idx === currentIdx && timestamps[idx] > windowStart) {
+      return { startClose: closes[prevIdx], startIdx: prevIdx };
+    }
+    const prevDiff = windowStart - timestamps[prevIdx];
+    const nextDiff = timestamps[idx] - windowStart;
+    const chosenIdx = prevDiff <= nextDiff ? prevIdx : idx;
+    return { startClose: closes[chosenIdx], startIdx: chosenIdx };
+  };
+  const next = (candle, btcCandle) => {
+    candlesHistory.push(candle);
+    if (btcCandle) {
+      btcCandlesHistory.push(btcCandle);
+    }
+    closes.push(candle.close);
+    highs.push(candle.high);
+    lows.push(candle.low);
+    volumes.push(candle.volume);
+    timestamps.push(candle.timestamp);
+    const ma14Value = ma14.nextValue(candle.close);
+    const ma49Value = ma49.nextValue(candle.close);
+    const ma50Value = ma50.nextValue(candle.close);
+    const atrValue = atr.nextValue(candle);
+    const atrPctValue = atrValue != null && Number.isFinite(atrValue) && candle.close ? atrValue / candle.close * 100 : null;
+    const atrPctShortValue = atrPctValue == null ? null : atrPctShort.nextValue(atrPctValue);
+    const atrPctLongValue = atrPctValue == null ? null : atrPctLong.nextValue(atrPctValue);
+    const atrPctRatio = typeof atrPctShortValue === "number" && Number.isFinite(atrPctShortValue) && typeof atrPctLongValue === "number" && Number.isFinite(atrPctLongValue) && atrPctLongValue !== 0 ? atrPctShortValue / atrPctLongValue : null;
+    const bbValue = bb.nextValue(candle.close);
+    const obvValue = obv.nextValue(candle);
+    const smaObvValue = obvValue == null ? null : smaObv.nextValue(obvValue);
+    const macdValue = macd.nextValue(candle.close);
+    const currentTimestamp = candle.timestamp;
+    const len = candlesHistory.length;
+    const prevCandle = len > 1 ? candlesHistory[len - 2] : null;
+    const correlation = btcCandlesHistory.length > 0 ? calculateCoinBtcCorrelation(
+      candlesHistory.slice(-CORRELATION_WINDOW),
+      btcCandlesHistory.slice(-CORRELATION_WINDOW)
+    ).correlation ?? 0 : 0;
+    let spread = null;
+    if (btcBinanceCandles.length > 0 && btcCoinbaseCandles.length > 0) {
+      const binanceResolved = resolveCloseAtOrBefore(
+        btcBinanceCandles,
+        btcBinanceCursor,
+        currentTimestamp
+      );
+      const coinbaseResolved = resolveCloseAtOrBefore(
+        btcCoinbaseCandles,
+        btcCoinbaseCursor,
+        currentTimestamp
+      );
+      btcBinanceCursor = binanceResolved.cursor;
+      btcCoinbaseCursor = coinbaseResolved.cursor;
+      if (binanceResolved.close != null && coinbaseResolved.close != null && Number.isFinite(binanceResolved.close) && Number.isFinite(coinbaseResolved.close) && binanceResolved.close > 0) {
+        spread = spreadSmoother.next({
+          binancePrice: binanceResolved.close,
+          coinbasePrice: coinbaseResolved.close
+        });
+      }
+    }
+    const computePluginSeries = (baseResult2) => {
+      const pluginSeries2 = {};
+      for (const pluginEntry of indicatorPluginEntries) {
+        if (!pluginEntry.compute) continue;
+        const historyKey = pluginEntry.historyKey || pluginEntry.indicator.id;
+        try {
+          const pluginValue = pluginEntry.compute({
+            candle,
+            btcCandle,
+            data: candlesHistory,
+            btcData: btcCandlesHistory,
+            baseResult: baseResult2
+          });
+          if (pluginValue == null || typeof pluginValue !== "number" || !Number.isFinite(pluginValue)) {
+            continue;
+          }
+          pluginSeries2[historyKey] = pluginValue;
+          pushIndicator(historyKey, pluginValue);
+        } catch (error) {
+          if (indicatorPluginErrorShown.has(historyKey)) {
+            continue;
+          }
+          indicatorPluginErrorShown.add(historyKey);
+          console.warn(
+            `Indicator plugin "${historyKey}" compute failed: ${String(error)}`
+          );
+        }
+      }
+      return pluginSeries2;
+    };
+    if (ma14Value == null || ma49Value == null || ma50Value == null || atrValue == null || !bbValue || obvValue == null || smaObvValue == null || !macdValue) {
+      computePluginSeries({
+        prevCandle,
+        correlation,
+        spread,
+        candle
+      });
+      return null;
+    }
+    const window1h = computeWindow(
+      currentTimestamp,
+      ONE_HOUR_MS,
+      window1hStart
+    );
+    window1hStart = window1h.startIdx;
+    const window24h = computeWindow(
+      currentTimestamp,
+      ONE_DAY_MS,
+      window24hStart
+    );
+    window24hStart = window24h.startIdx;
+    const price1hStart = findNearestStartClose(currentTimestamp, ONE_HOUR_MS);
+    const price24hStart = findNearestStartClose(currentTimestamp, ONE_DAY_MS);
+    const price1hPcntRaw = price1hStart.startClose != null ? percentChange(candle.close, price1hStart.startClose) : null;
+    const price24hPcntRaw = price24hStart.startClose != null ? percentChange(candle.close, price24hStart.startClose) : null;
+    const price1hPcnt = price1hPcntRaw ?? 0;
+    const price24hPcnt = price24hPcntRaw ?? 0;
+    const highPrice1h = window1h.hasFullWindow ? window1h.high : null;
+    const lowPrice1h = window1h.hasFullWindow ? window1h.low : null;
+    const volume1h = window1h.hasFullWindow ? window1h.volume : null;
+    const highPrice24h = window24h.hasFullWindow ? window24h.high : null;
+    const lowPrice24h = window24h.hasFullWindow ? window24h.low : null;
+    const volume24h = window24h.hasFullWindow ? window24h.volume : null;
+    let highLevel = null;
+    let lowLevel = null;
+    if (len >= indicatorPeriods.levelLookback + indicatorPeriods.levelDelay) {
+      const window = candlesHistory.slice(
+        len - indicatorPeriods.levelLookback - indicatorPeriods.levelDelay,
+        len - indicatorPeriods.levelDelay
+      );
+      highLevel = Math.max(...window.map((item) => item.high));
+      lowLevel = Math.min(...window.map((item) => item.low));
+    }
+    const baseResult = {
+      maFast: ma14Value,
+      maMedium: ma49Value,
+      maSlow: ma50Value,
+      atr: atrValue,
+      atrPct: atrPctRatio,
+      bbUpper: bbValue.upper,
+      bbMiddle: bbValue.middle,
+      bbLower: bbValue.lower,
+      obv: obvValue,
+      smaObv: smaObvValue,
+      macd: macdValue.MACD,
+      macdSignal: macdValue.signal,
+      macdHistogram: macdValue.histogram,
+      price24hPcnt,
+      price1hPcnt,
+      highPrice1h,
+      lowPrice1h,
+      volume1h,
+      highPrice24h,
+      lowPrice24h,
+      volume24h,
+      highLevel,
+      lowLevel,
+      prevClose: prevCandle?.close ?? null,
+      correlation,
+      spread
+    };
+    applyIndicatorsToHistory(baseResult, pushIndicator);
+    const pluginSeries = computePluginSeries({
+      ...baseResult,
+      candle,
+      prevCandle,
+      correlation
+    });
+    const result = {
+      ...baseResult,
+      ...pluginSeries,
+      candle,
+      prevCandle,
+      highLevel,
+      lowLevel,
+      correlation
+    };
+    return result;
+  };
+  data.forEach((candle, index) => {
+    next(candle, btcData[index]);
+  });
+  return {
+    next,
+    result: () => {
+      const baseHistory = cloneArrayValues(indicatorHistory);
+      if (!includeMlPayload) {
+        return baseHistory;
+      }
+      const fullHistory = {
+        ...baseHistory,
+        ...buildMlTimeframeIndicators(candlesHistory, indicatorPeriods),
+        ...buildMlCandleIndicators(candlesHistory, btcCandlesHistory),
+        ...buildIndicatorSeriesByTimeframes(
+          btcCandlesHistory,
+          indicatorPeriods,
+          "btc"
+        )
+      };
+      return fullHistory;
+    }
+  };
+};
+var buildMlTimeframeIndicators = (candles, periods = {}) => {
+  const result = {};
+  const indicatorPeriods = {
+    ...DEFAULT_INDICATOR_PERIODS,
+    ...periods
+  };
+  for (const timeframe of INDICATOR_TIMEFRAMES) {
+    const tfCandles = resampleCandles(candles, timeframe.minutes);
+    if (tfCandles.length === 0) continue;
+    const history = createIndicators(tfCandles, [], {
+      includeMlPayload: false,
+      periods: indicatorPeriods
+    }).result();
+    for (const [key, values] of Object.entries(history)) {
+      result[`${key}${timeframe.suffix}`] = values;
+    }
+  }
+  return cloneArrayValues(result);
+};
+var withSourcePrefix = (key, sourcePrefix = "") => {
+  if (!sourcePrefix) return key;
+  return `${sourcePrefix}${key[0].toUpperCase()}${key.slice(1)}`;
+};
+var buildIndicatorSeriesByTimeframes = (candles, periods, sourcePrefix = "") => {
+  const result = {};
+  if (candles.length === 0) return result;
+  const baseHistory = createIndicators(candles, [], {
+    includeMlPayload: false,
+    periods
+  }).result();
+  for (const [key, values] of Object.entries(baseHistory)) {
+    result[withSourcePrefix(key, sourcePrefix)] = values;
+  }
+  const timeframeHistory = buildMlTimeframeIndicators(candles, periods);
+  for (const [key, values] of Object.entries(timeframeHistory)) {
+    result[withSourcePrefix(key, sourcePrefix)] = values;
+  }
+  return cloneArrayValues(result);
+};
+
+// src/utils/timestamp.ts
+var import_date_fns = require("date-fns");
+var import_date_fns2 = require("date-fns");
+var getTimestamp = (days = 0) => {
+  if (days > 0) {
+    return (0, import_date_fns2.getUnixTime)((0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), days)) * 1e3;
+  }
+  return (0, import_date_fns2.getUnixTime)(/* @__PURE__ */ new Date()) * 1e3;
+};
+
+// src/utils/strategyHelpers/indicators.ts
+var buildDefaultIndicatorPeriods = (config) => ({
+  maFast: config.MA_FAST,
+  maMedium: config.MA_MEDIUM,
+  maSlow: config.MA_SLOW,
+  obvSma: config.OBV_SMA,
+  atr: config.ATR,
+  atrPctShort: config.ATR_PCT_SHORT,
+  atrPctLong: config.ATR_PCT_LONG,
+  bb: config.BB,
+  bbStd: config.BB_STD,
+  macdFast: config.MACD_FAST,
+  macdSlow: config.MACD_SLOW,
+  macdSignal: config.MACD_SIGNAL,
+  levelLookback: config.LEVEL_LOOKBACK,
+  levelDelay: config.LEVEL_DELAY
+});
+var createStrategyIndicatorsState = ({
+  env,
+  data,
+  btcData,
+  btcBinanceData,
+  btcCoinbaseData,
+  periods
+}) => {
+  let controller = env === "BACKTEST" ? createIndicators(data, btcData, {
+    periods,
+    btcBinanceData,
+    btcCoinbaseData
+  }) : null;
+  let currentBarPair;
+  const withSnapshot = (value) => Object.assign(value, {
+    snapshot: () => value.result()
+  });
+  const applyBar = (candle, btcCandle) => {
+    if (!controller) return;
+    controller.next(candle, btcCandle);
+  };
+  const ensureControllerInitialized = () => {
+    if (controller) return withSnapshot(controller);
+    controller = createIndicators(data.slice(0, -1), btcData.slice(0, -1), {
+      periods,
+      btcBinanceData,
+      btcCoinbaseData
+    });
+    const lastCandle = data[data.length - 1];
+    const lastBtcCandle = btcData[btcData.length - 1];
+    if (lastCandle && lastBtcCandle) {
+      controller.next(lastCandle, lastBtcCandle);
+    }
+    return withSnapshot(controller);
+  };
+  return {
+    isInitialized: () => controller != null,
+    setCurrentBar: (candle, btcCandle) => {
+      currentBarPair = { candle, btcCandle };
+    },
+    onBar: (candle, btcCandle) => {
+      const resolvedCandle = candle ?? currentBarPair?.candle;
+      const resolvedBtcCandle = btcCandle ?? currentBarPair?.btcCandle;
+      if (!resolvedCandle || !resolvedBtcCandle) return;
+      applyBar(resolvedCandle, resolvedBtcCandle);
+    },
+    next: (candle, btcCandle) => {
+      if (!controller) return void 0;
+      return controller.next(candle, btcCandle);
+    },
+    // Lazy bootstrap for live mode: initialize on history before current bar and then apply current bar once.
+    ensureInitializedWithCurrentBar: ensureControllerInitialized,
+    snapshot: () => ensureControllerInitialized().snapshot(),
+    latestNumber: (key) => {
+      const snapshot = ensureControllerInitialized().snapshot();
+      const value = snapshot?.[key];
+      if (!Array.isArray(value) || value.length === 0) {
+        return void 0;
+      }
+      const last = value[value.length - 1];
+      return typeof last === "number" ? last : void 0;
+    }
+  };
+};
+
+// src/utils/strategyHelpers/market.ts
+var getStrategyMarketSnapshot = async ({
+  env,
+  connector,
+  symbol,
+  interval,
+  cachedData,
+  preloadStart,
+  backtestPriceMode = "mid"
+}) => {
+  const fullData = env === "BACKTEST" ? cachedData : await connector.kline({
+    symbol,
+    start: preloadStart,
+    end: getTimestamp(),
+    cacheOnly: false,
+    interval
+  });
+  const lastCandle = fullData[fullData.length - 1];
+  let currentPrice = lastCandle.close;
+  if (env === "BACKTEST") {
+    if (backtestPriceMode === "mid") {
+      currentPrice = (lastCandle.open + lastCandle.close) / 2;
+    } else if (backtestPriceMode === "open") {
+      currentPrice = lastCandle.open;
+    } else if (backtestPriceMode === "rand") {
+      const min = Math.min(lastCandle.low, lastCandle.high);
+      const max = Math.max(lastCandle.low, lastCandle.high);
+      currentPrice = min + Math.random() * (max - min);
+    }
+  }
+  return {
+    fullData,
+    lastCandle,
+    timestamp: lastCandle.timestamp,
+    currentPrice
+  };
+};
+var calculateRiskRatio = ({
+  direction,
+  currentPrice,
+  takeProfitPrice,
+  stopLossPrice
+}) => {
+  const isLong = direction === "LONG";
+  const reward = isLong ? takeProfitPrice - currentPrice : currentPrice - takeProfitPrice;
+  const risk = isLong ? currentPrice - stopLossPrice : stopLossPrice - currentPrice;
+  return risk > 0 ? reward / risk : 0;
+};
+var getDirectionalTpSlPrices = ({
+  price,
+  direction,
+  takeProfitDelta,
+  stopLossDelta,
+  unit = "percent",
+  maxLossValue,
+  feePercent = FEE_PERCENT
+}) => {
+  const deltaFactor = unit === "percent" ? 100 : 1;
+  const tp = takeProfitDelta / deltaFactor;
+  const sl = stopLossDelta / deltaFactor;
+  const isLong = direction === "LONG";
+  const stopLossPrice = isLong ? price * (1 - sl) : price * (1 + sl);
+  const takeProfitPrice = isLong ? price * (1 + tp) : price * (1 - tp);
+  const riskRatio = calculateRiskRatio({
+    direction,
+    currentPrice: price,
+    takeProfitPrice,
+    stopLossPrice
+  });
+  const slPercent = unit === "percent" ? stopLossDelta : stopLossDelta * 100;
+  const qty = typeof maxLossValue === "number" && Number.isFinite(maxLossValue) && maxLossValue > 0 ? maxLossValue / (price * (slPercent + feePercent) / 100) : void 0;
+  return {
+    stopLossPrice,
+    takeProfitPrice,
+    riskRatio,
+    qty
+  };
+};
+
+// src/utils/strategyHelpers/state.ts
+var createLastTradeController = ({
+  env,
+  enabled = env ? env === "BACKTEST" : true,
+  cooldownMs = 864e5
+}) => {
+  let lastTradeTimestamp = null;
+  return {
+    isInCooldown: (timestamp) => Boolean(
+      enabled && lastTradeTimestamp != null && timestamp <= lastTradeTimestamp + cooldownMs
+    ),
+    markTrade: (timestamp) => {
+      if (!enabled) return;
+      lastTradeTimestamp = timestamp;
+    },
+    getLastTradeTimestamp: () => lastTradeTimestamp
+  };
+};
+
+// src/utils/uuid.ts
+var import_uuid = require("uuid");
+var uuid = (len = 12) => {
+  const uuid2 = (0, import_uuid.v4)();
+  return uuid2.slice(-len);
+};
+
+// src/utils/strategyHelpers/signalBuilders.ts
+var mapAiRuntimeFromConfig = (config, overrides = {}) => ({
+  enabled: Boolean(config.AI_ENABLED ?? true),
+  minQuality: Number(config.MIN_AI_QUALITY ?? 4),
+  ...overrides
+});
+var mapMlRuntimeFromConfig = (config, overrides = {}) => ({
+  enabled: Boolean(config.ML_ENABLED ?? true),
+  mlThreshold: Number(config.ML_THRESHOLD ?? 0),
+  ...overrides
+});
+var buildStrategySignal = ({
+  signalId,
+  strategy,
+  symbol,
+  interval,
+  direction,
+  timestamp,
+  prices,
+  figures = {},
+  indicators = {},
+  additionalIndicators,
+  isConfigFromBacktest
+}) => ({
+  signalId,
+  strategy,
+  symbol,
+  interval,
+  direction,
+  timestamp,
+  figures,
+  prices,
+  indicators,
+  additionalIndicators,
+  isConfigFromBacktest
+});
+var buildEntrySignalDecision = ({
+  code,
+  entryContext,
+  figures,
+  indicators,
+  additionalIndicators,
+  signalId,
+  orderPlan,
+  runtime
+}) => ({
+  kind: "entry",
+  code,
+  entryContext,
+  signal: buildStrategySignal({
+    signalId: signalId ?? uuid(),
+    strategy: entryContext.strategy,
+    symbol: entryContext.symbol,
+    interval: entryContext.interval,
+    direction: entryContext.direction,
+    timestamp: entryContext.timestamp,
+    prices: entryContext.prices,
+    figures,
+    indicators,
+    additionalIndicators,
+    isConfigFromBacktest: entryContext.isConfigFromBacktest
+  }),
+  orderPlan,
+  runtime
+});
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var toDefaultEntryCode = (strategy, direction) => `${strategy.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_${direction}_ENTRY`;
+var resolveTakeProfitPrice = ({
+  direction,
+  takeProfits
+}) => {
+  if (!Array.isArray(takeProfits) || takeProfits.length === 0) {
+    throw new Error("strategyApi.entry requires at least one takeProfit");
+  }
+  const prices = takeProfits.map((tp) => tp?.price).filter((price) => isFiniteNumber(price));
+  if (prices.length === 0) {
+    throw new Error("strategyApi.entry requires finite takeProfit prices");
+  }
+  return direction === "LONG" ? Math.max(...prices) : Math.min(...prices);
+};
+var createStrategyAPI = ({
+  strategy,
+  symbol,
+  interval,
+  env,
+  connector,
+  cachedData,
+  indicatorsState,
+  preloadStart,
+  backtestPriceMode,
+  isConfigFromBacktest
+}) => {
+  const getCurrentPosition = () => connector.getPosition(symbol);
+  const isPositionExists = async () => {
+    const position = await getCurrentPosition();
+    return Boolean(
+      position && typeof position.qty === "number" && position.qty > 0
+    );
+  };
+  const getMarketData = async (params = {}) => {
+    const resolvedPreloadStart = params.preloadStart ?? preloadStart;
+    if (typeof resolvedPreloadStart !== "number") {
+      throw new Error("strategyApi.getMarketData requires preloadStart");
+    }
+    const snapshot = await getStrategyMarketSnapshot({
+      env,
+      connector,
+      symbol,
+      interval,
+      cachedData,
+      preloadStart: resolvedPreloadStart,
+      backtestPriceMode: params.backtestPriceMode ?? backtestPriceMode
+    });
+    return snapshot;
+  };
+  return {
+    skip: (code) => ({ kind: "skip", code }),
+    entry: async ({
+      code,
+      direction,
+      figures,
+      indicators,
+      additionalIndicators,
+      signalId,
+      orderPlan,
+      runtime
+    }) => {
+      const marketData = await getMarketData();
+      const currentPrice = marketData.currentPrice;
+      const timestamp = marketData.timestamp;
+      const stopLossPrice = orderPlan.stopLossPrice;
+      const takeProfitPrice = resolveTakeProfitPrice({
+        direction,
+        takeProfits: orderPlan.takeProfits
+      });
+      if (!isFiniteNumber(stopLossPrice)) {
+        throw new Error(
+          "strategyApi.entry requires finite orderPlan.stopLossPrice"
+        );
+      }
+      const resolvedCode = code ?? toDefaultEntryCode(String(strategy), direction);
+      const riskRatio = calculateRiskRatio({
+        direction,
+        currentPrice,
+        takeProfitPrice,
+        stopLossPrice
+      });
+      return buildEntrySignalDecision({
+        code: resolvedCode,
+        entryContext: {
+          strategy,
+          symbol,
+          interval,
+          direction,
+          timestamp,
+          prices: {
+            currentPrice,
+            takeProfitPrice,
+            stopLossPrice,
+            riskRatio
+          },
+          isConfigFromBacktest
+        },
+        figures,
+        indicators,
+        additionalIndicators,
+        signalId,
+        orderPlan,
+        runtime
+      });
+    },
+    getMarketData,
+    nextIndicators: (candle, btcCandle) => indicatorsState?.next(candle, btcCandle),
+    getCurrentPosition,
+    isCurrentPositionExists: isPositionExists,
+    getDirectionalTpSlPrices: (params) => getDirectionalTpSlPrices(params),
+    createLastTradeController: (params) => createLastTradeController({
+      env,
+      ...params
+    })
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildDefaultIndicatorPeriods,
+  buildEntrySignalDecision,
+  buildStrategySignal,
+  calculateRiskRatio,
+  createLastTradeController,
+  createStrategyAPI,
+  createStrategyIndicatorsState,
+  getDirectionalTpSlPrices,
+  getStrategyMarketSnapshot,
+  mapAiRuntimeFromConfig,
+  mapMlRuntimeFromConfig
+});