@tradejs/app 1.0.8 → 1.0.10

package/src/app/lib/runtimeStrategies.ts

@@ -0,0 +1,1376 @@
+import { endOfMonth, addMonths, startOfMonth } from 'date-fns';
+import { INITIAL_BACKTEST_AMOUNT } from '@tradejs/core/constants';
+import {
+  normalizeStrategyOrderLinkKey,
+  parseStrategyOrderLinkKey,
+} from '@tradejs/core/trade';
+import type {
+  ClosedPnlRecord,
+  ExchangeEntryRecord,
+  PositionPnlSnapshot,
+  RuntimeTradeRecord,
+  SimpleOrderLogData,
+  StrategyConfig,
+  TestStat,
+  MarketUniverse,
+  Interval,
+} from '@tradejs/types';
+
+const MS_IN_DAY = 24 * 60 * 60 * 1000;
+const AVG_DAYS_IN_MONTH = 30.4375;
+
+type ClosedPnlRecordWithOrderLinkId = ClosedPnlRecord & {
+  direction?: RuntimeTradeRecord['direction'];
+  entryTimestamp?: number;
+  orderLinkId?: string;
+};
+
+type RuntimeTradeWithResolvedPnl = RuntimeTradeRecord & {
+  resolvedPnl: number;
+  resolvedTimestamp: number;
+};
+
+export interface RuntimeStrategyTradeSummary {
+  totalTrades: number;
+  activeTrades: number;
+  closedTrades: number;
+  wins: number;
+  losses: number;
+  activePnl: number;
+  closedPnl: number;
+  totalPnl: number;
+  symbolConcentrationTop1: number | null;
+  symbolConcentrationTop5: number | null;
+}
+
+export interface RuntimeStrategyTradeView {
+  orderId: string;
+  symbol: string;
+  direction: RuntimeTradeRecord['direction'];
+  status: RuntimeTradeRecord['status'];
+  qty: number;
+  entryTimestamp: number;
+  entryPrice: number;
+  actualEntryPrice: number | null;
+  exitTimestamp: number | null;
+  exitPrice: number | null;
+  actualExitPrice: number | null;
+  currentPrice: number | null;
+  pnl: number | null;
+  durationHours: number | null;
+  entrySlippagePercent: number | null;
+  exitSlippagePercent: number | null;
+  exitType: RuntimeTradeRecord['exitType'] | null;
+  takeProfitPrice: number | null;
+  stopLossPrice: number | null;
+  takeProfitPercent: number | null;
+  stopLossPercent: number | null;
+  openFee: number | null;
+  closeFee: number | null;
+  fundingFee: number | null;
+  totalFee: number | null;
+  lastSyncedAt: number | null;
+}
+
+export interface RuntimeStrategyView {
+  runtimeKey: string;
+  strategyName: string;
+  configId: string;
+  interval: Interval;
+  universe: MarketUniverse;
+  accountId?: string;
+  accountLabel?: string;
+  deploymentId?: string;
+  policyProfileId?: string;
+  connected: boolean;
+  enabled: boolean;
+  config: StrategyConfig | null;
+  symbols: string[];
+  stat: TestStat;
+  summary: RuntimeStrategyTradeSummary;
+  orderLog: SimpleOrderLogData;
+  recentTrades: RuntimeStrategyTradeView[];
+  orders: RuntimeStrategyTradeView[];
+}
+
+export const buildRuntimeStrategyIdentityKey = ({
+  strategyName,
+  configId,
+  universe,
+  accountId,
+  deploymentId,
+  policyProfileId,
+}: {
+  strategyName: string;
+  configId?: string;
+  universe?: MarketUniverse;
+  accountId?: string;
+  deploymentId?: string;
+  policyProfileId?: string;
+}) =>
+  [
+    strategyName,
+    configId ?? 'config',
+    universe ?? 'crypto',
+    accountId ?? 'default',
+    deploymentId ?? 'default',
+    policyProfileId ?? 'default',
+  ].join(':');
+
+export interface RuntimeStrategyAccountScope {
+  strategyName: string;
+  configId: string;
+  universe: MarketUniverse;
+  accountId?: string;
+}
+
+export const assignLegacyRuntimeTradeAccountScopes = (
+  trades: RuntimeTradeRecord[],
+  scopes: RuntimeStrategyAccountScope[],
+): RuntimeTradeRecord[] =>
+  trades.map((trade) => {
+    if (trade.accountId || trade.deploymentId) {
+      return trade;
+    }
+
+    const matchingAccountIds = new Set(
+      scopes
+        .filter(
+          (scope) =>
+            scope.strategyName === trade.strategy &&
+            scope.configId === (trade.runtimeConfigId ?? 'config') &&
+            scope.universe === (trade.universe ?? 'crypto'),
+        )
+        .map((scope) => scope.accountId)
+        .filter((accountId): accountId is string => Boolean(accountId)),
+    );
+
+    if (matchingAccountIds.size !== 1) {
+      return trade;
+    }
+
+    return { ...trade, accountId: [...matchingAccountIds][0] };
+  });
+
+export interface RuntimeStrategiesResponse {
+  provider: string;
+  hours: number;
+  generatedAt: number;
+  dataSources?: {
+    localTrades: number;
+    exchangeFallbackTrades: number;
+    exchangeErrors: string[];
+  };
+  strategies: RuntimeStrategyView[];
+}
+
+const roundValue = (value: number, digits = 2) => {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+
+const toNonEmptyString = (value: unknown) =>
+  typeof value === 'string' && value.trim() ? value.trim() : null;
+
+const toFiniteNumberOrNull = (value: unknown) =>
+  typeof value === 'number' && Number.isFinite(value) ? value : null;
+
+const getTradePnl = (trade: RuntimeTradeRecord) =>
+  trade.status === 'closed'
+    ? trade.closedPnl ?? trade.currentPnl ?? null
+    : trade.currentPnl ?? null;
+
+const getTradeLevelPercent = ({
+  direction,
+  entryPrice,
+  levelPrice,
+  kind,
+}: {
+  direction: RuntimeTradeRecord['direction'];
+  entryPrice: number;
+  levelPrice: unknown;
+  kind: 'takeProfit' | 'stopLoss';
+}) => {
+  if (
+    typeof levelPrice !== 'number' ||
+    !Number.isFinite(levelPrice) ||
+    !Number.isFinite(entryPrice) ||
+    entryPrice <= 0
+  ) {
+    return null;
+  }
+
+  const rawPercent =
+    direction === 'LONG'
+      ? ((levelPrice - entryPrice) / entryPrice) * 100
+      : ((entryPrice - levelPrice) / entryPrice) * 100;
+  const percent = kind === 'stopLoss' ? Math.abs(rawPercent) : rawPercent;
+
+  return Number.isFinite(percent) ? roundValue(percent) : null;
+};
+
+const getPriceSlippagePercent = ({
+  expectedPrice,
+  actualPrice,
+}: {
+  expectedPrice: unknown;
+  actualPrice: unknown;
+}) => {
+  if (
+    typeof expectedPrice !== 'number' ||
+    !Number.isFinite(expectedPrice) ||
+    expectedPrice <= 0 ||
+    typeof actualPrice !== 'number' ||
+    !Number.isFinite(actualPrice)
+  ) {
+    return null;
+  }
+
+  return roundValue(((actualPrice - expectedPrice) / expectedPrice) * 100, 4);
+};
+
+const getExpectedExitPrice = (trade: RuntimeTradeRecord) => {
+  if (trade.exitType === 'tp') {
+    return toFiniteNumberOrNull(trade.aiAnalysis?.takeProfitPrice);
+  }
+
+  if (trade.exitType === 'sl') {
+    return toFiniteNumberOrNull(trade.aiAnalysis?.stopLossPrice);
+  }
+
+  return null;
+};
+
+const getTradeDurationHours = (trade: RuntimeTradeRecord, endTime: number) => {
+  const resolvedTimestamp = getTradeResolvedTimestamp(trade, endTime);
+  if (
+    !Number.isFinite(trade.entryTimestamp) ||
+    !Number.isFinite(resolvedTimestamp) ||
+    resolvedTimestamp < trade.entryTimestamp
+  ) {
+    return null;
+  }
+
+  return roundValue((resolvedTimestamp - trade.entryTimestamp) / 3_600_000, 2);
+};
+
+const getTradeTotalFee = (trade: RuntimeTradeRecord) => {
+  const explicitTotal = toFiniteNumberOrNull(trade.totalFee);
+  if (explicitTotal != null) {
+    return explicitTotal;
+  }
+
+  const fees = [trade.openFee, trade.closeFee, trade.fundingFee]
+    .map(toFiniteNumberOrNull)
+    .filter((fee): fee is number => fee != null);
+
+  return fees.length
+    ? Number(fees.reduce((sum, fee) => sum + fee, 0).toFixed(12))
+    : null;
+};
+
+const buildRiskLevelsAnalysis = ({
+  takeProfitPrice,
+  stopLossPrice,
+}: {
+  takeProfitPrice?: number | null;
+  stopLossPrice?: number | null;
+}): RuntimeTradeRecord['aiAnalysis'] | null => {
+  const resolvedTakeProfitPrice = toFiniteNumberOrNull(takeProfitPrice);
+  const resolvedStopLossPrice = toFiniteNumberOrNull(stopLossPrice);
+
+  if (resolvedTakeProfitPrice == null && resolvedStopLossPrice == null) {
+    return null;
+  }
+
+  return {
+    ...(resolvedTakeProfitPrice != null
+      ? { takeProfitPrice: resolvedTakeProfitPrice }
+      : {}),
+    ...(resolvedStopLossPrice != null
+      ? { stopLossPrice: resolvedStopLossPrice }
+      : {}),
+  };
+};
+
+const getTradeResolvedTimestamp = (
+  trade: RuntimeTradeRecord,
+  endTime: number,
+) => {
+  if (
+    typeof trade.exitTimestamp === 'number' &&
+    Number.isFinite(trade.exitTimestamp)
+  ) {
+    return trade.exitTimestamp;
+  }
+
+  return endTime;
+};
+
+const resolveTradesWithKnownPnl = (
+  trades: RuntimeTradeRecord[],
+  endTime: number,
+): RuntimeTradeWithResolvedPnl[] =>
+  trades
+    .map((trade) => {
+      const pnl = getTradePnl(trade);
+      const resolvedTimestamp = getTradeResolvedTimestamp(trade, endTime);
+
+      if (
+        typeof pnl !== 'number' ||
+        !Number.isFinite(pnl) ||
+        !Number.isFinite(resolvedTimestamp)
+      ) {
+        return null;
+      }
+
+      return {
+        ...trade,
+        resolvedPnl: pnl,
+        resolvedTimestamp: Math.max(trade.entryTimestamp, resolvedTimestamp),
+      };
+    })
+    .filter((trade): trade is RuntimeTradeWithResolvedPnl => trade != null)
+    .sort((left, right) => {
+      if (left.resolvedTimestamp !== right.resolvedTimestamp) {
+        return left.resolvedTimestamp - right.resolvedTimestamp;
+      }
+
+      return left.entryTimestamp - right.entryTimestamp;
+    });
+
+const calculateMaxDrawdown = (amounts: number[]) => {
+  if (!amounts.length) {
+    return 0;
+  }
+
+  let peak = amounts[0];
+  let maxDrawdown = 0;
+
+  for (const amount of amounts) {
+    if (amount > peak) {
+      peak = amount;
+    }
+
+    if (peak <= 0) {
+      continue;
+    }
+
+    const drawdown = ((peak - amount) / peak) * 100;
+    if (drawdown > maxDrawdown) {
+      maxDrawdown = drawdown;
+    }
+  }
+
+  return roundValue(maxDrawdown);
+};
+
+const calculateSharpeRatio = (
+  orderLog: SimpleOrderLogData,
+  startTime: number,
+  endTime: number,
+) => {
+  if (!orderLog.length || endTime <= startTime) {
+    return null;
+  }
+
+  const points = [...orderLog]
+    .map(([timestamp, amount]) => ({ ts: timestamp, amount }))
+    .sort((left, right) => left.ts - right.ts);
+
+  const eomSeries: number[] = [];
+  let pointIndex = 0;
+  let monthCursor = startOfMonth(new Date(startTime));
+  const lastMonth = endOfMonth(new Date(endTime));
+  let lastAmount = points[0]?.amount ?? INITIAL_BACKTEST_AMOUNT;
+
+  while (monthCursor <= lastMonth) {
+    const eomTs = endOfMonth(monthCursor).getTime();
+
+    while (pointIndex < points.length && points[pointIndex].ts <= eomTs) {
+      lastAmount = points[pointIndex].amount;
+      pointIndex += 1;
+    }
+
+    eomSeries.push(lastAmount);
+    monthCursor = addMonths(monthCursor, 1);
+  }
+
+  if (eomSeries.length < 2) {
+    return null;
+  }
+
+  const monthlyReturns: number[] = [];
+  for (let index = 1; index < eomSeries.length; index += 1) {
+    const previous = eomSeries[index - 1];
+    const current = eomSeries[index];
+    monthlyReturns.push(previous > 0 ? current / previous - 1 : 0);
+  }
+
+  if (!monthlyReturns.length) {
+    return null;
+  }
+
+  const mean =
+    monthlyReturns.reduce((sum, value) => sum + value, 0) /
+    monthlyReturns.length;
+  const variance =
+    monthlyReturns.reduce((sum, value) => sum + (value - mean) ** 2, 0) /
+    monthlyReturns.length;
+  const std = Math.sqrt(variance);
+
+  if (!Number.isFinite(std) || std === 0) {
+    return null;
+  }
+
+  return roundValue((mean / std) * Math.sqrt(12));
+};
+
+const calculateExposurePercent = (
+  trades: RuntimeTradeRecord[],
+  startTime: number,
+  endTime: number,
+) => {
+  if (endTime <= startTime) {
+    return 0;
+  }
+
+  const intervals = trades
+    .map((trade) => ({
+      start: Math.max(startTime, trade.entryTimestamp),
+      end: Math.min(endTime, getTradeResolvedTimestamp(trade, endTime)),
+    }))
+    .filter((interval) => interval.end > interval.start)
+    .sort((left, right) => left.start - right.start);
+
+  if (!intervals.length) {
+    return 0;
+  }
+
+  const merged: Array<{ start: number; end: number }> = [];
+
+  for (const interval of intervals) {
+    const last = merged[merged.length - 1];
+
+    if (!last || interval.start > last.end) {
+      merged.push({ ...interval });
+      continue;
+    }
+
+    last.end = Math.max(last.end, interval.end);
+  }
+
+  const coveredMs = merged.reduce(
+    (sum, interval) => sum + (interval.end - interval.start),
+    0,
+  );
+
+  return roundValue((coveredMs / (endTime - startTime)) * 100);
+};
+
+const calculateStreaks = (pnls: number[]) => {
+  let currentWins = 0;
+  let currentLosses = 0;
+  let maxWins = 0;
+  let maxLosses = 0;
+
+  for (const pnl of pnls) {
+    if (pnl > 0) {
+      currentWins += 1;
+      currentLosses = 0;
+      maxWins = Math.max(maxWins, currentWins);
+      continue;
+    }
+
+    if (pnl < 0) {
+      currentLosses += 1;
+      currentWins = 0;
+      maxLosses = Math.max(maxLosses, currentLosses);
+      continue;
+    }
+
+    currentWins = 0;
+    currentLosses = 0;
+  }
+
+  return {
+    maxConsecutiveWins: maxWins,
+    maxConsecutiveLosses: maxLosses,
+  };
+};
+
+const calculateSymbolConcentration = (
+  trades: RuntimeTradeWithResolvedPnl[],
+  limit: number,
+) => {
+  const totals = new Map<string, number>();
+
+  for (const trade of trades) {
+    totals.set(
+      trade.symbol,
+      (totals.get(trade.symbol) ?? 0) + Math.abs(trade.resolvedPnl),
+    );
+  }
+
+  const totalAbsPnl = [...totals.values()].reduce(
+    (sum, value) => sum + value,
+    0,
+  );
+  if (totalAbsPnl <= 0) {
+    return null;
+  }
+
+  const topAbsPnl = [...totals.values()]
+    .sort((left, right) => right - left)
+    .slice(0, limit)
+    .reduce((sum, value) => sum + value, 0);
+
+  return roundValue((topAbsPnl / totalAbsPnl) * 100);
+};
+
+const createEmptyRuntimeStat = (
+  startTime: number,
+  endTime: number,
+): TestStat => {
+  const periodDays = Math.max(0, (endTime - startTime) / MS_IN_DAY);
+  const periodMonths = periodDays / AVG_DAYS_IN_MONTH;
+
+  return {
+    periodDays: roundValue(periodDays),
+    periodMonths: roundValue(periodMonths),
+    orders: 0,
+    wins: 0,
+    losses: 0,
+    ordersPerMonth: 0,
+    exposure: 0,
+    amount: INITIAL_BACKTEST_AMOUNT,
+    maxAmount: INITIAL_BACKTEST_AMOUNT,
+    minAmount: INITIAL_BACKTEST_AMOUNT,
+    netProfit: 0,
+    totalReturn: 0,
+    cagr: 0,
+    maxDrawdown: 0,
+    calmar: null,
+    winRate: 0,
+    riskRewardRatio: null,
+    expectancy: 0,
+    maxConsecutiveWins: 0,
+    maxConsecutiveLosses: 0,
+    sharpeRatio: null,
+    score: 0,
+  };
+};
+
+export const resolveStrategyNameByConfigKey = (
+  userName: string,
+  key: string,
+): string | null => {
+  return (
+    resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null
+  );
+};
+
+export const resolveStrategyConfigIdentityByKey = (
+  userName: string,
+  key: string,
+): { strategyName: string; configId: string } | null => {
+  const parts = key.split(':');
+  if (parts.length !== 5) return null;
+  const [users, keyUserName, strategies, strategyName, configId] = parts;
+  if (
+    users !== 'users' ||
+    keyUserName !== userName ||
+    strategies !== 'strategies' ||
+    !strategyName ||
+    strategyName === 'charts' ||
+    !configId ||
+    configId === 'results' ||
+    !/^[a-zA-Z0-9_-]+$/.test(configId)
+  ) {
+    return null;
+  }
+  return { strategyName, configId };
+};
+
+const buildStrategyNameKeyMap = (strategyNames: string[]) => {
+  const map = new Map<string, string>();
+
+  for (const strategyName of strategyNames) {
+    const key = normalizeStrategyOrderLinkKey(strategyName);
+
+    if (key && !map.has(key)) {
+      map.set(key, strategyName);
+    }
+  }
+
+  return map;
+};
+
+export const resolveStrategyNameByOrderLinkId = ({
+  orderLinkId,
+  strategyNames,
+}: {
+  orderLinkId: string | null | undefined;
+  strategyNames: string[];
+}) => {
+  const strategyKey = parseStrategyOrderLinkKey(orderLinkId);
+
+  if (!strategyKey) {
+    return null;
+  }
+
+  return buildStrategyNameKeyMap(strategyNames).get(strategyKey) ?? null;
+};
+
+export const isRuntimeTradeRecord = (
+  value: unknown,
+): value is RuntimeTradeRecord => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const record = value as Record<string, unknown>;
+  return (
+    typeof record.orderId === 'string' &&
+    typeof record.strategy === 'string' &&
+    typeof record.symbol === 'string' &&
+    typeof record.entryTimestamp === 'number' &&
+    typeof record.entryPrice === 'number' &&
+    typeof record.qty === 'number'
+  );
+};
+
+export const selectTradesForWindow = (
+  trades: RuntimeTradeRecord[],
+  startTime: number,
+  activeOrderIds: Set<string> = new Set(),
+) =>
+  trades.filter((trade) => {
+    if (trade.status === 'active') {
+      if (activeOrderIds.has(trade.orderId)) {
+        return true;
+      }
+
+      return trade.entryTimestamp >= startTime;
+    }
+
+    const exitTimestamp =
+      typeof trade.exitTimestamp === 'number' ? trade.exitTimestamp : 0;
+
+    return trade.entryTimestamp >= startTime || exitTimestamp >= startTime;
+  });
+
+export const buildRuntimeStrategyAnalytics = ({
+  trades,
+  startTime,
+  endTime,
+}: {
+  trades: RuntimeTradeRecord[];
+  startTime: number;
+  endTime: number;
+}) => {
+  const resolvedTrades = resolveTradesWithKnownPnl(trades, endTime);
+  const orderLog: SimpleOrderLogData = [[startTime, INITIAL_BACKTEST_AMOUNT]];
+  const tradePnls = resolvedTrades.map((trade) => trade.resolvedPnl);
+  let runningAmount = INITIAL_BACKTEST_AMOUNT;
+
+  for (const trade of resolvedTrades) {
+    runningAmount = roundValue(runningAmount + trade.resolvedPnl);
+    orderLog.push([trade.resolvedTimestamp, runningAmount]);
+  }
+
+  if (orderLog[orderLog.length - 1]?.[0] !== endTime) {
+    orderLog.push([endTime, runningAmount]);
+  }
+
+  const amounts = orderLog.map(([, amount]) => amount);
+  const wins = tradePnls.filter((pnl) => pnl > 0).length;
+  const losses = tradePnls.filter((pnl) => pnl < 0).length;
+  const averageWin =
+    wins > 0
+      ? tradePnls.filter((pnl) => pnl > 0).reduce((sum, pnl) => sum + pnl, 0) /
+        wins
+      : 0;
+  const averageLossAbs =
+    losses > 0
+      ? Math.abs(
+          tradePnls
+            .filter((pnl) => pnl < 0)
+            .reduce((sum, pnl) => sum + pnl, 0) / losses,
+        )
+      : 0;
+  const returnSeries: number[] = [];
+  let amountBeforeTrade = INITIAL_BACKTEST_AMOUNT;
+
+  for (const trade of resolvedTrades) {
+    returnSeries.push(
+      amountBeforeTrade > 0 ? trade.resolvedPnl / amountBeforeTrade : 0,
+    );
+    amountBeforeTrade += trade.resolvedPnl;
+  }
+
+  const periodDays = Math.max(0, (endTime - startTime) / MS_IN_DAY);
+  const periodMonths = periodDays / AVG_DAYS_IN_MONTH;
+  const amount = amounts[amounts.length - 1] ?? INITIAL_BACKTEST_AMOUNT;
+  const netProfit = amount - INITIAL_BACKTEST_AMOUNT;
+  const totalReturn =
+    INITIAL_BACKTEST_AMOUNT > 0
+      ? ((amount - INITIAL_BACKTEST_AMOUNT) / INITIAL_BACKTEST_AMOUNT) * 100
+      : 0;
+  const cagr =
+    periodMonths > 0
+      ? (Math.pow(amount / INITIAL_BACKTEST_AMOUNT, 12 / periodMonths) - 1) *
+        100
+      : 0;
+  const maxDrawdown = calculateMaxDrawdown(amounts);
+  const calmar = maxDrawdown > 0 ? cagr / maxDrawdown : null;
+  const riskRewardRatio =
+    averageLossAbs > 0 ? averageWin / averageLossAbs : null;
+  const expectancy =
+    returnSeries.length > 0
+      ? roundValue(
+          (returnSeries.reduce((sum, value) => sum + value, 0) /
+            returnSeries.length) *
+            100,
+        )
+      : 0;
+  const sharpeRatio = calculateSharpeRatio(orderLog, startTime, endTime);
+  const exposure = calculateExposurePercent(trades, startTime, endTime);
+  const { maxConsecutiveWins, maxConsecutiveLosses } =
+    calculateStreaks(tradePnls);
+  const symbolConcentrationTop1 = calculateSymbolConcentration(
+    resolvedTrades,
+    1,
+  );
+  const symbolConcentrationTop5 = calculateSymbolConcentration(
+    resolvedTrades,
+    5,
+  );
+
+  const stat: TestStat =
+    trades.length === 0
+      ? createEmptyRuntimeStat(startTime, endTime)
+      : {
+          periodDays: roundValue(periodDays),
+          periodMonths: roundValue(periodMonths),
+          orders: trades.length,
+          wins,
+          losses,
+          ordersPerMonth:
+            periodMonths > 0 ? roundValue(trades.length / periodMonths) : 0,
+          exposure,
+          amount: roundValue(amount),
+          maxAmount: roundValue(Math.max(...amounts)),
+          minAmount: roundValue(Math.min(...amounts)),
+          netProfit: roundValue(netProfit),
+          totalReturn: roundValue(totalReturn),
+          cagr: roundValue(cagr),
+          maxDrawdown,
+          calmar: calmar == null ? null : roundValue(calmar),
+          winRate:
+            trades.length > 0 ? roundValue((wins / trades.length) * 100) : 0,
+          riskRewardRatio:
+            riskRewardRatio == null ? null : roundValue(riskRewardRatio),
+          expectancy,
+          maxConsecutiveWins,
+          maxConsecutiveLosses,
+          sharpeRatio,
+          score: 0,
+        };
+
+  const activeTrades = trades.filter((trade) => trade.status === 'active');
+  const closedTrades = trades.filter((trade) => trade.status === 'closed');
+  const activePnl = roundValue(
+    activeTrades.reduce(
+      (sum, trade) =>
+        sum +
+        (typeof trade.currentPnl === 'number' &&
+        Number.isFinite(trade.currentPnl)
+          ? trade.currentPnl
+          : 0),
+      0,
+    ),
+  );
+  const closedPnl = roundValue(
+    closedTrades.reduce(
+      (sum, trade) =>
+        sum +
+        (typeof trade.closedPnl === 'number' && Number.isFinite(trade.closedPnl)
+          ? trade.closedPnl
+          : typeof trade.currentPnl === 'number' &&
+              Number.isFinite(trade.currentPnl)
+            ? trade.currentPnl
+            : 0),
+      0,
+    ),
+  );
+
+  return {
+    orderLog,
+    stat,
+    summary: {
+      totalTrades: trades.length,
+      activeTrades: activeTrades.length,
+      closedTrades: closedTrades.length,
+      wins,
+      losses,
+      activePnl,
+      closedPnl,
+      totalPnl: roundValue(activePnl + closedPnl),
+      symbolConcentrationTop1,
+      symbolConcentrationTop5,
+    },
+  };
+};
+
+export const toRuntimeTradeView = (
+  trade: RuntimeTradeRecord,
+  endTime = Date.now(),
+): RuntimeStrategyTradeView => ({
+  orderId: trade.orderId,
+  symbol: trade.symbol,
+  direction: trade.direction,
+  status: trade.status,
+  qty: trade.qty,
+  entryTimestamp: trade.entryTimestamp,
+  entryPrice: trade.entryPrice,
+  actualEntryPrice: toFiniteNumberOrNull(trade.actualEntryPrice),
+  exitTimestamp:
+    typeof trade.exitTimestamp === 'number' ? trade.exitTimestamp : null,
+  exitPrice: typeof trade.exitPrice === 'number' ? trade.exitPrice : null,
+  actualExitPrice: toFiniteNumberOrNull(trade.actualExitPrice),
+  currentPrice: toFiniteNumberOrNull(trade.currentPrice),
+  pnl: getTradePnl(trade),
+  durationHours: getTradeDurationHours(trade, endTime),
+  entrySlippagePercent: getPriceSlippagePercent({
+    expectedPrice: trade.entryPrice,
+    actualPrice: trade.actualEntryPrice,
+  }),
+  exitSlippagePercent: getPriceSlippagePercent({
+    expectedPrice: getExpectedExitPrice(trade),
+    actualPrice: trade.actualExitPrice ?? trade.exitPrice,
+  }),
+  exitType: trade.exitType ?? null,
+  takeProfitPrice: toFiniteNumberOrNull(trade.aiAnalysis?.takeProfitPrice),
+  stopLossPrice: toFiniteNumberOrNull(trade.aiAnalysis?.stopLossPrice),
+  takeProfitPercent: getTradeLevelPercent({
+    direction: trade.direction,
+    entryPrice: trade.entryPrice,
+    levelPrice: trade.aiAnalysis?.takeProfitPrice,
+    kind: 'takeProfit',
+  }),
+  stopLossPercent: getTradeLevelPercent({
+    direction: trade.direction,
+    entryPrice: trade.entryPrice,
+    levelPrice: trade.aiAnalysis?.stopLossPrice,
+    kind: 'stopLoss',
+  }),
+  openFee: toFiniteNumberOrNull(trade.openFee),
+  closeFee: toFiniteNumberOrNull(trade.closeFee),
+  fundingFee: toFiniteNumberOrNull(trade.fundingFee),
+  totalFee: getTradeTotalFee(trade),
+  lastSyncedAt:
+    typeof trade.lastSyncedAt === 'number' ? trade.lastSyncedAt : null,
+});
+
+const removeClosedPnlFromExactMaps = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  row,
+}: {
+  exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  exactByOrderId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  row: ClosedPnlRecordWithOrderLinkId;
+}) => {
+  if (row.orderLinkId) {
+    exactByOrderLinkId.delete(row.orderLinkId);
+  }
+
+  if (row.orderId) {
+    exactByOrderId.delete(row.orderId);
+  }
+};
+
+const removeClosedPnlFromSymbolBuckets = (
+  buckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>,
+  row: ClosedPnlRecordWithOrderLinkId,
+) => {
+  const rows = buckets.get(row.symbol);
+  if (!rows?.length) {
+    return;
+  }
+
+  const index = rows.findIndex((candidate) => candidate === row);
+  if (index >= 0) {
+    rows.splice(index, 1);
+  }
+};
+
+const takeExactClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  symbolBuckets,
+  orderLinkId,
+  orderId,
+}: {
+  exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  exactByOrderId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+  orderLinkId?: string | null;
+  orderId?: string | null;
+}) => {
+  const exactKeys: Array<
+    [Map<string, ClosedPnlRecordWithOrderLinkId>, string | null | undefined]
+  > = [
+    [exactByOrderLinkId, orderLinkId],
+    [exactByOrderId, orderId],
+  ];
+
+  for (const [bucket, key] of exactKeys) {
+    const normalizedKey = toNonEmptyString(key);
+
+    if (!normalizedKey) {
+      continue;
+    }
+
+    const exactMatch = bucket.get(normalizedKey);
+    if (!exactMatch) {
+      continue;
+    }
+
+    removeClosedPnlFromExactMaps({
+      exactByOrderLinkId,
+      exactByOrderId,
+      row: exactMatch,
+    });
+    removeClosedPnlFromSymbolBuckets(symbolBuckets, exactMatch);
+    return exactMatch;
+  }
+
+  return null;
+};
+
+export const takeClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId = new Map<string, ClosedPnlRecordWithOrderLinkId>(),
+  symbolBuckets,
+  trade,
+}: {
+  exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  exactByOrderId?: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+  trade: RuntimeTradeRecord;
+}) => {
+  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 * 60_000;
+  const matchIndex = rows.reduce((bestIndex, row, index) => {
+    if (
+      !Number.isFinite(row.closedAt) ||
+      row.closedAt < minimumClosedAt ||
+      (row.direction && row.direction !== trade.direction)
+    ) {
+      return bestIndex;
+    }
+
+    if (bestIndex < 0) {
+      return index;
+    }
+
+    const best = rows[bestIndex];
+    return row.closedAt < best.closedAt ? index : bestIndex;
+  }, -1);
+
+  if (matchIndex < 0) {
+    return null;
+  }
+
+  const [row] = rows.splice(matchIndex, 1);
+  if (row) {
+    removeClosedPnlFromExactMaps({
+      exactByOrderLinkId,
+      exactByOrderId,
+      row,
+    });
+  }
+
+  return row ?? null;
+};
+
+const takeClosedPnlMatchForExchangeEntry = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  symbolBuckets,
+  entry,
+}: {
+  exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  exactByOrderId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+  entry: ExchangeEntryRecord;
+}) => {
+  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 * 60_000;
+  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;
+    }
+
+    const best = rows[bestIndex];
+    return row.closedAt < best.closedAt ? index : bestIndex;
+  }, -1);
+
+  if (matchIndex < 0) {
+    return null;
+  }
+
+  const [row] = rows.splice(matchIndex, 1);
+  if (row) {
+    removeClosedPnlFromExactMaps({
+      exactByOrderLinkId,
+      exactByOrderId,
+      row,
+    });
+  }
+
+  return row ?? null;
+};
+
+const aggregateExchangeEntriesByOrder = (entryRows: ExchangeEntryRecord[]) => {
+  const grouped = new Map<
+    string,
+    ExchangeEntryRecord & {
+      _qtyForPricing: number;
+      _notionalForPricing: number;
+    }
+  >();
+
+  entryRows.forEach((entry, index) => {
+    const orderLinkId = toNonEmptyString(entry.orderLinkId);
+    const orderId = toNonEmptyString(entry.orderId);
+    const groupKey =
+      orderLinkId ||
+      orderId ||
+      `${entry.symbol}:${entry.direction}:${entry.entryTimestamp}:${index}`;
+    const existing = grouped.get(groupKey);
+
+    if (!existing) {
+      grouped.set(groupKey, {
+        ...entry,
+        qty: Number.isFinite(entry.qty) ? entry.qty : 0,
+        _qtyForPricing:
+          Number.isFinite(entry.qty) &&
+          Number.isFinite(entry.entryPrice) &&
+          entry.entryPrice != null
+            ? entry.qty
+            : 0,
+        _notionalForPricing:
+          Number.isFinite(entry.qty) &&
+          Number.isFinite(entry.entryPrice) &&
+          entry.entryPrice != null
+            ? entry.qty * entry.entryPrice
+            : 0,
+      });
+      return;
+    }
+
+    existing.qty += Number.isFinite(entry.qty) ? entry.qty : 0;
+    existing.entryTimestamp = Math.min(
+      existing.entryTimestamp,
+      entry.entryTimestamp,
+    );
+
+    if (
+      Number.isFinite(entry.qty) &&
+      Number.isFinite(entry.entryPrice) &&
+      entry.entryPrice != null
+    ) {
+      existing._qtyForPricing += entry.qty;
+      existing._notionalForPricing += entry.qty * entry.entryPrice;
+    }
+  });
+
+  return [...grouped.values()]
+    .map(({ _qtyForPricing, _notionalForPricing, ...entry }) => ({
+      ...entry,
+      qty: roundValue(entry.qty, 8),
+      entryPrice:
+        _qtyForPricing > 0
+          ? roundValue(_notionalForPricing / _qtyForPricing, 8)
+          : null,
+    }))
+    .sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+
+export const buildExchangeFallbackRuntimeTrades = ({
+  entryRows,
+  closedPnlRows,
+  openPositions,
+  strategyNames,
+  existingTrades,
+  endTime,
+}: {
+  entryRows: ExchangeEntryRecord[];
+  closedPnlRows: ClosedPnlRecordWithOrderLinkId[];
+  openPositions: PositionPnlSnapshot[];
+  strategyNames: string[];
+  existingTrades: RuntimeTradeRecord[];
+  endTime: number;
+}) => {
+  if (!entryRows.length && !closedPnlRows.length) {
+    return [];
+  }
+
+  const strategyNameByOrderId = new Map(
+    existingTrades
+      .filter(
+        (trade): trade is RuntimeTradeRecord & { strategy: string } =>
+          typeof trade.orderId === 'string' &&
+          trade.orderId.trim().length > 0 &&
+          typeof trade.strategy === 'string' &&
+          trade.strategy.trim().length > 0,
+      )
+      .map((trade) => [trade.orderId, trade.strategy]),
+  );
+  const strategyNamesPool = [
+    ...new Set([
+      ...strategyNames,
+      ...existingTrades.map((trade) => trade.strategy).filter(Boolean),
+    ]),
+  ];
+  const openPositionBySymbol = new Map(
+    openPositions.map((position) => [position.symbol, position]),
+  );
+  const existingOrderIds = new Set(
+    existingTrades
+      .map((trade) => toNonEmptyString(trade.orderId))
+      .filter((value): value is string => value != null),
+  );
+  const exactByOrderLinkId = new Map(
+    closedPnlRows
+      .filter(
+        (
+          row,
+        ): row is ClosedPnlRecordWithOrderLinkId & { orderLinkId: string } =>
+          typeof row.orderLinkId === 'string' && row.orderLinkId.length > 0,
+      )
+      .map((row) => [row.orderLinkId, row]),
+  );
+  const exactByOrderId = new Map(
+    closedPnlRows
+      .filter(
+        (row): row is ClosedPnlRecordWithOrderLinkId & { orderId: string } =>
+          typeof row.orderId === 'string' && row.orderId.length > 0,
+      )
+      .map((row) => [row.orderId, row]),
+  );
+  const symbolBuckets = new Map<string, ClosedPnlRecordWithOrderLinkId[]>();
+
+  for (const row of closedPnlRows) {
+    const bucket = symbolBuckets.get(row.symbol) ?? [];
+    bucket.push(row);
+    symbolBuckets.set(row.symbol, bucket);
+  }
+
+  const fallbackTrades = aggregateExchangeEntriesByOrder(entryRows)
+    .map<RuntimeTradeRecord | null>((entry) => {
+      const normalizedOrderLinkId = toNonEmptyString(entry.orderLinkId);
+      const normalizedOrderId = toNonEmptyString(entry.orderId);
+      const runtimeOrderId = normalizedOrderLinkId ?? normalizedOrderId;
+
+      if (!runtimeOrderId || existingOrderIds.has(runtimeOrderId)) {
+        return null;
+      }
+
+      const strategyName =
+        (normalizedOrderLinkId
+          ? strategyNameByOrderId.get(normalizedOrderLinkId)
+          : null) ??
+        (normalizedOrderId
+          ? strategyNameByOrderId.get(normalizedOrderId)
+          : null) ??
+        resolveStrategyNameByOrderLinkId({
+          orderLinkId: normalizedOrderLinkId,
+          strategyNames: strategyNamesPool,
+        });
+
+      if (!strategyName) {
+        return null;
+      }
+
+      const matchedClosedPnl = takeClosedPnlMatchForExchangeEntry({
+        exactByOrderLinkId,
+        exactByOrderId,
+        symbolBuckets,
+        entry,
+      });
+      const openPosition = openPositionBySymbol.get(entry.symbol);
+      const isActive =
+        !matchedClosedPnl &&
+        openPosition?.direction === entry.direction &&
+        Number.isFinite(openPosition.currentPrice) &&
+        Number.isFinite(openPosition.unrealizedPnl);
+      const entryPrice =
+        typeof entry.entryPrice === 'number' &&
+        Number.isFinite(entry.entryPrice)
+          ? entry.entryPrice
+          : typeof matchedClosedPnl?.entryPrice === 'number' &&
+              Number.isFinite(matchedClosedPnl.entryPrice)
+            ? matchedClosedPnl.entryPrice
+            : null;
+
+      if (entryPrice == null) {
+        return null;
+      }
+
+      return {
+        orderId: runtimeOrderId,
+        strategy: strategyName,
+        symbol: entry.symbol,
+        direction: entry.direction,
+        qty: entry.qty,
+        entryPrice,
+        actualEntryPrice:
+          matchedClosedPnl?.entryPrice ?? entry.entryPrice ?? null,
+        entryTimestamp: entry.entryTimestamp,
+        status: isActive ? 'active' : 'closed',
+        currentPrice: isActive
+          ? openPosition?.currentPrice ?? null
+          : matchedClosedPnl?.exitPrice ?? null,
+        currentPnl: isActive
+          ? openPosition?.unrealizedPnl ?? null
+          : matchedClosedPnl?.closedPnl ?? null,
+        closedPnl: isActive ? null : matchedClosedPnl?.closedPnl ?? null,
+        exitPrice: isActive ? null : matchedClosedPnl?.exitPrice ?? null,
+        actualExitPrice: isActive ? null : matchedClosedPnl?.exitPrice ?? null,
+        exitTimestamp: isActive ? null : matchedClosedPnl?.closedAt ?? null,
+        aiAnalysis: isActive
+          ? buildRiskLevelsAnalysis({
+              takeProfitPrice: openPosition?.takeProfitPrice,
+              stopLossPrice: openPosition?.stopLossPrice,
+            })
+          : null,
+        openFee: matchedClosedPnl?.openFee ?? entry.openFee ?? null,
+        closeFee: matchedClosedPnl?.closeFee ?? entry.closeFee ?? null,
+        fundingFee: matchedClosedPnl?.fundingFee ?? entry.fundingFee ?? null,
+        totalFee: matchedClosedPnl?.totalFee ?? entry.totalFee ?? null,
+        lastSyncedAt: endTime,
+      };
+    })
+    .filter((trade): trade is RuntimeTradeRecord => trade != null);
+
+  const fallbackOrderIds = new Set([
+    ...existingOrderIds,
+    ...fallbackTrades.map((trade) => trade.orderId),
+  ]);
+  const remainingClosedPnlRows = [...symbolBuckets.values()].flat();
+  const closedPnlFallbackTrades = remainingClosedPnlRows
+    .map<RuntimeTradeRecord | null>((row) => {
+      const normalizedOrderLinkId = toNonEmptyString(row.orderLinkId);
+      const normalizedOrderId = toNonEmptyString(row.orderId);
+      const runtimeOrderId = normalizedOrderLinkId ?? normalizedOrderId;
+
+      if (!runtimeOrderId || fallbackOrderIds.has(runtimeOrderId)) {
+        return null;
+      }
+
+      const strategyName =
+        (normalizedOrderLinkId
+          ? strategyNameByOrderId.get(normalizedOrderLinkId)
+          : null) ??
+        (normalizedOrderId
+          ? strategyNameByOrderId.get(normalizedOrderId)
+          : null) ??
+        resolveStrategyNameByOrderLinkId({
+          orderLinkId: normalizedOrderLinkId,
+          strategyNames: strategyNamesPool,
+        });
+
+      if (
+        !strategyName ||
+        row.entryPrice == null ||
+        !Number.isFinite(row.entryPrice)
+      ) {
+        return null;
+      }
+
+      const direction = row.direction ?? null;
+      if (!direction) {
+        return null;
+      }
+
+      return {
+        orderId: runtimeOrderId,
+        strategy: strategyName,
+        symbol: row.symbol,
+        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 is RuntimeTradeRecord => trade != null);
+
+  return [...fallbackTrades, ...closedPnlFallbackTrades].sort(
+    (left, right) => left.entryTimestamp - right.entryTimestamp,
+  );
+};