@tradejs/strategies 1.0.0

package/dist/index.mjs

@@ -0,0 +1,87 @@
+import {
+  breakoutManifest
+} from "./chunk-3PN7ZSJJ.mjs";
+import {
+  config,
+  trendLineManifest
+} from "./chunk-MVIV5ZII.mjs";
+import {
+  maStrategyAiAdapter,
+  maStrategyManifest,
+  maStrategyMlAdapter
+} from "./chunk-RDK2JK3K.mjs";
+import {
+  adaptiveMomentumRibbonAiAdapter,
+  adaptiveMomentumRibbonManifest,
+  adaptiveMomentumRibbonMlAdapter
+} from "./chunk-RYEPHOGL.mjs";
+import {
+  volumeDivergenceAiAdapter,
+  volumeDivergenceManifest,
+  volumeDivergenceMlAdapter
+} from "./chunk-ULLCAH5C.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+
+// src/index.ts
+import { defineStrategyPlugin } from "@tradejs/core/config";
+var createLazyStrategyCreator = (loader, exportName) => {
+  return async (params) => {
+    const module = await loader();
+    const creator = module[exportName];
+    if (typeof creator !== "function") {
+      throw new Error(
+        `Strategy creator export "${String(exportName)}" is missing`
+      );
+    }
+    return creator(params);
+  };
+};
+var strategyEntries = [
+  {
+    manifest: breakoutManifest,
+    creator: createLazyStrategyCreator(
+      () => import("./strategy-Y4SOK6FF.mjs"),
+      "BreakoutStrategyCreator"
+    )
+  },
+  {
+    manifest: trendLineManifest,
+    creator: createLazyStrategyCreator(
+      () => import("./strategy-UZBWST3G.mjs"),
+      "TrendlineStrategyCreator"
+    )
+  },
+  {
+    manifest: maStrategyManifest,
+    creator: createLazyStrategyCreator(
+      () => import("./strategy-ZVNTA6UR.mjs"),
+      "MaStrategyCreator"
+    )
+  },
+  {
+    manifest: adaptiveMomentumRibbonManifest,
+    creator: createLazyStrategyCreator(
+      () => import("./strategy-Q2QNDZK5.mjs"),
+      "AdaptiveMomentumRibbonStrategyCreator"
+    )
+  },
+  {
+    manifest: volumeDivergenceManifest,
+    creator: createLazyStrategyCreator(
+      () => import("./strategy-M3BRWDRR.mjs"),
+      "VolumeDivergenceStrategyCreator"
+    )
+  }
+];
+var index_default = defineStrategyPlugin({ strategyEntries });
+export {
+  adaptiveMomentumRibbonAiAdapter,
+  adaptiveMomentumRibbonMlAdapter,
+  index_default as default,
+  maStrategyAiAdapter,
+  maStrategyMlAdapter,
+  strategyEntries,
+  config as trendLineDefaultConfig,
+  volumeDivergenceAiAdapter,
+  volumeDivergenceMlAdapter
+};

package/dist/strategy-M3BRWDRR.mjs

@@ -0,0 +1,377 @@
+import {
+  volumeDivergenceManifest
+} from "./chunk-ULLCAH5C.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,
+  MAX_CORRELATION: 0.45,
+  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: 1e3,
+  PIVOT_LOOKBACK_LEFT: 21,
+  PIVOT_LOOKBACK_RIGHT: 5,
+  MAX_BARS_BETWEEN_PIVOTS: 60,
+  MIN_BARS_BETWEEN_PIVOTS: 5,
+  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";
+
+// src/VolumeDivergence/figures.ts
+var buildVolumeDivergenceFigures = ({
+  kind,
+  previousPivotIndex,
+  currentPivotIndex,
+  previousPivotLow,
+  previousPivotHigh,
+  currentPivotLow,
+  currentPivotHigh,
+  fullData
+}) => ({
+  lines: [
+    {
+      id: `volume-divergence-price-${kind}`,
+      kind: `volume_divergence_${kind}_price`,
+      points: [
+        {
+          timestamp: fullData[previousPivotIndex]?.timestamp ?? 0,
+          value: kind === "bullish" ? previousPivotLow : previousPivotHigh
+        },
+        {
+          timestamp: fullData[currentPivotIndex]?.timestamp ?? 0,
+          value: kind === "bullish" ? currentPivotLow : currentPivotHigh
+        }
+      ],
+      color: kind === "bullish" ? "#22c55e" : "#ef4444",
+      width: 2,
+      style: "dashed"
+    }
+  ],
+  points: [
+    {
+      id: `volume-divergence-pivots-${kind}`,
+      kind: `volume_divergence_${kind}_pivots`,
+      points: [
+        {
+          timestamp: fullData[previousPivotIndex]?.timestamp ?? 0,
+          value: kind === "bullish" ? previousPivotLow : previousPivotHigh
+        },
+        {
+          timestamp: fullData[currentPivotIndex]?.timestamp ?? 0,
+          value: kind === "bullish" ? currentPivotLow : currentPivotHigh
+        }
+      ],
+      color: kind === "bullish" ? "#22c55e" : "#ef4444",
+      radius: 4
+    }
+  ]
+});
+
+// src/VolumeDivergence/core.ts
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var appendNormalizedVolumes = ({
+  candles,
+  length,
+  normalizedVolumes
+}) => {
+  while (normalizedVolumes.length < candles.length) {
+    const i = normalizedVolumes.length;
+    const start = Math.max(0, i - length + 1);
+    let highest = 0;
+    for (let j = start; j <= i; j += 1) {
+      highest = Math.max(highest, Number(candles[j]?.volume) || 0);
+    }
+    const volume = Number(candles[i]?.volume) || 0;
+    normalizedVolumes.push(highest > 0 ? volume / highest * 100 : 0);
+  }
+};
+var isPivotHigh = ({
+  values,
+  index,
+  left,
+  right
+}) => {
+  const pivotValue = values[index];
+  if (!isFiniteNumber(pivotValue)) {
+    return false;
+  }
+  if (index - left < 0 || index + right >= values.length) {
+    return false;
+  }
+  for (let i = index - left; i <= index + right; i += 1) {
+    if (i === index) continue;
+    if (!isFiniteNumber(values[i]) || values[i] >= pivotValue) {
+      return false;
+    }
+  }
+  return true;
+};
+var candleDeltaProxy = (candle) => {
+  const volume = Number(candle.volume) || 0;
+  const range = Math.max(Math.abs(candle.high - candle.low), 1e-9);
+  const bodyBias = (candle.close - candle.open) / range;
+  return volume * clamp(bodyBias, -1, 1);
+};
+var findLatestDivergence = ({
+  candles,
+  normalizedVolumes,
+  lookbackLeft,
+  lookbackRight,
+  rangeLower,
+  rangeUpper
+}) => {
+  const currentConfirmationIndex = candles.length - 1;
+  const currentPivotIndex = currentConfirmationIndex - lookbackRight;
+  if (currentPivotIndex <= 0) {
+    return null;
+  }
+  if (!isPivotHigh({
+    values: normalizedVolumes,
+    index: currentPivotIndex,
+    left: lookbackLeft,
+    right: lookbackRight
+  })) {
+    return null;
+  }
+  let previousPivotIndex = -1;
+  for (let i = currentPivotIndex - 1; i >= lookbackLeft; i -= 1) {
+    if (isPivotHigh({
+      values: normalizedVolumes,
+      index: i,
+      left: lookbackLeft,
+      right: lookbackRight
+    })) {
+      previousPivotIndex = i;
+      break;
+    }
+  }
+  if (previousPivotIndex < 0) {
+    return null;
+  }
+  const previousConfirmationIndex = previousPivotIndex + lookbackRight;
+  const barsBetweenPivotConfirmations = currentConfirmationIndex - previousConfirmationIndex - 1;
+  if (barsBetweenPivotConfirmations < rangeLower || barsBetweenPivotConfirmations > rangeUpper) {
+    return null;
+  }
+  const currentPivotVolumeNorm = normalizedVolumes[currentPivotIndex];
+  const previousPivotVolumeNorm = normalizedVolumes[previousPivotIndex];
+  const currentPivotLow = Number(candles[currentPivotIndex]?.low);
+  const previousPivotLow = Number(candles[previousPivotIndex]?.low);
+  const currentPivotHigh = Number(candles[currentPivotIndex]?.high);
+  const previousPivotHigh = Number(candles[previousPivotIndex]?.high);
+  const currentPivotCandle = candles[currentPivotIndex];
+  if (!isFiniteNumber(currentPivotVolumeNorm) || !isFiniteNumber(previousPivotVolumeNorm) || !isFiniteNumber(currentPivotLow) || !isFiniteNumber(previousPivotLow) || !isFiniteNumber(currentPivotHigh) || !isFiniteNumber(previousPivotHigh)) {
+    return null;
+  }
+  const volHigherLow = currentPivotVolumeNorm > previousPivotVolumeNorm;
+  const volLowerHigh = currentPivotVolumeNorm < previousPivotVolumeNorm;
+  const priceLowerLow = currentPivotLow < previousPivotLow;
+  const priceHigherHigh = currentPivotHigh > previousPivotHigh;
+  if (priceLowerLow && volHigherLow) {
+    return {
+      currentPivotIndex,
+      previousPivotIndex,
+      currentPivotVolumeNorm,
+      previousPivotVolumeNorm,
+      currentPivotLow,
+      previousPivotLow,
+      currentPivotHigh,
+      previousPivotHigh,
+      currentPivotVolume: Number(currentPivotCandle.volume) || 0,
+      currentPivotDelta: candleDeltaProxy(currentPivotCandle),
+      barsBetweenPivotConfirmations,
+      kind: "bullish"
+    };
+  }
+  if (priceHigherHigh && volLowerHigh) {
+    return {
+      currentPivotIndex,
+      previousPivotIndex,
+      currentPivotVolumeNorm,
+      previousPivotVolumeNorm,
+      currentPivotLow,
+      previousPivotLow,
+      currentPivotHigh,
+      previousPivotHigh,
+      currentPivotVolume: Number(currentPivotCandle.volume) || 0,
+      currentPivotDelta: candleDeltaProxy(currentPivotCandle),
+      barsBetweenPivotConfirmations,
+      kind: "bearish"
+    };
+  }
+  return null;
+};
+var createVolumeDivergenceCore = async ({ config: config2, strategyApi, indicatorsState }) => {
+  const {
+    NORMALIZATION_LENGTH,
+    PIVOT_LOOKBACK_LEFT,
+    PIVOT_LOOKBACK_RIGHT,
+    MAX_BARS_BETWEEN_PIVOTS,
+    MIN_BARS_BETWEEN_PIVOTS,
+    FEE_PERCENT,
+    MAX_LOSS_VALUE,
+    MAX_CORRELATION,
+    ENV,
+    BULLISH,
+    BEARISH
+  } = config2;
+  const lastTradeController = strategyApi.createLastTradeController();
+  const normalizedVolumes = [];
+  return async () => {
+    indicatorsState.onBar();
+    const positionExists = await strategyApi.isCurrentPositionExists();
+    if (positionExists) {
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    const { fullData, timestamp, currentPrice } = await strategyApi.getMarketData();
+    if (fullData.length < PIVOT_LOOKBACK_LEFT + PIVOT_LOOKBACK_RIGHT + 2) {
+      return strategyApi.skip("WAIT_DATA");
+    }
+    if (lastTradeController.isInCooldown(timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    appendNormalizedVolumes({
+      candles: fullData,
+      length: NORMALIZATION_LENGTH,
+      normalizedVolumes
+    });
+    const divergence = findLatestDivergence({
+      candles: fullData,
+      normalizedVolumes,
+      lookbackLeft: PIVOT_LOOKBACK_LEFT,
+      lookbackRight: PIVOT_LOOKBACK_RIGHT,
+      rangeLower: MIN_BARS_BETWEEN_PIVOTS,
+      rangeUpper: MAX_BARS_BETWEEN_PIVOTS
+    });
+    if (!divergence) {
+      return strategyApi.skip("NO_DIVERGENCE");
+    }
+    const modeConfig = divergence.kind === "bullish" ? BULLISH : BEARISH;
+    if (!modeConfig.enable) {
+      return strategyApi.skip("STRATEGY_DISABLED");
+    }
+    const { stopLossPrice, takeProfitPrice, riskRatio, qty } = strategyApi.getDirectionalTpSlPrices({
+      price: currentPrice,
+      direction: modeConfig.direction,
+      takeProfitDelta: modeConfig.TP,
+      stopLossDelta: modeConfig.SL,
+      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 <= modeConfig.minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${round(riskRatio)}`);
+    }
+    const indicators = indicatorsState.snapshot();
+    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: "VOLUME_DIVERGENCE_REVERSAL_SIGNAL",
+      direction: modeConfig.direction,
+      figures: buildVolumeDivergenceFigures({
+        kind: divergence.kind,
+        previousPivotIndex: divergence.previousPivotIndex,
+        currentPivotIndex: divergence.currentPivotIndex,
+        previousPivotLow: divergence.previousPivotLow,
+        previousPivotHigh: divergence.previousPivotHigh,
+        currentPivotLow: divergence.currentPivotLow,
+        currentPivotHigh: divergence.currentPivotHigh,
+        fullData
+      }),
+      indicators,
+      additionalIndicators: {
+        divergenceKind: divergence.kind,
+        normalizedVolumeAtPivot: divergence.currentPivotVolumeNorm,
+        previousNormalizedVolumeAtPivot: divergence.previousPivotVolumeNorm,
+        volumeAtPivot: divergence.currentPivotVolume,
+        deltaAtPivot: divergence.currentPivotDelta,
+        barsBetweenPivotConfirmations: divergence.barsBetweenPivotConfirmations,
+        divergence: {
+          kind: divergence.kind,
+          pivotLookbackLeft: PIVOT_LOOKBACK_LEFT,
+          pivotLookbackRight: PIVOT_LOOKBACK_RIGHT,
+          currentPivot: {
+            index: divergence.currentPivotIndex,
+            timestamp: fullData[divergence.currentPivotIndex]?.timestamp,
+            priceLow: divergence.currentPivotLow,
+            priceHigh: divergence.currentPivotHigh,
+            volumeNorm: divergence.currentPivotVolumeNorm
+          },
+          previousPivot: {
+            index: divergence.previousPivotIndex,
+            timestamp: fullData[divergence.previousPivotIndex]?.timestamp,
+            priceLow: divergence.previousPivotLow,
+            priceHigh: divergence.previousPivotHigh,
+            volumeNorm: divergence.previousPivotVolumeNorm
+          },
+          barsBetweenPivotConfirmations: divergence.barsBetweenPivotConfirmations
+        }
+      },
+      orderPlan: {
+        qty,
+        stopLossPrice,
+        takeProfits: [{ rate: 1, price: takeProfitPrice }]
+      }
+    });
+  };
+};
+
+// src/VolumeDivergence/strategy.ts
+var VolumeDivergenceStrategyCreator = createStrategyRuntime({
+  strategyName: "VolumeDivergence",
+  defaults: config,
+  createCore: createVolumeDivergenceCore,
+  manifest: volumeDivergenceManifest,
+  strategyDirectory: __dirname
+});
+export {
+  VolumeDivergenceStrategyCreator
+};