@tradejs/strategies 1.0.6 → 1.0.9

package/dist/strategy-QEIPAPY4.mjs

@@ -0,0 +1,373 @@
+import {
+  config,
+  trendShiftManifest
+} from "./chunk-SOVTOGY4.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+
+// src/TrendShift/strategy.ts
+import { createStrategyRuntime } from "@tradejs/node/strategies";
+
+// src/TrendShift/core.ts
+import { round } from "@tradejs/core/math";
+
+// src/TrendShift/engine.ts
+var clampPositive = (value, fallback) => Number.isFinite(value) && value > 0 ? value : fallback;
+var calculateTrueRange = (candle, prevClose) => {
+  const high = Number(candle.high);
+  const low = Number(candle.low);
+  const close = Number(candle.close);
+  if (!Number.isFinite(high) || !Number.isFinite(low) || !Number.isFinite(close)) {
+    return 0;
+  }
+  if (prevClose == null || !Number.isFinite(prevClose)) {
+    return Math.max(high - low, 0);
+  }
+  return Math.max(
+    high - low,
+    Math.abs(high - prevClose),
+    Math.abs(low - prevClose)
+  );
+};
+var updateAtrState = ({
+  atrState,
+  tr,
+  period
+}) => {
+  const safeTr = Number.isFinite(tr) ? Math.max(tr, 0) : 0;
+  const safePeriod = Math.max(1, Math.floor(period));
+  if (atrState.value == null) {
+    return {
+      value: safeTr,
+      count: 1
+    };
+  }
+  if (atrState.count < safePeriod) {
+    const nextCount = atrState.count + 1;
+    return {
+      value: (atrState.value * atrState.count + safeTr) / nextCount,
+      count: nextCount
+    };
+  }
+  return {
+    value: (atrState.value * (safePeriod - 1) + safeTr) / safePeriod,
+    count: atrState.count + 1
+  };
+};
+var trimSeries = (series, maxPoints) => series.length <= maxPoints ? series : series.slice(series.length - maxPoints);
+var asDirection = (trendState) => trendState === 1 ? "LONG" : "SHORT";
+var buildTrendShiftSignalContext = ({
+  snapshot,
+  indicators
+}) => {
+  const maFastSeries = Array.isArray(indicators?.maFast) ? indicators?.maFast : [];
+  const maSlowSeries = Array.isArray(indicators?.maSlow) ? indicators?.maSlow : [];
+  const maFast = maFastSeries[maFastSeries.length - 1];
+  const maSlow = maSlowSeries[maSlowSeries.length - 1];
+  const coinBias = Number.isFinite(maFast) && Number.isFinite(maSlow) ? maFast > maSlow ? "bullish" : maFast < maSlow ? "bearish" : "neutral" : "unknown";
+  const signalDirection = snapshot.bullFlip ? "LONG" : snapshot.bearFlip ? "SHORT" : asDirection(snapshot.trendState);
+  const coinBiasAligned = coinBias === "unknown" || coinBias === "neutral" ? null : signalDirection === "LONG" ? coinBias === "bullish" : coinBias === "bearish";
+  return {
+    signalDirection,
+    trendState: snapshot.trendState,
+    rawTrend: snapshot.rawTrend,
+    confirmedFlip: snapshot.bullFlip || snapshot.bearFlip,
+    bullFlip: snapshot.bullFlip,
+    bearFlip: snapshot.bearFlip,
+    bullFlipRaw: snapshot.bullFlipRaw,
+    bearFlipRaw: snapshot.bearFlipRaw,
+    flipDistanceOk: snapshot.flipDistanceOk,
+    closeVsAvgPct: snapshot.closeVsAvgPct,
+    bandWidthPct: snapshot.bandWidthPct,
+    avgSlopePct: snapshot.avgSlopePct,
+    distanceAtrRatio: snapshot.distanceAtrRatio,
+    adaptiveAtr: snapshot.adaptiveAtr,
+    avg: snapshot.avg,
+    upper: snapshot.upper,
+    lower: snapshot.lower,
+    hold: snapshot.hold,
+    currentPrice: snapshot.close,
+    coinMaFast: Number.isFinite(maFast) ? maFast : null,
+    coinMaSlow: Number.isFinite(maSlow) ? maSlow : null,
+    coinBias,
+    coinBiasAligned
+  };
+};
+var getConfigNumbers = (config2) => ({
+  mult: clampPositive(config2.TRENDSHIFT_MULTIPLICATIVE_FACTOR, 4),
+  slope: clampPositive(config2.TRENDSHIFT_SLOPE, 12),
+  atrLength: Math.max(1, Math.floor(config2.TRENDSHIFT_ATR_LENGTH ?? 150)),
+  widthPct: clampPositive(config2.TRENDSHIFT_WIDTH_PCT, 75) / 100,
+  minFlipAtr: Math.max(0, Number(config2.TRENDSHIFT_MIN_FLIP_DISTANCE_ATR ?? 0)),
+  confirmFlipWithClose: Boolean(config2.TRENDSHIFT_CONFIRM_FLIP_WITH_CLOSE),
+  maxFigurePoints: Math.max(
+    20,
+    Math.floor(config2.TRENDSHIFT_MAX_FIGURE_POINTS ?? 180)
+  )
+});
+var createTrendShiftEngine = ({
+  config: config2,
+  initialCandles = []
+}) => {
+  const {
+    mult,
+    slope,
+    atrLength,
+    widthPct,
+    minFlipAtr,
+    confirmFlipWithClose,
+    maxFigurePoints
+  } = getConfigNumbers(config2);
+  const state = {
+    atrState: {
+      value: null,
+      count: 0
+    },
+    avg: null,
+    hold: null,
+    rawTrend: 1,
+    trendState: 1,
+    prevClose: null,
+    series: {
+      avg: [],
+      upper: [],
+      lower: []
+    },
+    snapshot: null
+  };
+  const apply = (candle) => {
+    const close = Number(candle.close);
+    if (!Number.isFinite(close)) {
+      return {
+        snapshot: state.snapshot,
+        series: state.series
+      };
+    }
+    const tr = calculateTrueRange(candle, state.prevClose);
+    state.atrState = updateAtrState({
+      atrState: state.atrState,
+      tr,
+      period: atrLength
+    });
+    const adaptiveAtr = Math.max((state.atrState.value ?? tr) * mult, 1e-9);
+    const prevAvg = state.avg ?? close;
+    const prevHold = state.hold ?? adaptiveAtr;
+    const prevRawTrend = state.rawTrend;
+    const prevTrendState = state.trendState;
+    const avg = Math.abs(close - prevAvg) > adaptiveAtr ? (close + prevAvg) / 2 : prevAvg + prevRawTrend * (prevHold / mult / Math.max(slope, 1));
+    const rawTrend = avg > prevAvg ? 1 : avg < prevAvg ? -1 : prevRawTrend;
+    const hold = rawTrend !== prevRawTrend ? adaptiveAtr : prevHold + (adaptiveAtr - prevHold) / Math.max(slope, 1);
+    const upper = avg + widthPct * hold;
+    const lower = avg - widthPct * hold;
+    const closeDistance = Math.abs(close - avg);
+    const flipDistanceOk = closeDistance >= adaptiveAtr * minFlipAtr;
+    const bullFlipRaw = rawTrend === 1 && prevTrendState !== 1;
+    const bearFlipRaw = rawTrend === -1 && prevTrendState !== -1;
+    const bullFlip = bullFlipRaw && flipDistanceOk && (!confirmFlipWithClose || close > avg);
+    const bearFlip = bearFlipRaw && flipDistanceOk && (!confirmFlipWithClose || close < avg);
+    const trendState = bullFlip ? 1 : bearFlip ? -1 : prevTrendState;
+    const closeVsAvgPct = avg !== 0 ? (close - avg) / avg * 100 : 0;
+    const bandWidthPct = avg !== 0 ? (upper - lower) / avg * 100 : 0;
+    const avgSlopePct = prevAvg !== 0 ? (avg - prevAvg) / prevAvg * 100 : 0;
+    const distanceAtrRatio = adaptiveAtr > 0 ? closeDistance / adaptiveAtr : 0;
+    const labelOffset = hold * 0.2;
+    state.avg = avg;
+    state.hold = hold;
+    state.rawTrend = rawTrend;
+    state.trendState = trendState;
+    state.prevClose = close;
+    state.series.avg = trimSeries(
+      [...state.series.avg, { timestamp: candle.timestamp, value: avg }],
+      maxFigurePoints
+    );
+    state.series.upper = trimSeries(
+      [...state.series.upper, { timestamp: candle.timestamp, value: upper }],
+      maxFigurePoints
+    );
+    state.series.lower = trimSeries(
+      [...state.series.lower, { timestamp: candle.timestamp, value: lower }],
+      maxFigurePoints
+    );
+    state.snapshot = {
+      avg,
+      upper,
+      lower,
+      hold,
+      adaptiveAtr,
+      rawTrend,
+      trendState,
+      bullFlipRaw,
+      bearFlipRaw,
+      bullFlip,
+      bearFlip,
+      flipDistanceOk,
+      closeVsAvgPct,
+      bandWidthPct,
+      avgSlopePct,
+      distanceAtrRatio,
+      labelOffset,
+      timestamp: candle.timestamp,
+      close
+    };
+    return {
+      snapshot: state.snapshot,
+      series: state.series
+    };
+  };
+  for (const candle of initialCandles) {
+    apply(candle);
+  }
+  return {
+    next: apply,
+    getState: () => ({
+      snapshot: state.snapshot,
+      series: state.series
+    })
+  };
+};
+
+// src/TrendShift/figures.ts
+var buildTrendShiftFigures = ({
+  series,
+  direction,
+  entryTimestamp,
+  entryPrice
+}) => {
+  const trendColor = direction === "LONG" ? "#00b894" : "#d63031";
+  const lines = [
+    {
+      id: "trendshift-upper",
+      kind: "trendshift_upper",
+      points: series.upper,
+      color: trendColor,
+      width: 1,
+      style: "dashed"
+    },
+    {
+      id: "trendshift-avg",
+      kind: "trendshift_avg",
+      points: series.avg,
+      color: trendColor,
+      width: 2,
+      style: "solid"
+    },
+    {
+      id: "trendshift-lower",
+      kind: "trendshift_lower",
+      points: series.lower,
+      color: trendColor,
+      width: 1,
+      style: "dashed"
+    }
+  ].filter((line) => Array.isArray(line.points) && line.points.length > 0);
+  const points = [
+    {
+      id: `trendshift-entry-${entryTimestamp}`,
+      kind: "trendshift_entry",
+      points: [{ timestamp: entryTimestamp, value: entryPrice }],
+      color: trendColor,
+      radius: 4
+    }
+  ];
+  return { lines, points };
+};
+
+// src/TrendShift/core.ts
+var isOpenPosition = (position) => Boolean(
+  position && typeof position.price === "number" && Number.isFinite(position.price) && typeof position.qty === "number" && Number.isFinite(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
+);
+var createTrendShiftCore = async ({ config: config2, data: initialData, strategyApi, indicatorsState }) => {
+  const engine = createTrendShiftEngine({
+    config: config2,
+    initialCandles: initialData
+  });
+  const lastTradeController = strategyApi.createLastTradeController();
+  return async (candle) => {
+    indicatorsState.onBar();
+    const runtimeState = engine.next(candle);
+    const snapshot = runtimeState.snapshot;
+    if (!snapshot) {
+      return strategyApi.skip("WAIT_DATA");
+    }
+    const position = await strategyApi.getCurrentPosition();
+    if (isOpenPosition(position)) {
+      const oppositeBullExit = position.direction === "SHORT" && snapshot.bullFlip;
+      const oppositeBearExit = position.direction === "LONG" && snapshot.bearFlip;
+      if (Boolean(config2.TRENDSHIFT_EXIT_ON_OPPOSITE_FLIP) && (oppositeBullExit || oppositeBearExit)) {
+        return strategyApi.exit({
+          code: "TRENDSHIFT_OPPOSITE_FLIP_EXIT",
+          direction: position.direction
+        });
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const isBullEntry = snapshot.bullFlip;
+    const isBearEntry = snapshot.bearFlip;
+    if (!isBullEntry && !isBearEntry) {
+      return strategyApi.skip("NO_SIGNAL");
+    }
+    const modeConfig = isBullEntry ? config2.LONG : config2.SHORT;
+    if (!modeConfig.enable) {
+      return strategyApi.skip("STRATEGY_DISABLED");
+    }
+    const indicators = indicatorsState.snapshot();
+    const { timestamp, currentPrice } = await strategyApi.getMarketData();
+    const direction = modeConfig.direction;
+    const signalContext = buildTrendShiftSignalContext({
+      snapshot: {
+        ...snapshot,
+        close: currentPrice
+      },
+      indicators
+    });
+    const { stopLossPrice, takeProfitPrice, riskRatio, qty } = strategyApi.getDirectionalTpSlPrices({
+      price: currentPrice,
+      direction,
+      takeProfitDelta: modeConfig.TP,
+      stopLossDelta: modeConfig.SL,
+      unit: "percent",
+      maxLossValue: config2.MAX_LOSS_VALUE,
+      feePercent: Number(config2.FEE_PERCENT ?? 0)
+    });
+    if (!qty || !Number.isFinite(qty) || qty <= 0) {
+      return strategyApi.skip("INVALID_QTY");
+    }
+    if (riskRatio <= modeConfig.minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${round(riskRatio)}`);
+    }
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: isBullEntry ? "TRENDSHIFT_BULLISH_FLIP" : "TRENDSHIFT_BEARISH_FLIP",
+      direction,
+      indicators,
+      additionalIndicators: {
+        trendShiftContext: signalContext
+      },
+      figures: buildTrendShiftFigures({
+        series: runtimeState.series,
+        direction,
+        entryTimestamp: timestamp,
+        entryPrice: currentPrice
+      }),
+      orderPlan: {
+        qty,
+        stopLossPrice,
+        takeProfits: [{ rate: 1, price: takeProfitPrice }]
+      }
+    });
+  };
+};
+
+// src/TrendShift/strategy.ts
+var TrendShiftStrategyCreator = createStrategyRuntime({
+  strategyName: "TrendShift",
+  defaults: config,
+  createCore: createTrendShiftCore,
+  manifest: trendShiftManifest,
+  strategyDirectory: __dirname
+});
+export {
+  TrendShiftStrategyCreator
+};

package/dist/{strategy-6TS2NFSC.mjs → strategy-WYN4FZ5S.mjs}

@@ -1,65 +1,14 @@
 import {
   buildVolumeDivergenceSetupFeatures,
+  config,
   getVolumeDivergenceEntryThresholds,
   volumeDivergenceManifest
-} from "./chunk-XMRB45ZO.mjs";
+} from "./chunk-QVWMBYYM.mjs";
 import "./chunk-HEBXNMVQ.mjs";
 
 // src/VolumeDivergence/strategy.ts
 import { createStrategyRuntime } from "@tradejs/node/strategies";
 
-// src/VolumeDivergence/config.ts
-var config = {
-  ENV: "BACKTEST",
-  INTERVAL: "15",
-  MAKE_ORDERS: true,
-  CLOSE_OPPOSITE_POSITIONS: false,
-  BACKTEST_PRICE_MODE: "mid",
-  AI_ENABLED: false,
-  ML_ENABLED: false,
-  ML_THRESHOLD: 0.1,
-  MIN_AI_QUALITY: 3,
-  FEE_PERCENT: 5e-3,
-  MAX_LOSS_VALUE: 10,
-  MA_FAST: 14,
-  MA_MEDIUM: 49,
-  MA_SLOW: 50,
-  OBV_SMA: 10,
-  ATR: 14,
-  ATR_PCT_SHORT: 7,
-  ATR_PCT_LONG: 30,
-  BB: 20,
-  BB_STD: 2,
-  MACD_FAST: 12,
-  MACD_SLOW: 26,
-  MACD_SIGNAL: 9,
-  LEVEL_LOOKBACK: 20,
-  LEVEL_DELAY: 2,
-  NORMALIZATION_LENGTH: 100,
-  PIVOT_LOOKBACK_LEFT: 8,
-  PIVOT_LOOKBACK_RIGHT: 3,
-  MIN_BARS_BETWEEN_PIVOTS: 4,
-  MAX_BARS_BETWEEN_PIVOTS: 36,
-  ALLOW_STRUCTURE_ADVANCE_ENTRY: false,
-  MIN_DIVERGENCE_AMPLITUDE_ATR_RATIO: 0.35,
-  MIN_RECLAIM_PCT: 105,
-  MIN_CONFIRMATION_CANDLE_QUALITY: 0.58,
-  BULLISH: {
-    enable: true,
-    direction: "LONG",
-    TP: 4,
-    SL: 1.3,
-    minRiskRatio: 2
-  },
-  BEARISH: {
-    enable: true,
-    direction: "SHORT",
-    TP: 4,
-    SL: 1.3,
-    minRiskRatio: 2
-  }
-};
-
 // src/VolumeDivergence/core.ts
 import { round } from "@tradejs/core/math";
 
@@ -114,57 +63,11 @@ var buildVolumeDivergenceFigures = ({
 });
 
 // src/VolumeDivergence/core.ts
-var BREAK_EVEN_TRIGGER_RISK_MULTIPLIER = 0.5;
 var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
 var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
 var isOpenPosition = (position) => Boolean(
   position && typeof position.price === "number" && Number.isFinite(position.price) && typeof position.qty === "number" && Number.isFinite(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
 );
-var getFavorableMovePct = ({
-  direction,
-  entryPrice,
-  currentPrice
-}) => {
-  if (!Number.isFinite(entryPrice) || !Number.isFinite(currentPrice) || entryPrice <= 0) {
-    return null;
-  }
-  return direction === "LONG" ? (currentPrice - entryPrice) / entryPrice * 100 : (entryPrice - currentPrice) / entryPrice * 100;
-};
-var getPositionStopLossPrice = (position) => {
-  if (!position || typeof position !== "object") {
-    return null;
-  }
-  const slPrice = Number(
-    position.slPrice ?? Number.NaN
-  );
-  if (Number.isFinite(slPrice)) {
-    return slPrice;
-  }
-  const signalStopLossPrice = Number(
-    position.signal?.prices?.stopLossPrice ?? Number.NaN
-  );
-  return Number.isFinite(signalStopLossPrice) ? signalStopLossPrice : null;
-};
-var getPositionRiskPct = ({
-  direction,
-  entryPrice,
-  stopLossPrice
-}) => {
-  if (stopLossPrice == null || !Number.isFinite(entryPrice) || !Number.isFinite(stopLossPrice) || entryPrice <= 0) {
-    return null;
-  }
-  return direction === "LONG" ? (entryPrice - stopLossPrice) / entryPrice * 100 : (stopLossPrice - entryPrice) / entryPrice * 100;
-};
-var isBreakEvenStopAlreadyApplied = ({
-  direction,
-  entryPrice,
-  stopLossPrice
-}) => {
-  if (stopLossPrice == null || !Number.isFinite(entryPrice) || !Number.isFinite(stopLossPrice)) {
-    return false;
-  }
-  return direction === "LONG" ? stopLossPrice >= entryPrice : stopLossPrice <= entryPrice;
-};
 var compactQueue = (queue) => {
   if (queue.start <= 1024 || queue.start * 2 <= queue.indices.length) {
     return;
@@ -565,32 +468,6 @@ var createVolumeDivergenceCore = async ({ config: config2, strategyApi, indicato
     const timestamp = Number(candle.timestamp);
     const currentPosition = await strategyApi.getCurrentPosition();
     if (isOpenPosition(currentPosition)) {
-      const { currentPrice: currentPrice2 } = await strategyApi.getMarketData();
-      const activeModeConfig = currentPosition.direction === "LONG" ? BULLISH : BEARISH;
-      const currentStopLossPrice = getPositionStopLossPrice(currentPosition);
-      const favorableMovePct = getFavorableMovePct({
-        direction: currentPosition.direction,
-        entryPrice: currentPosition.price,
-        currentPrice: currentPrice2
-      });
-      const currentPositionRiskPct = getPositionRiskPct({
-        direction: currentPosition.direction,
-        entryPrice: currentPosition.price,
-        stopLossPrice: currentStopLossPrice
-      });
-      if (!isBreakEvenStopAlreadyApplied({
-        direction: currentPosition.direction,
-        entryPrice: currentPosition.price,
-        stopLossPrice: currentStopLossPrice
-      }) && favorableMovePct != null && favorableMovePct >= (currentPositionRiskPct ?? activeModeConfig.SL) * BREAK_EVEN_TRIGGER_RISK_MULTIPLIER) {
-        return strategyApi.protect({
-          code: "VOLUME_DIVERGENCE_MOVE_STOP_TO_BREAK_EVEN",
-          protectPlan: {
-            direction: currentPosition.direction,
-            stopLossPrice: currentPosition.price
-          }
-        });
-      }
       return strategyApi.skip("POSITION_EXISTS");
     }
     if (candleWindow.length < PIVOT_LOOKBACK_LEFT + PIVOT_LOOKBACK_RIGHT + 2) {