@tradejs/node 3.0.1 → 3.1.1

package/dist/chunk-FB5NUEOQ.mjs

@@ -0,0 +1,295 @@
+// src/runtimeTrades.ts
+import { resolveStrategyNameByOrderLinkId } from "@tradejs/core/runtimeTrades";
+
+// src/runtimeTradeReconciliation.ts
+var toNonEmptyString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var removeFromExactMaps = (exactByOrderLinkId, exactByOrderId, row) => {
+  for (const [key, value] of exactByOrderLinkId) {
+    if (value === row) exactByOrderLinkId.delete(key);
+  }
+  for (const [key, value] of exactByOrderId) {
+    if (value === row) exactByOrderId.delete(key);
+  }
+};
+var removeFromSymbolBuckets = (buckets, row) => {
+  const rows = buckets.get(row.symbol);
+  const index = rows?.findIndex((candidate) => candidate === row) ?? -1;
+  if (index >= 0) rows?.splice(index, 1);
+};
+var takeExactClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  symbolBuckets,
+  orderLinkId,
+  orderId
+}) => {
+  const keys = [
+    [exactByOrderLinkId, orderLinkId],
+    [exactByOrderId, orderId]
+  ];
+  for (const [bucket, key] of keys) {
+    const normalizedKey = toNonEmptyString(key);
+    if (!normalizedKey) continue;
+    const match = bucket.get(normalizedKey);
+    if (!match) continue;
+    removeFromExactMaps(exactByOrderLinkId, exactByOrderId, match);
+    removeFromSymbolBuckets(symbolBuckets, match);
+    return match;
+  }
+  return null;
+};
+var takeClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId = /* @__PURE__ */ new Map(),
+  symbolBuckets,
+  trade
+}) => {
+  const exactMatch = takeExactClosedPnlMatch({
+    exactByOrderLinkId,
+    exactByOrderId,
+    symbolBuckets,
+    orderLinkId: trade.orderId,
+    orderId: trade.orderId
+  });
+  if (exactMatch) return exactMatch;
+  const rows = symbolBuckets.get(trade.symbol);
+  if (!rows?.length) return null;
+  const minimumClosedAt = trade.entryTimestamp - 5 * 6e4;
+  const matchIndex = rows.reduce((bestIndex, row2, index) => {
+    if (!Number.isFinite(row2.closedAt) || row2.closedAt < minimumClosedAt || row2.direction && row2.direction !== trade.direction) {
+      return bestIndex;
+    }
+    if (bestIndex < 0) return index;
+    return row2.closedAt < rows[bestIndex].closedAt ? index : bestIndex;
+  }, -1);
+  if (matchIndex < 0) return null;
+  const [row] = rows.splice(matchIndex, 1);
+  if (row) removeFromExactMaps(exactByOrderLinkId, exactByOrderId, row);
+  return row ?? null;
+};
+
+// src/runtimeTrades.ts
+var toNonEmptyString2 = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var roundValue = (value, digits = 2) => {
+  if (!Number.isFinite(value)) return 0;
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+var removeExactMatches = (exactByOrderLinkId, exactByOrderId, row) => {
+  if (row.orderLinkId) exactByOrderLinkId.delete(row.orderLinkId);
+  if (row.orderId) exactByOrderId.delete(row.orderId);
+};
+var takeClosedPnlMatchForEntry = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  symbolBuckets,
+  entry
+}) => {
+  const exactMatch = takeExactClosedPnlMatch({
+    exactByOrderLinkId,
+    exactByOrderId,
+    symbolBuckets,
+    orderLinkId: entry.orderLinkId,
+    orderId: entry.orderId
+  });
+  if (exactMatch) return exactMatch;
+  const rows = symbolBuckets.get(entry.symbol);
+  if (!rows?.length) return null;
+  const minimumClosedAt = entry.entryTimestamp - 5 * 6e4;
+  const matchIndex = rows.reduce((bestIndex, row, index) => {
+    if (!Number.isFinite(row.closedAt) || row.closedAt < minimumClosedAt || row.direction && row.direction !== entry.direction) {
+      return bestIndex;
+    }
+    if (bestIndex < 0) return index;
+    return row.closedAt < rows[bestIndex].closedAt ? index : bestIndex;
+  }, -1);
+  if (matchIndex < 0) return null;
+  const [match] = rows.splice(matchIndex, 1);
+  if (match) removeExactMatches(exactByOrderLinkId, exactByOrderId, match);
+  return match ?? null;
+};
+var aggregateExchangeEntriesByOrder = (entryRows) => {
+  const grouped = /* @__PURE__ */ new Map();
+  entryRows.forEach((entry, index) => {
+    const orderLinkId = toNonEmptyString2(entry.orderLinkId);
+    const orderId = toNonEmptyString2(entry.orderId);
+    const key = orderLinkId || orderId || `${entry.symbol}:${entry.direction}:${entry.entryTimestamp}:${index}`;
+    const existing = grouped.get(key);
+    const hasPrice = Number.isFinite(entry.qty) && typeof entry.entryPrice === "number" && Number.isFinite(entry.entryPrice);
+    if (!existing) {
+      grouped.set(key, {
+        ...entry,
+        qty: Number.isFinite(entry.qty) ? entry.qty : 0,
+        pricingQty: hasPrice ? entry.qty : 0,
+        pricingNotional: hasPrice ? entry.qty * (entry.entryPrice ?? 0) : 0
+      });
+      return;
+    }
+    existing.qty += Number.isFinite(entry.qty) ? entry.qty : 0;
+    existing.entryTimestamp = Math.min(
+      existing.entryTimestamp,
+      entry.entryTimestamp
+    );
+    if (hasPrice) {
+      existing.pricingQty += entry.qty;
+      existing.pricingNotional += entry.qty * (entry.entryPrice ?? 0);
+    }
+  });
+  return [...grouped.values()].map(({ pricingQty, pricingNotional, ...entry }) => ({
+    ...entry,
+    qty: roundValue(entry.qty, 8),
+    entryPrice: pricingQty > 0 ? roundValue(pricingNotional / pricingQty, 8) : null
+  })).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+var resolveStrategy = ({
+  orderLinkId,
+  orderId,
+  strategyNameByOrderId,
+  strategyNames
+}) => (orderLinkId ? strategyNameByOrderId.get(orderLinkId) : null) ?? (orderId ? strategyNameByOrderId.get(orderId) : null) ?? resolveStrategyNameByOrderLinkId({ orderLinkId, strategyNames });
+var buildRiskLevels = (position) => {
+  const takeProfitPrice = position?.takeProfitPrice;
+  const stopLossPrice = position?.stopLossPrice;
+  if ((typeof takeProfitPrice !== "number" || !Number.isFinite(takeProfitPrice)) && (typeof stopLossPrice !== "number" || !Number.isFinite(stopLossPrice))) {
+    return null;
+  }
+  return {
+    ...typeof takeProfitPrice === "number" && Number.isFinite(takeProfitPrice) ? { takeProfitPrice } : {},
+    ...typeof stopLossPrice === "number" && Number.isFinite(stopLossPrice) ? { stopLossPrice } : {}
+  };
+};
+var buildExchangeFallbackRuntimeTrades = ({
+  entryRows,
+  closedPnlRows,
+  openPositions,
+  strategyNames,
+  existingTrades,
+  endTime
+}) => {
+  if (!entryRows.length && !closedPnlRows.length) return [];
+  const strategyNameByOrderId = new Map(
+    existingTrades.filter(
+      (trade) => Boolean(trade.orderId?.trim() && trade.strategy?.trim())
+    ).map((trade) => [trade.orderId, trade.strategy])
+  );
+  const strategyNamesPool = [
+    .../* @__PURE__ */ new Set([
+      ...strategyNames,
+      ...existingTrades.map(({ strategy }) => strategy)
+    ])
+  ];
+  const openPositionBySymbol = new Map(
+    openPositions.map((position) => [position.symbol, position])
+  );
+  const existingOrderIds = new Set(
+    existingTrades.map(({ orderId }) => toNonEmptyString2(orderId)).filter((value) => value != null)
+  );
+  const exactByOrderLinkId = new Map(
+    closedPnlRows.filter((row) => Boolean(row.orderLinkId)).map((row) => [row.orderLinkId, row])
+  );
+  const exactByOrderId = new Map(
+    closedPnlRows.filter((row) => Boolean(row.orderId)).map((row) => [row.orderId, row])
+  );
+  const symbolBuckets = /* @__PURE__ */ new Map();
+  for (const row of closedPnlRows) {
+    const bucket = symbolBuckets.get(row.symbol) ?? [];
+    bucket.push(row);
+    symbolBuckets.set(row.symbol, bucket);
+  }
+  const fallbackTrades = aggregateExchangeEntriesByOrder(entryRows).map((entry) => {
+    const orderLinkId = toNonEmptyString2(entry.orderLinkId);
+    const orderId = toNonEmptyString2(entry.orderId);
+    const runtimeOrderId = orderLinkId ?? orderId;
+    if (!runtimeOrderId || existingOrderIds.has(runtimeOrderId)) return null;
+    const strategy = resolveStrategy({
+      orderLinkId,
+      orderId,
+      strategyNameByOrderId,
+      strategyNames: strategyNamesPool
+    });
+    if (!strategy) return null;
+    const closed = takeClosedPnlMatchForEntry({
+      exactByOrderLinkId,
+      exactByOrderId,
+      symbolBuckets,
+      entry
+    });
+    const position = openPositionBySymbol.get(entry.symbol);
+    const isActive = !closed && position?.direction === entry.direction && Number.isFinite(position.currentPrice) && Number.isFinite(position.unrealizedPnl);
+    const entryPrice = typeof entry.entryPrice === "number" && Number.isFinite(entry.entryPrice) ? entry.entryPrice : typeof closed?.entryPrice === "number" && Number.isFinite(closed.entryPrice) ? closed.entryPrice : null;
+    if (entryPrice == null) return null;
+    return {
+      orderId: runtimeOrderId,
+      strategy,
+      symbol: entry.symbol,
+      direction: entry.direction,
+      qty: entry.qty,
+      entryPrice,
+      actualEntryPrice: closed?.entryPrice ?? entry.entryPrice ?? null,
+      entryTimestamp: entry.entryTimestamp,
+      status: isActive ? "active" : "closed",
+      currentPrice: isActive ? position?.currentPrice ?? null : closed?.exitPrice ?? null,
+      currentPnl: isActive ? position?.unrealizedPnl ?? null : closed?.closedPnl ?? null,
+      closedPnl: isActive ? null : closed?.closedPnl ?? null,
+      exitPrice: isActive ? null : closed?.exitPrice ?? null,
+      actualExitPrice: isActive ? null : closed?.exitPrice ?? null,
+      exitTimestamp: isActive ? null : closed?.closedAt ?? null,
+      aiAnalysis: isActive ? buildRiskLevels(position) : null,
+      openFee: closed?.openFee ?? entry.openFee ?? null,
+      closeFee: closed?.closeFee ?? entry.closeFee ?? null,
+      fundingFee: closed?.fundingFee ?? entry.fundingFee ?? null,
+      totalFee: closed?.totalFee ?? entry.totalFee ?? null,
+      lastSyncedAt: endTime
+    };
+  }).filter((trade) => trade != null);
+  const usedOrderIds = /* @__PURE__ */ new Set([
+    ...existingOrderIds,
+    ...fallbackTrades.map(({ orderId }) => orderId)
+  ]);
+  const remainingClosedTrades = [...symbolBuckets.values()].flat().map((row) => {
+    const orderLinkId = toNonEmptyString2(row.orderLinkId);
+    const orderId = toNonEmptyString2(row.orderId);
+    const runtimeOrderId = orderLinkId ?? orderId;
+    if (!runtimeOrderId || usedOrderIds.has(runtimeOrderId)) return null;
+    const strategy = resolveStrategy({
+      orderLinkId,
+      orderId,
+      strategyNameByOrderId,
+      strategyNames: strategyNamesPool
+    });
+    if (!strategy || row.entryPrice == null || !Number.isFinite(row.entryPrice) || !row.direction) {
+      return null;
+    }
+    return {
+      orderId: runtimeOrderId,
+      strategy,
+      symbol: row.symbol,
+      direction: row.direction,
+      qty: row.qty,
+      entryPrice: row.entryPrice,
+      actualEntryPrice: row.entryPrice,
+      entryTimestamp: typeof row.entryTimestamp === "number" && Number.isFinite(row.entryTimestamp) ? row.entryTimestamp : row.closedAt,
+      status: "closed",
+      currentPrice: row.exitPrice,
+      currentPnl: row.closedPnl,
+      closedPnl: row.closedPnl,
+      exitPrice: row.exitPrice,
+      actualExitPrice: row.exitPrice,
+      exitTimestamp: row.closedAt,
+      openFee: row.openFee ?? null,
+      closeFee: row.closeFee ?? null,
+      fundingFee: row.fundingFee ?? null,
+      totalFee: row.totalFee ?? null,
+      lastSyncedAt: endTime
+    };
+  }).filter((trade) => trade != null);
+  return [...fallbackTrades, ...remainingClosedTrades].sort(
+    (left, right) => left.entryTimestamp - right.entryTimestamp
+  );
+};
+
+export {
+  takeExactClosedPnlMatch,
+  takeClosedPnlMatch,
+  buildExchangeFallbackRuntimeTrades
+};

package/dist/chunk-LAJ7NA3Q.mjs

@@ -0,0 +1,377 @@
+// src/strategies.ts
+export * from "@tradejs/core/strategies";
+
+// src/strategyHooks/closeOppositePositionsBeforeOpen.ts
+import _ from "lodash";
+import { logger } from "@tradejs/infra/logger";
+var closeOppositePositionsBeforeOpen = async ({
+  connector,
+  entryContext
+}) => {
+  const {
+    symbol: currentSymbol,
+    direction: currentDirection,
+    timestamp,
+    prices,
+    strategy: strategyName
+  } = entryContext;
+  const price = prices.currentPrice;
+  try {
+    logger.log(
+      "info",
+      "[%s] checking open positions before open: %s %s",
+      strategyName,
+      currentSymbol,
+      currentDirection
+    );
+    const positions = await connector.getPositions();
+    const openPositions = (positions || []).filter(
+      (item) => item && Number(item.qty) > 0
+    );
+    logger.log(
+      "info",
+      "[%s] open positions found: %s",
+      strategyName,
+      openPositions.length
+    );
+    const oppositePositions = openPositions.filter(
+      (item) => item.symbol !== currentSymbol && item.direction !== currentDirection
+    );
+    if (_.isEmpty(oppositePositions)) {
+      logger.log(
+        "info",
+        "[%s] no opposite positions to close before open: %s",
+        strategyName,
+        currentSymbol
+      );
+      return;
+    }
+    for (const position of oppositePositions) {
+      logger.log(
+        "info",
+        "[%s] closing opposite position: %s %s qty=%s",
+        strategyName,
+        position.symbol,
+        position.direction,
+        position.qty
+      );
+      try {
+        await connector.closePosition({
+          symbol: position.symbol,
+          price,
+          timestamp,
+          direction: position.direction
+        });
+        logger.log(
+          "info",
+          "[%s] opposite position closed: %s",
+          strategyName,
+          position.symbol
+        );
+      } catch (err) {
+        logger.log(
+          "error",
+          "[%s] failed to close opposite position: %s %s",
+          strategyName,
+          position.symbol,
+          err
+        );
+      }
+    }
+  } catch (err) {
+    logger.log(
+      "error",
+      "[%s] failed to load open positions before open: %s %s",
+      strategyName,
+      currentSymbol,
+      err
+    );
+  }
+};
+var createCloseOppositeBeforePlaceOrderHook = ({
+  isEnabled
+}) => {
+  return async ({ ctx, entry }) => {
+    if (ctx.env === "BACKTEST") {
+      return;
+    }
+    if (!isEnabled(ctx.strategyConfig)) {
+      return;
+    }
+    await closeOppositePositionsBeforeOpen({
+      connector: ctx.connector,
+      entryContext: entry.context
+    });
+  };
+};
+
+// src/strategyHooks/shared.ts
+var DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER = 0.5;
+var DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER = 0;
+var DEFAULT_GLOBAL_UNREALIZED_PNL_TRIGGER_RISK_MULTIPLIER = 4;
+var GLOBAL_UNREALIZED_PNL_CLOSE_ALL_CODE = "GLOBAL_UNREALIZED_PNL_TARGET_REACHED_CLOSE_ALL";
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var isOpenPosition = (position) => Boolean(
+  position && isFiniteNumber(position.price) && isFiniteNumber(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
+);
+var isOpenPositionPnlSnapshot = (position) => Boolean(
+  isOpenPosition(position) && isFiniteNumber(position?.currentPrice) && isFiniteNumber(position?.unrealizedPnl)
+);
+var getStrategyMaxLossValue = (strategyConfig) => {
+  const maxLossValue = Number(strategyConfig?.MAX_LOSS_VALUE ?? Number.NaN);
+  return Number.isFinite(maxLossValue) && maxLossValue > 0 ? maxLossValue : null;
+};
+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 getPositionTakeProfitPrice = (position) => {
+  if (!position || typeof position !== "object") {
+    return null;
+  }
+  const directTakeProfitPrice = Number(
+    position.tpPrice ?? position.takeProfitPrice ?? Number.NaN
+  );
+  if (Number.isFinite(directTakeProfitPrice)) {
+    return directTakeProfitPrice;
+  }
+  const signalTakeProfitPrice = Number(
+    position.signal?.prices?.takeProfitPrice ?? Number.NaN
+  );
+  return Number.isFinite(signalTakeProfitPrice) ? signalTakeProfitPrice : null;
+};
+var getBreakEvenStopPrice = ({
+  direction,
+  entryPrice,
+  takeProfitPrice,
+  stopProfitMultiplier
+}) => {
+  if (!Number.isFinite(entryPrice)) {
+    return null;
+  }
+  const normalizedStopProfitMultiplier = Number.isFinite(stopProfitMultiplier) ? Math.min(Math.max(stopProfitMultiplier, 0), 1) : DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER;
+  if (takeProfitPrice == null || !Number.isFinite(takeProfitPrice) || direction === "LONG" && takeProfitPrice <= entryPrice || direction === "SHORT" && takeProfitPrice >= entryPrice) {
+    return entryPrice;
+  }
+  const distanceToTakeProfit = takeProfitPrice - entryPrice;
+  return entryPrice + distanceToTakeProfit * normalizedStopProfitMultiplier;
+};
+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 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 getConfiguredDirectionRiskPct = ({
+  strategyConfig,
+  direction
+}) => {
+  if (!strategyConfig || typeof strategyConfig !== "object") {
+    return null;
+  }
+  const directSideConfig = strategyConfig[direction];
+  const directSideRiskPct = Number(directSideConfig?.SL ?? Number.NaN);
+  if (Number.isFinite(directSideRiskPct)) {
+    return directSideRiskPct;
+  }
+  for (const candidate of Object.values(strategyConfig)) {
+    if (!candidate || typeof candidate !== "object") {
+      continue;
+    }
+    const candidateDirection = candidate.direction;
+    const candidateRiskPct = Number(
+      candidate.SL ?? Number.NaN
+    );
+    if (candidateDirection === direction && Number.isFinite(candidateRiskPct)) {
+      return candidateRiskPct;
+    }
+  }
+  return null;
+};
+var toStrategyCodePrefix = (strategyName) => strategyName === "TrendLine" ? "TRENDLINE" : strategyName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase();
+
+// src/strategyHooks/moveStopToBreakEvenAfterCoreDecision.ts
+var createMoveStopToBreakEvenOnBarHook = ({
+  isEnabled = () => true,
+  triggerRiskMultiplier = DEFAULT_BREAK_EVEN_TRIGGER_RISK_MULTIPLIER,
+  stopProfitMultiplier = DEFAULT_BREAK_EVEN_STOP_PROFIT_MULTIPLIER
+} = {}) => {
+  return async ({ ctx, market }) => {
+    if (!isEnabled(ctx.strategyConfig)) {
+      return;
+    }
+    const currentPosition = await ctx.connector.getPosition(ctx.symbol);
+    if (!isOpenPosition(currentPosition)) {
+      return;
+    }
+    const currentPrice = Number(market.candle.close ?? Number.NaN);
+    if (!Number.isFinite(currentPrice)) {
+      return;
+    }
+    const currentStopLossPrice = getPositionStopLossPrice(currentPosition);
+    if (isBreakEvenStopAlreadyApplied({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      stopLossPrice: currentStopLossPrice
+    })) {
+      return;
+    }
+    const favorableMovePct = getFavorableMovePct({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      currentPrice
+    });
+    const currentPositionRiskPct = getPositionRiskPct({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      stopLossPrice: currentStopLossPrice
+    });
+    const configuredRiskPct = getConfiguredDirectionRiskPct({
+      strategyConfig: ctx.strategyConfig,
+      direction: currentPosition.direction
+    });
+    const triggerRiskPct = currentPositionRiskPct ?? configuredRiskPct;
+    if (favorableMovePct == null || triggerRiskPct == null || favorableMovePct < triggerRiskPct * triggerRiskMultiplier) {
+      return;
+    }
+    const stopLossPrice = getBreakEvenStopPrice({
+      direction: currentPosition.direction,
+      entryPrice: currentPosition.price,
+      takeProfitPrice: getPositionTakeProfitPrice(currentPosition),
+      stopProfitMultiplier
+    });
+    if (stopLossPrice == null) {
+      return;
+    }
+    return {
+      kind: "protect",
+      code: `${toStrategyCodePrefix(ctx.strategyName)}_MOVE_STOP_TO_BREAK_EVEN`,
+      protectPlan: {
+        direction: currentPosition.direction,
+        stopLossPrice
+      }
+    };
+  };
+};
+var createMoveStopToBreakEvenAfterCoreDecisionHook = createMoveStopToBreakEvenOnBarHook;
+
+// src/signalsHooks/closeAllPositionsOnGlobalProfitBeforeSignals.ts
+import { logger as logger2 } from "@tradejs/infra/logger";
+var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
+  getStrategyDefaultConfig = () => void 0,
+  profitRiskMultiplier = DEFAULT_GLOBAL_UNREALIZED_PNL_TRIGGER_RISK_MULTIPLIER
+} = {}) => {
+  return async ({ connector, runtimeStrategies }) => {
+    if (typeof connector.getOpenPositionPnl !== "function") {
+      return;
+    }
+    const openPositions = (await connector.getOpenPositionPnl()).filter(
+      isOpenPositionPnlSnapshot
+    );
+    if (!openPositions.length) {
+      return;
+    }
+    const totalUnrealizedPnl = openPositions.reduce(
+      (sum, position) => sum + position.unrealizedPnl,
+      0
+    );
+    if (!Number.isFinite(totalUnrealizedPnl) || totalUnrealizedPnl <= 0) {
+      return;
+    }
+    const maxLossValues = runtimeStrategies.flatMap(
+      ({ strategyName, strategyConfig }) => {
+        const maxLossValue = getStrategyMaxLossValue({
+          ...getStrategyDefaultConfig(strategyName) ?? {},
+          ...strategyConfig ?? {}
+        });
+        return maxLossValue == null ? [] : [maxLossValue];
+      }
+    );
+    if (!maxLossValues.length) {
+      return;
+    }
+    const averageMaxLossValue = maxLossValues.reduce((sum, value) => sum + value, 0) / maxLossValues.length;
+    const unrealizedPnlThreshold = averageMaxLossValue * profitRiskMultiplier;
+    if (!Number.isFinite(unrealizedPnlThreshold) || unrealizedPnlThreshold <= 0 || totalUnrealizedPnl < unrealizedPnlThreshold) {
+      return;
+    }
+    logger2.info(
+      "closing all positions before signals by global unrealized pnl threshold: totalPnl=%s threshold=%s positions=%s",
+      totalUnrealizedPnl,
+      unrealizedPnlThreshold,
+      openPositions.length
+    );
+    const closeTimestamp = Date.now();
+    const closeResults = await Promise.allSettled(
+      openPositions.map(
+        (position) => connector.closePosition({
+          symbol: position.symbol,
+          direction: position.direction,
+          price: position.currentPrice,
+          timestamp: closeTimestamp
+        })
+      )
+    );
+    const failedClosures = closeResults.flatMap((result, index) => {
+      if (result.status === "fulfilled" && result.value === true) {
+        return [];
+      }
+      return [
+        `${openPositions[index]?.symbol}:${openPositions[index]?.direction ?? "UNKNOWN"}`
+      ];
+    });
+    if (failedClosures.length) {
+      logger2.warn(
+        "close-all before signals hook could not confirm closures for %s",
+        failedClosures.join(", ")
+      );
+    }
+    return {
+      abort: true,
+      reason: GLOBAL_UNREALIZED_PNL_CLOSE_ALL_CODE
+    };
+  };
+};
+
+export {
+  closeOppositePositionsBeforeOpen,
+  createCloseOppositeBeforePlaceOrderHook,
+  createMoveStopToBreakEvenOnBarHook,
+  createMoveStopToBreakEvenAfterCoreDecisionHook,
+  createCloseAllOnGlobalProfitBeforeSignalsHook
+};