@tradejs/strategies 1.0.5 → 1.0.6

package/dist/strategy-AFIGEHDS.mjs

@@ -0,0 +1,418 @@
+import {
+  buildTrendlineStructuralContext,
+  buildTrendlineTimingContext,
+  config,
+  trendLineManifest
+} from "./chunk-H2TU2YMA.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+
+// src/TrendLine/strategy.ts
+import { createStrategyRuntime } from "@tradejs/node/strategies";
+
+// src/TrendLine/core.ts
+import { round as round2 } from "@tradejs/core/math";
+import { createTrendlineEngine } from "@tradejs/core/indicators";
+
+// src/TrendLine/filters.ts
+import { diffRel } from "@tradejs/core/math";
+import { ATR_PCT } from "@tradejs/indicators";
+var MAX_CANDLE_VOLATILITY = 0.025;
+var filterByVeryVolatility = (data) => {
+  const lastCandle = data[data.length - 1];
+  const prevCandle = data[data.length - 2];
+  const isVeryVolatility = diffRel(lastCandle.low, lastCandle.high) > MAX_CANDLE_VOLATILITY || diffRel(prevCandle.low, prevCandle.high) > MAX_CANDLE_VOLATILITY;
+  if (isVeryVolatility) {
+    return false;
+  }
+  return true;
+};
+
+// src/TrendLine/figures.ts
+var buildTrendLineFigures = (bestLine) => ({
+  lines: [
+    {
+      id: bestLine.id,
+      kind: "trendline",
+      points: [...bestLine.points ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: bestLine.mode === "lows" ? "#facc15" : "#fb923c",
+      width: 2,
+      style: "solid"
+    }
+  ],
+  points: [
+    {
+      id: `${bestLine.id}-points`,
+      kind: "trendline_points",
+      points: [...bestLine.points ?? [], ...bestLine.touches ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: "#ef4444",
+      radius: 4
+    }
+  ]
+});
+
+// src/TrendLine/risk.ts
+import { round } from "@tradejs/core/math";
+var MIN_STOP_BUFFER_PCT = 0.15;
+var LINE_BUFFER_ATR_FACTOR = 0.35;
+var LINE_BUFFER_BASE_SL_FACTOR = 0.15;
+var ATR_STOP_FLOOR_FACTOR = 0.8;
+var MIN_STOP_LOSS_FACTOR = 0.75;
+var MAX_STOP_LOSS_FACTOR = 2.25;
+var clampNumber = (value, min, max) => Math.min(Math.max(value, min), max);
+var getTimingStopFactor = (entryTiming) => {
+  if (entryTiming === "ready_retest") {
+    return 0.9;
+  }
+  if (entryTiming === "ready_follow_through") {
+    return 1.05;
+  }
+  return 1;
+};
+var getTimingTargetRiskRatio = ({
+  direction,
+  entryTiming
+}) => {
+  if (direction === "LONG") {
+    if (entryTiming === "ready_retest") {
+      return 2.45;
+    }
+    if (entryTiming === "ready_follow_through") {
+      return 2.3;
+    }
+    return 2.6;
+  }
+  if (entryTiming === "ready_retest") {
+    return 2.3;
+  }
+  if (entryTiming === "ready_follow_through") {
+    return 2.15;
+  }
+  return 2.45;
+};
+var buildTrendlineRiskPlan = ({
+  direction,
+  modeConfig,
+  structuralContext,
+  timingContext
+}) => {
+  const baseStopLossDelta = modeConfig.SL;
+  const atrPct = structuralContext.atrPct ?? baseStopLossDelta;
+  const priceVsLinePctAbs = structuralContext.priceVsLinePctAbs ?? 0;
+  const breakVsAtrRatio = structuralContext.breakVsAtrRatio ?? 0;
+  const touches = structuralContext.touches ?? 0;
+  const distance = structuralContext.distance ?? null;
+  const lineBufferPct = Math.max(
+    atrPct * LINE_BUFFER_ATR_FACTOR,
+    baseStopLossDelta * LINE_BUFFER_BASE_SL_FACTOR,
+    MIN_STOP_BUFFER_PCT
+  );
+  const lineInvalidationPct = priceVsLinePctAbs + lineBufferPct;
+  const volatilityFloorPct = Math.max(
+    atrPct * ATR_STOP_FLOOR_FACTOR,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR
+  );
+  let stopLossDelta = Math.max(lineInvalidationPct, volatilityFloorPct);
+  if (touches >= 6) {
+    stopLossDelta *= 0.95;
+  } else if (touches > 0 && touches <= 4) {
+    stopLossDelta *= 1.05;
+  }
+  if (distance != null && distance >= 250) {
+    stopLossDelta *= 1.08;
+  } else if (distance != null && distance <= 120) {
+    stopLossDelta *= 0.95;
+  }
+  stopLossDelta *= getTimingStopFactor(timingContext.entryTiming);
+  if (direction === "SHORT") {
+    stopLossDelta *= 1.08;
+  }
+  if (breakVsAtrRatio >= 1.5) {
+    stopLossDelta *= 0.95;
+  }
+  stopLossDelta = clampNumber(
+    stopLossDelta,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR,
+    baseStopLossDelta * MAX_STOP_LOSS_FACTOR
+  );
+  let targetRiskRatio = getTimingTargetRiskRatio({
+    direction,
+    entryTiming: timingContext.entryTiming
+  });
+  if (breakVsAtrRatio >= 1.25) {
+    targetRiskRatio += 0.2;
+  } else if (breakVsAtrRatio > 0 && breakVsAtrRatio < 0.75) {
+    targetRiskRatio -= 0.15;
+  }
+  if (touches >= 6) {
+    targetRiskRatio += 0.1;
+  }
+  if (distance != null && distance >= 120 && distance <= 350) {
+    targetRiskRatio += 0.1;
+  }
+  if (direction === "SHORT" && distance != null && distance > 450) {
+    targetRiskRatio -= 0.25;
+  }
+  if (direction === "LONG" && distance != null && distance > 500) {
+    targetRiskRatio -= 0.15;
+  }
+  const minTargetRiskRatio = modeConfig.minRiskRatio + 0.05;
+  const maxTargetRiskRatio = Math.max(modeConfig.TP / modeConfig.SL, minTargetRiskRatio) + 0.4;
+  targetRiskRatio = clampNumber(
+    targetRiskRatio,
+    minTargetRiskRatio,
+    maxTargetRiskRatio
+  );
+  return {
+    stopLossDelta: round(stopLossDelta, 3),
+    targetRiskRatio: round(targetRiskRatio, 2),
+    takeProfitDelta: round(stopLossDelta * targetRiskRatio, 3)
+  };
+};
+
+// src/TrendLine/core.ts
+var BREAK_EVEN_TRIGGER_RISK_MULTIPLIER = 0.5;
+var buildTrendlineSignalSeed = ({
+  direction,
+  currentPrice,
+  indicators,
+  bestLine,
+  trendlineTiming
+}) => ({
+  direction,
+  prices: { currentPrice },
+  indicators,
+  additionalIndicators: {
+    touches: bestLine.touches.length + 2,
+    distance: bestLine.distance,
+    trendLine: bestLine,
+    ...trendlineTiming ? { trendlineTiming } : {}
+  },
+  figures: {
+    trendLine: bestLine
+  }
+});
+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 isFailedBreakout = ({
+  direction,
+  priceVsLinePct
+}) => {
+  if (priceVsLinePct == null) {
+    return false;
+  }
+  return direction === "LONG" ? priceVsLinePct < 0 : priceVsLinePct > 0;
+};
+var createTrendLineCore = async ({ config: config2, data: cachedData, strategyApi, indicatorsState }) => {
+  const { TRENDLINE, FEE_PERCENT, MAX_LOSS_VALUE, HIGHS, LOWS } = config2;
+  const lastTradeController = strategyApi.createLastTradeController();
+  const trendlineOptions = {
+    bestLines: 1,
+    capture: true,
+    ...TRENDLINE
+  };
+  const getLowsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "lows",
+    ...trendlineOptions
+  });
+  const getHighsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "highs",
+    ...trendlineOptions
+  });
+  return async (candle) => {
+    const lowsTrendlines = getLowsTrendlines.next(candle);
+    const highsTrendlines = getHighsTrendlines.next(candle);
+    indicatorsState.onBar();
+    const currentPosition = await strategyApi.getCurrentPosition();
+    if (isOpenPosition(currentPosition)) {
+      const { currentPrice: currentPrice2 } = await strategyApi.getMarketData();
+      const activeLine = currentPosition.direction === "LONG" ? highsTrendlines[0] : lowsTrendlines[0];
+      const activeModeConfig = currentPosition.direction === "LONG" ? HIGHS : LOWS;
+      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 (activeLine) {
+        const indicators2 = indicatorsState.snapshot();
+        const manageSignalSeed = buildTrendlineSignalSeed({
+          direction: activeModeConfig.direction,
+          currentPrice: currentPrice2,
+          indicators: indicators2,
+          bestLine: activeLine
+        });
+        const structuralContext2 = buildTrendlineStructuralContext(manageSignalSeed);
+        if (isFailedBreakout({
+          direction: currentPosition.direction,
+          priceVsLinePct: structuralContext2.priceVsLinePct
+        })) {
+          return strategyApi.exit({
+            code: "TRENDLINE_FAILED_BREAKOUT_EXIT",
+            direction: currentPosition.direction
+          });
+        }
+      }
+      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: "TRENDLINE_MOVE_STOP_TO_BREAK_EVEN",
+          protectPlan: {
+            direction: currentPosition.direction,
+            stopLossPrice: currentPosition.price
+          }
+        });
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    const bestLine = lowsTrendlines.length > 0 ? lowsTrendlines[0] : highsTrendlines[0];
+    if (!bestLine) {
+      return strategyApi.skip("NO_TRENDLINE");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const modeConfig = bestLine.mode === "highs" ? HIGHS : LOWS;
+    const { direction, minRiskRatio, enable } = modeConfig;
+    if (!enable) {
+      return strategyApi.skip("STRATEGY_DISABLED");
+    }
+    const { fullData, timestamp, currentPrice } = await strategyApi.getMarketData();
+    if (!filterByVeryVolatility(fullData)) {
+      return strategyApi.skip("VERY_VOLATILITY");
+    }
+    const indicators = indicatorsState.snapshot();
+    const signalSeed = buildTrendlineSignalSeed({
+      direction,
+      currentPrice,
+      indicators,
+      bestLine
+    });
+    const structuralContext = buildTrendlineStructuralContext(signalSeed);
+    if (structuralContext.structuralHardBlockReasons.length > 0) {
+      return strategyApi.skip(
+        `TRENDLINE_STRUCTURE:${structuralContext.structuralHardBlockReasons[0]}`
+      );
+    }
+    const timingContext = buildTrendlineTimingContext({
+      signal: signalSeed,
+      candles: fullData,
+      structuralContext
+    });
+    if (!timingContext.entryReadyNow) {
+      const timingCode = timingContext.entryTiming === "stale_breakout" ? "STALE_BREAKOUT" : timingContext.entryTiming === "wait_retest_confirmation" ? "WAIT_RETEST_CONFIRMATION" : "WAIT_RETEST";
+      return strategyApi.skip(`TRENDLINE_TIMING:${timingCode}`);
+    }
+    const riskPlan = buildTrendlineRiskPlan({
+      direction,
+      modeConfig,
+      structuralContext,
+      timingContext
+    });
+    const { stopLossPrice, takeProfitPrice, riskRatio, qty } = strategyApi.getDirectionalTpSlPrices({
+      price: currentPrice,
+      direction,
+      takeProfitDelta: riskPlan.takeProfitDelta,
+      stopLossDelta: riskPlan.stopLossDelta,
+      unit: "percent",
+      maxLossValue: MAX_LOSS_VALUE,
+      feePercent: Number(FEE_PERCENT ?? 0)
+    });
+    if (!qty || !Number.isFinite(qty) || qty <= 0) {
+      return strategyApi.skip("INVALID_QTY");
+    }
+    if (riskRatio <= minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${round2(riskRatio)}`);
+    }
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: "TRENDLINE_SIGNAL",
+      figures: {
+        ...buildTrendLineFigures(bestLine)
+      },
+      direction,
+      indicators,
+      additionalIndicators: buildTrendlineSignalSeed({
+        direction,
+        currentPrice,
+        indicators,
+        bestLine,
+        trendlineTiming: timingContext
+      }).additionalIndicators,
+      orderPlan: {
+        qty,
+        stopLossPrice,
+        takeProfits: [{ rate: 1, price: takeProfitPrice }]
+      }
+    });
+  };
+};
+
+// src/TrendLine/strategy.ts
+var TrendlineStrategyCreator = createStrategyRuntime({
+  strategyName: "TrendLine",
+  defaults: config,
+  createCore: createTrendLineCore,
+  manifest: trendLineManifest,
+  strategyDirectory: __dirname
+});
+export {
+  TrendlineStrategyCreator
+};

package/dist/{strategy-ZVNTA6UR.mjs → strategy-FYNNJDOH.mjs}

@@ -19,7 +19,6 @@ var config = {
   MIN_AI_QUALITY: 3,
   FEE_PERCENT: 5e-3,
   MAX_LOSS_VALUE: 10,
-  MAX_CORRELATION: 0.45,
   TRADE_COOLDOWN_MS: 0,
   MA_FAST: 21,
   MA_SLOW: 55,
@@ -134,15 +133,7 @@ var detectCross = (maFast, maSlow) => {
   return null;
 };
 var createMaStrategyCore = async ({ config: config2, strategyApi, indicatorsState }) => {
-  const {
-    ENV,
-    FEE_PERCENT,
-    MAX_LOSS_VALUE,
-    MAX_CORRELATION,
-    TRADE_COOLDOWN_MS,
-    LONG,
-    SHORT
-  } = config2;
+  const { FEE_PERCENT, MAX_LOSS_VALUE, TRADE_COOLDOWN_MS, LONG, SHORT } = config2;
   const lastTradeController = strategyApi.createLastTradeController({
     enabled: Number(TRADE_COOLDOWN_MS ?? 0) > 0,
     cooldownMs: Number(TRADE_COOLDOWN_MS ?? 0)
@@ -205,9 +196,6 @@ var createMaStrategyCore = async ({ config: config2, strategyApi, indicatorsStat
       return strategyApi.skip(`RISK_RATIO:${round(riskRatio)}`);
     }
     const correlation = indicatorsState.latestNumber("correlation");
-    if (ENV !== "BACKTEST" && correlation != null && correlation >= MAX_CORRELATION) {
-      return strategyApi.skip(`MAX_CORRELATION:${round(correlation)}`);
-    }
     lastTradeController.markTrade(timestamp);
     return strategyApi.entry({
       code: cross.kind === "bullish" ? "MA_BULLISH_CROSS" : "MA_BEARISH_CROSS",