backtest-kit 3.2.0 → 3.3.1

package/build/index.cjs

@@ -2900,6 +2900,27 @@ class ExchangeConnectionService {
     }
 }
 
+/**
+ * Returns the effective entry price for price calculations.
+ *
+ * When the _entry array exists and has at least one element, returns
+ * the simple arithmetic mean of all entry prices (DCA average).
+ * Otherwise returns the original signal.priceOpen.
+ *
+ * This mirrors the _trailingPriceStopLoss pattern: original price is preserved
+ * in signal.priceOpen (for identity/tracking), while calculations use the
+ * effective averaged price returned by this function.
+ *
+ * @param signal - Signal row (ISignalRow or IScheduledSignalRow)
+ * @returns Effective entry price for distance and PNL calculations
+ */
+const getEffectivePriceOpen = (signal) => {
+    if (signal._entry && signal._entry.length > 0) {
+        return signal._entry.reduce((sum, e) => sum + e.price, 0) / signal._entry.length;
+    }
+    return signal.priceOpen;
+};
+
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
@@ -2950,7 +2971,7 @@ class ExchangeConnectionService {
  * ```
  */
 const toProfitLossDto = (signal, priceClose) => {
-    const priceOpen = signal.priceOpen;
+    const priceOpen = getEffectivePriceOpen(signal);
     // Calculate weighted PNL with partial closes
     if (signal._partial && signal._partial.length > 0) {
         let totalWeightedPnl = 0;
@@ -3204,6 +3225,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentToClose: commit.percentToClose,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
                 signalId: publicSignal.id,
@@ -3211,6 +3233,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3227,6 +3250,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentToClose: commit.percentToClose,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
                 signalId: publicSignal.id,
@@ -3234,6 +3258,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3249,6 +3274,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 backtest: commit.backtest,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 signalId: publicSignal.id,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
@@ -3256,6 +3282,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3272,6 +3299,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentShift: commit.percentShift,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 signalId: publicSignal.id,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
@@ -3279,6 +3307,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3295,6 +3324,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentShift: commit.percentShift,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 signalId: publicSignal.id,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
@@ -3302,6 +3332,33 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
+                scheduledAt: publicSignal.scheduledAt,
+                pendingAt: publicSignal.pendingAt,
+            });
+            continue;
+        }
+        if (commit.action === "average-buy") {
+            const effectivePriceOpen = getEffectivePriceOpen(self._pendingSignal);
+            await CALL_COMMIT_FN(self, {
+                action: "average-buy",
+                symbol: commit.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                backtest: commit.backtest,
+                currentPrice: commit.currentPrice,
+                effectivePriceOpen,
+                timestamp,
+                totalEntries: publicSignal.totalEntries,
+                signalId: publicSignal.id,
+                position: publicSignal.position,
+                priceOpen: publicSignal.originalPriceOpen,
+                priceTakeProfit: publicSignal.priceTakeProfit,
+                priceStopLoss: publicSignal.priceStopLoss,
+                originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3362,13 +3419,20 @@ const TO_PUBLIC_SIGNAL = (signal) => {
     const partialExecuted = ("_partial" in signal && Array.isArray(signal._partial))
         ? signal._partial.reduce((sum, partial) => sum + partial.percent, 0)
         : 0;
+    const totalEntries = ("_entry" in signal && Array.isArray(signal._entry))
+        ? signal._entry.length
+        : 1;
+    const effectivePriceOpen = "_entry" in signal ? getEffectivePriceOpen(signal) : signal.priceOpen;
     return {
         ...structuredClone(signal),
+        priceOpen: effectivePriceOpen,
         priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
         priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
+        originalPriceOpen: signal.priceOpen,
         originalPriceStopLoss: signal.priceStopLoss,
         originalPriceTakeProfit: signal.priceTakeProfit,
         partialExecuted,
+        totalEntries,
     };
 };
 const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
@@ -3698,6 +3762,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
                 scheduledAt: currentTime,
                 pendingAt: currentTime, // Для immediate signal оба времени одинаковые
                 _isScheduled: false,
+                _entry: [{ price: signal.priceOpen }],
             };
             // Валидируем сигнал перед возвратом
             VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -3719,6 +3784,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             scheduledAt: currentTime,
             pendingAt: SCHEDULED_SIGNAL_PENDING_MOCK, // Временно, обновится при активации
             _isScheduled: true,
+            _entry: [{ price: signal.priceOpen }],
         };
         // Валидируем сигнал перед возвратом
         VALIDATE_SIGNAL_FN(scheduledSignalRow, currentPrice, true);
@@ -3736,6 +3802,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         scheduledAt: currentTime,
         pendingAt: currentTime, // Для immediate signal оба времени одинаковые
         _isScheduled: false,
+        _entry: [{ price: currentPrice }],
     };
     // Валидируем сигнал перед возвратом
     VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -3882,9 +3949,10 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
     return true;
 };
 const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
+    const effectivePriceOpen = getEffectivePriceOpen(signal);
     // CRITICAL: Always calculate from ORIGINAL SL, not from current trailing SL
     // This prevents error accumulation on repeated calls
-    const originalSlDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+    const originalSlDistancePercent = Math.abs((effectivePriceOpen - signal.priceStopLoss) / effectivePriceOpen * 100);
     // Calculate new stop-loss distance percentage by adding shift to ORIGINAL distance
     // Negative percentShift: reduces distance % (tightens stop, moves SL toward entry or beyond)
     // Positive percentShift: increases distance % (loosens stop, moves SL away from entry)
@@ -3896,13 +3964,13 @@ const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
         // LONG: SL is below entry (or above entry if in profit zone)
         // Formula: entry * (1 - newDistance%)
         // Example: entry=100, originalSL=90 (10%), shift=-5% → newDistance=5% → 100 * 0.95 = 95 (tighter)
-        newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
+        newStopLoss = effectivePriceOpen * (1 - newSlDistancePercent / 100);
     }
     else {
         // SHORT: SL is above entry (or below entry if in profit zone)
         // Formula: entry * (1 + newDistance%)
         // Example: entry=100, originalSL=110 (10%), shift=-5% → newDistance=5% → 100 * 1.05 = 105 (tighter)
-        newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
+        newStopLoss = effectivePriceOpen * (1 + newSlDistancePercent / 100);
     }
     const currentTrailingSL = signal._trailingPriceStopLoss;
     const isFirstCall = currentTrailingSL === undefined;
@@ -3965,9 +4033,10 @@ const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
     }
 };
 const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
+    const effectivePriceOpen = getEffectivePriceOpen(signal);
     // CRITICAL: Always calculate from ORIGINAL TP, not from current trailing TP
     // This prevents error accumulation on repeated calls
-    const originalTpDistancePercent = Math.abs((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+    const originalTpDistancePercent = Math.abs((signal.priceTakeProfit - effectivePriceOpen) / effectivePriceOpen * 100);
     // Calculate new take-profit distance percentage by adding shift to ORIGINAL distance
     // Negative percentShift: reduces distance % (brings TP closer to entry)
     // Positive percentShift: increases distance % (moves TP further from entry)
@@ -3978,13 +4047,13 @@ const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
         // LONG: TP is above entry
         // Formula: entry * (1 + newDistance%)
         // Example: entry=100, originalTP=110 (10%), shift=-3% → newDistance=7% → 100 * 1.07 = 107 (closer)
-        newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+        newTakeProfit = effectivePriceOpen * (1 + newTpDistancePercent / 100);
     }
     else {
         // SHORT: TP is below entry
         // Formula: entry * (1 - newDistance%)
         // Example: entry=100, originalTP=90 (10%), shift=-3% → newDistance=7% → 100 * 0.93 = 93 (closer)
-        newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+        newTakeProfit = effectivePriceOpen * (1 - newTpDistancePercent / 100);
     }
     const currentTrailingTP = signal._trailingPriceTakeProfit;
     const isFirstCall = currentTrailingTP === undefined;
@@ -4045,6 +4114,7 @@ const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
     }
 };
 const BREAKEVEN_FN = (self, signal, currentPrice) => {
+    const effectivePriceOpen = getEffectivePriceOpen(signal);
     // Calculate breakeven threshold based on slippage and fees
     // Need to cover: entry slippage + entry fee + exit slippage + exit fee
     // Total: (slippage + fee) * 2 transactions
@@ -4052,10 +4122,10 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
     // Check if trailing stop is already set
     if (signal._trailingPriceStopLoss !== undefined) {
         const trailingStopLoss = signal._trailingPriceStopLoss;
-        const breakevenPrice = signal.priceOpen;
+        const breakevenPrice = effectivePriceOpen;
         if (signal.position === "long") {
             // LONG: trailing SL is positive if it's above entry (in profit zone)
-            const isPositiveTrailing = trailingStopLoss > signal.priceOpen;
+            const isPositiveTrailing = trailingStopLoss > effectivePriceOpen;
             if (isPositiveTrailing) {
                 // Trailing stop is already protecting profit - consider breakeven achieved
                 self.params.logger.debug("BREAKEVEN_FN: positive trailing stop already set, returning true", {
@@ -4071,7 +4141,7 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
             else {
                 // Trailing stop is negative (below entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice >= thresholdPrice;
                 if (isThresholdReached && breakevenPrice > trailingStopLoss) {
                     // Check for price intrusion before setting new SL
@@ -4120,7 +4190,7 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
         }
         else {
             // SHORT: trailing SL is positive if it's below entry (in profit zone)
-            const isPositiveTrailing = trailingStopLoss < signal.priceOpen;
+            const isPositiveTrailing = trailingStopLoss < effectivePriceOpen;
             if (isPositiveTrailing) {
                 // Trailing stop is already protecting profit - consider breakeven achieved
                 self.params.logger.debug("BREAKEVEN_FN: positive trailing stop already set, returning true", {
@@ -4136,7 +4206,7 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
             else {
                 // Trailing stop is negative (above entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice <= thresholdPrice;
                 if (isThresholdReached && breakevenPrice < trailingStopLoss) {
                     // Check for price intrusion before setting new SL
@@ -4186,21 +4256,21 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
     }
     // No trailing stop set - proceed with normal breakeven logic
     const currentStopLoss = signal.priceStopLoss;
-    const breakevenPrice = signal.priceOpen;
+    const breakevenPrice = effectivePriceOpen;
     // Calculate threshold price
     let thresholdPrice;
     let isThresholdReached;
     let canMoveToBreakeven;
     if (signal.position === "long") {
         // LONG: threshold reached when price goes UP by breakevenThresholdPercent from entry
-        thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+        thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
         isThresholdReached = currentPrice >= thresholdPrice;
         // Can move to breakeven only if threshold reached and SL is below entry
         canMoveToBreakeven = isThresholdReached && currentStopLoss < breakevenPrice;
     }
     else {
         // SHORT: threshold reached when price goes DOWN by breakevenThresholdPercent from entry
-        thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+        thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
         isThresholdReached = currentPrice <= thresholdPrice;
         // Can move to breakeven only if threshold reached and SL is above entry
         canMoveToBreakeven = isThresholdReached && currentStopLoss > breakevenPrice;
@@ -4260,8 +4330,51 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
         thresholdPrice,
         breakevenThresholdPercent,
         profitDistancePercent: signal.position === "long"
-            ? ((currentPrice - signal.priceOpen) / signal.priceOpen * 100)
-            : ((signal.priceOpen - currentPrice) / signal.priceOpen * 100),
+            ? ((currentPrice - effectivePriceOpen) / effectivePriceOpen * 100)
+            : ((effectivePriceOpen - currentPrice) / effectivePriceOpen * 100),
+    });
+    return true;
+};
+const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
+    // Ensure _entry is initialized (handles signals loaded from disk without _entry)
+    if (!signal._entry || signal._entry.length === 0) {
+        signal._entry = [{ price: signal.priceOpen }];
+    }
+    const lastEntry = signal._entry[signal._entry.length - 1];
+    if (signal.position === "long") {
+        // LONG: averaging down = currentPrice must be strictly lower than last entry
+        if (currentPrice >= lastEntry.price) {
+            self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice >= last entry (LONG)", {
+                signalId: signal.id,
+                position: signal.position,
+                currentPrice,
+                lastEntryPrice: lastEntry.price,
+                reason: "must average down for LONG",
+            });
+            return false;
+        }
+    }
+    else {
+        // SHORT: averaging down = currentPrice must be strictly higher than last entry
+        if (currentPrice <= lastEntry.price) {
+            self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice <= last entry (SHORT)", {
+                signalId: signal.id,
+                position: signal.position,
+                currentPrice,
+                lastEntryPrice: lastEntry.price,
+                reason: "must average down for SHORT",
+            });
+            return false;
+        }
+    }
+    signal._entry.push({ price: currentPrice });
+    self.params.logger.info("AVERAGE_BUY_FN executed", {
+        signalId: signal.id,
+        position: signal.position,
+        originalPriceOpen: signal.priceOpen,
+        newEntryPrice: currentPrice,
+        newEffectivePrice: getEffectivePriceOpen(signal),
+        totalEntries: signal._entry.length,
     });
     return true;
 };
@@ -4990,9 +5103,10 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
     await CALL_ACTIVE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentTime, self.params.execution.context.backtest);
     // Calculate percentage of path to TP/SL for partial fill/loss callbacks
     {
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
         if (signal.position === "long") {
             // For long: calculate progress towards TP or SL
-            const currentDistance = currentPrice - signal.priceOpen;
+            const currentDistance = currentPrice - effectivePriceOpen;
             if (currentDistance > 0) {
                 // Check if breakeven should be triggered
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
@@ -5000,7 +5114,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             if (currentDistance > 0) {
                 // Moving towards TP (use trailing TP if set)
                 const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                const tpDistance = effectiveTakeProfit - signal.priceOpen;
+                const tpDistance = effectiveTakeProfit - effectivePriceOpen;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
@@ -5008,7 +5122,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             else if (currentDistance < 0) {
                 // Moving towards SL (use trailing SL if set)
                 const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                const slDistance = signal.priceOpen - effectiveStopLoss;
+                const slDistance = effectivePriceOpen - effectiveStopLoss;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
@@ -5016,7 +5130,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         }
         else if (signal.position === "short") {
             // For short: calculate progress towards TP or SL
-            const currentDistance = signal.priceOpen - currentPrice;
+            const currentDistance = effectivePriceOpen - currentPrice;
             if (currentDistance > 0) {
                 // Check if breakeven should be triggered
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
@@ -5024,7 +5138,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             if (currentDistance > 0) {
                 // Moving towards TP (use trailing TP if set)
                 const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                const tpDistance = signal.priceOpen - effectiveTakeProfit;
+                const tpDistance = effectivePriceOpen - effectiveTakeProfit;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
@@ -5032,7 +5146,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             if (currentDistance < 0) {
                 // Moving towards SL (use trailing SL if set)
                 const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                const slDistance = effectiveStopLoss - signal.priceOpen;
+                const slDistance = effectiveStopLoss - effectivePriceOpen;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
@@ -5252,8 +5366,10 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                 priceStopLoss: publicSignalForCommit.priceStopLoss,
                 originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                originalPriceOpen: publicSignalForCommit.originalPriceOpen,
                 scheduledAt: publicSignalForCommit.scheduledAt,
                 pendingAt: publicSignalForCommit.pendingAt,
+                totalEntries: publicSignalForCommit.totalEntries,
             });
             await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
             await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
@@ -5400,9 +5516,10 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         // Call onPartialProfit/onPartialLoss callbacks during backtest candle processing
         // Calculate percentage of path to TP/SL
         {
+            const effectivePriceOpen = getEffectivePriceOpen(signal);
             if (signal.position === "long") {
                 // For long: calculate progress towards TP or SL
-                const currentDistance = averagePrice - signal.priceOpen;
+                const currentDistance = averagePrice - effectivePriceOpen;
                 if (currentDistance > 0) {
                     // Check if breakeven should be triggered
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
@@ -5410,21 +5527,21 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 if (currentDistance > 0) {
                     // Moving towards TP (use trailing TP if set)
                     const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                    const tpDistance = effectiveTakeProfit - signal.priceOpen;
+                    const tpDistance = effectiveTakeProfit - effectivePriceOpen;
                     const progressPercent = (currentDistance / tpDistance) * 100;
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 else if (currentDistance < 0) {
                     // Moving towards SL (use trailing SL if set)
                     const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                    const slDistance = signal.priceOpen - effectiveStopLoss;
+                    const slDistance = effectivePriceOpen - effectiveStopLoss;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
             }
             else if (signal.position === "short") {
                 // For short: calculate progress towards TP or SL
-                const currentDistance = signal.priceOpen - averagePrice;
+                const currentDistance = effectivePriceOpen - averagePrice;
                 if (currentDistance > 0) {
                     // Check if breakeven should be triggered
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
@@ -5432,14 +5549,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 if (currentDistance > 0) {
                     // Moving towards TP (use trailing TP if set)
                     const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                    const tpDistance = signal.priceOpen - effectiveTakeProfit;
+                    const tpDistance = effectivePriceOpen - effectiveTakeProfit;
                     const progressPercent = (currentDistance / tpDistance) * 100;
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 if (currentDistance < 0) {
                     // Moving towards SL (use trailing SL if set)
                     const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                    const slDistance = effectiveStopLoss - signal.priceOpen;
+                    const slDistance = effectiveStopLoss - effectivePriceOpen;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
@@ -5637,6 +5754,7 @@ class ClientStrategy {
             return false;
         }
         const signal = this._pendingSignal;
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
         // Calculate breakeven threshold based on slippage and fees
         // Need to cover: entry slippage + entry fee + exit slippage + exit fee
         // Total: (slippage + fee) * 2 transactions
@@ -5646,52 +5764,52 @@ class ClientStrategy {
             const trailingStopLoss = signal._trailingPriceStopLoss;
             if (signal.position === "long") {
                 // LONG: trailing SL is positive if it's above entry (in profit zone)
-                const isPositiveTrailing = trailingStopLoss > signal.priceOpen;
+                const isPositiveTrailing = trailingStopLoss > effectivePriceOpen;
                 if (isPositiveTrailing) {
                     // Trailing stop is already protecting profit - breakeven achieved
                     return true;
                 }
                 // Trailing stop is negative (below entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice >= thresholdPrice;
-                const breakevenPrice = signal.priceOpen;
+                const breakevenPrice = effectivePriceOpen;
                 // Can upgrade to breakeven if threshold reached and breakeven is better than current trailing SL
                 return isThresholdReached && breakevenPrice > trailingStopLoss;
             }
             else {
                 // SHORT: trailing SL is positive if it's below entry (in profit zone)
-                const isPositiveTrailing = trailingStopLoss < signal.priceOpen;
+                const isPositiveTrailing = trailingStopLoss < effectivePriceOpen;
                 if (isPositiveTrailing) {
                     // Trailing stop is already protecting profit - breakeven achieved
                     return true;
                 }
                 // Trailing stop is negative (above entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice <= thresholdPrice;
-                const breakevenPrice = signal.priceOpen;
+                const breakevenPrice = effectivePriceOpen;
                 // Can upgrade to breakeven if threshold reached and breakeven is better than current trailing SL
                 return isThresholdReached && breakevenPrice < trailingStopLoss;
             }
         }
         // No trailing stop set - proceed with normal breakeven logic
         const currentStopLoss = signal.priceStopLoss;
-        const breakevenPrice = signal.priceOpen;
+        const breakevenPrice = effectivePriceOpen;
         // Calculate threshold price
         let thresholdPrice;
         let isThresholdReached;
         let canMoveToBreakeven;
         if (signal.position === "long") {
             // LONG: threshold reached when price goes UP by breakevenThresholdPercent from entry
-            thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+            thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
             isThresholdReached = currentPrice >= thresholdPrice;
             // Can move to breakeven only if threshold reached and SL is below entry
             canMoveToBreakeven = isThresholdReached && currentStopLoss < breakevenPrice;
         }
         else {
             // SHORT: threshold reached when price goes DOWN by breakevenThresholdPercent from entry
-            thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+            thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
             isThresholdReached = currentPrice <= thresholdPrice;
             // Can move to breakeven only if threshold reached and SL is above entry
             canMoveToBreakeven = isThresholdReached && currentStopLoss > breakevenPrice;
@@ -5774,6 +5892,8 @@ class ClientStrategy {
                 backtest: this.params.execution.context.backtest,
                 cancelId: cancelledSignal.cancelId,
                 timestamp: currentTime,
+                totalEntries: cancelledSignal._entry?.length ?? 1,
+                originalPriceOpen: cancelledSignal.priceOpen,
             });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -5814,6 +5934,8 @@ class ClientStrategy {
                 backtest: this.params.execution.context.backtest,
                 closeId: closedSignal.closeId,
                 timestamp: currentTime,
+                totalEntries: closedSignal._entry?.length ?? 1,
+                originalPriceOpen: closedSignal.priceOpen,
             });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -5894,8 +6016,10 @@ class ClientStrategy {
                 priceStopLoss: publicSignalForCommit.priceStopLoss,
                 originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                originalPriceOpen: publicSignalForCommit.originalPriceOpen,
                 scheduledAt: publicSignalForCommit.scheduledAt,
                 pendingAt: publicSignalForCommit.pendingAt,
+                totalEntries: publicSignalForCommit.totalEntries,
             });
             // Call onOpen callback
             await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -6026,6 +6150,8 @@ class ClientStrategy {
                 backtest: true,
                 cancelId: cancelledSignal.cancelId,
                 timestamp: closeTimestamp,
+                totalEntries: cancelledSignal._entry?.length ?? 1,
+                originalPriceOpen: cancelledSignal.priceOpen,
             });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
@@ -6063,6 +6189,8 @@ class ClientStrategy {
                 backtest: true,
                 closeId: closedSignal.closeId,
                 timestamp: closeTimestamp,
+                totalEntries: closedSignal._entry?.length ?? 1,
+                originalPriceOpen: closedSignal.priceOpen,
             });
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -6450,16 +6578,19 @@ class ClientStrategy {
             throw new Error(`ClientStrategy partialProfit: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
         // Validation: currentPrice must be moving toward TP (profit direction)
-        if (this._pendingSignal.position === "long") {
-            // For LONG: currentPrice must be higher than priceOpen (moving toward TP)
-            if (currentPrice <= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialProfit: For LONG position, currentPrice (${currentPrice}) must be > priceOpen (${this._pendingSignal.priceOpen})`);
+        {
+            const effectivePriceOpen = getEffectivePriceOpen(this._pendingSignal);
+            if (this._pendingSignal.position === "long") {
+                // For LONG: currentPrice must be higher than effectivePriceOpen (moving toward TP)
+                if (currentPrice <= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialProfit: For LONG position, currentPrice (${currentPrice}) must be > effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
-        }
-        else {
-            // For SHORT: currentPrice must be lower than priceOpen (moving toward TP)
-            if (currentPrice >= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialProfit: For SHORT position, currentPrice (${currentPrice}) must be < priceOpen (${this._pendingSignal.priceOpen})`);
+            else {
+                // For SHORT: currentPrice must be lower than effectivePriceOpen (moving toward TP)
+                if (currentPrice >= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialProfit: For SHORT position, currentPrice (${currentPrice}) must be < effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
         }
         // Check if currentPrice already crossed take profit level
@@ -6582,16 +6713,19 @@ class ClientStrategy {
             throw new Error(`ClientStrategy partialLoss: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
         // Validation: currentPrice must be moving toward SL (loss direction)
-        if (this._pendingSignal.position === "long") {
-            // For LONG: currentPrice must be lower than priceOpen (moving toward SL)
-            if (currentPrice >= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialLoss: For LONG position, currentPrice (${currentPrice}) must be < priceOpen (${this._pendingSignal.priceOpen})`);
+        {
+            const effectivePriceOpen = getEffectivePriceOpen(this._pendingSignal);
+            if (this._pendingSignal.position === "long") {
+                // For LONG: currentPrice must be lower than effectivePriceOpen (moving toward SL)
+                if (currentPrice >= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialLoss: For LONG position, currentPrice (${currentPrice}) must be < effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
-        }
-        else {
-            // For SHORT: currentPrice must be higher than priceOpen (moving toward SL)
-            if (currentPrice <= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialLoss: For SHORT position, currentPrice (${currentPrice}) must be > priceOpen (${this._pendingSignal.priceOpen})`);
+            else {
+                // For SHORT: currentPrice must be higher than effectivePriceOpen (moving toward SL)
+                if (currentPrice <= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialLoss: For SHORT position, currentPrice (${currentPrice}) must be > effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
         }
         // Check if currentPrice already crossed stop loss level
@@ -6712,7 +6846,7 @@ class ClientStrategy {
         }
         // Check for conflict with existing trailing take profit
         const signal = this._pendingSignal;
-        const breakevenPrice = signal.priceOpen;
+        const breakevenPrice = getEffectivePriceOpen(signal);
         const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
         if (signal.position === "long" && breakevenPrice >= effectiveTakeProfit) {
             // LONG: Breakeven SL would be at or above current TP - invalid configuration
@@ -6864,14 +6998,15 @@ class ClientStrategy {
         }
         // Calculate what the new stop loss would be
         const signal = this._pendingSignal;
-        const slDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
+        const slDistancePercent = Math.abs((effectivePriceOpen - signal.priceStopLoss) / effectivePriceOpen * 100);
         const newSlDistancePercent = slDistancePercent + percentShift;
         let newStopLoss;
         if (signal.position === "long") {
-            newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
+            newStopLoss = effectivePriceOpen * (1 - newSlDistancePercent / 100);
         }
         else {
-            newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
+            newStopLoss = effectivePriceOpen * (1 + newSlDistancePercent / 100);
         }
         // Check for price intrusion before executing trailing logic
         if (signal.position === "long" && currentPrice < newStopLoss) {
@@ -7037,14 +7172,15 @@ class ClientStrategy {
         }
         // Calculate what the new take profit would be
         const signal = this._pendingSignal;
-        const tpDistancePercent = Math.abs((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
+        const tpDistancePercent = Math.abs((signal.priceTakeProfit - effectivePriceOpen) / effectivePriceOpen * 100);
         const newTpDistancePercent = tpDistancePercent + percentShift;
         let newTakeProfit;
         if (signal.position === "long") {
-            newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+            newTakeProfit = effectivePriceOpen * (1 + newTpDistancePercent / 100);
         }
         else {
-            newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+            newTakeProfit = effectivePriceOpen * (1 - newTpDistancePercent / 100);
         }
         // Check for price intrusion before executing trailing logic
         if (signal.position === "long" && currentPrice > newTakeProfit) {
@@ -7126,6 +7262,70 @@ class ClientStrategy {
         });
         return true;
     }
+    /**
+     * Adds a new averaging entry to an open position (DCA — Dollar Cost Averaging).
+     *
+     * Appends currentPrice to the _entry array. The effective entry price used in all
+     * distance and PNL calculations becomes the simple arithmetic mean of all _entry prices.
+     * Original priceOpen is preserved unchanged for identity/audit purposes.
+     *
+     * Rejection rules (returns false without throwing):
+     * - LONG: currentPrice >= last entry price (must average down, not up or equal)
+     * - SHORT: currentPrice <= last entry price (must average down, not up or equal)
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - New entry price to add to the averaging history
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise<boolean> - true if entry added, false if rejected by direction check
+     */
+    async averageBuy(symbol, currentPrice, backtest) {
+        this.params.logger.debug("ClientStrategy averageBuy", {
+            symbol,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        // Validation: must have pending signal
+        if (!this._pendingSignal) {
+            throw new Error(`ClientStrategy averageBuy: No pending signal exists for symbol=${symbol}`);
+        }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy averageBuy: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Reject if any partial closes have already been executed
+        if (this._pendingSignal._partial && this._pendingSignal._partial.length > 0) {
+            this.params.logger.debug("ClientStrategy averageBuy: rejected — partial closes already executed", {
+                symbol,
+                partialCount: this._pendingSignal._partial.length,
+            });
+            return false;
+        }
+        // Execute averaging logic
+        const result = AVERAGE_BUY_FN(this, this._pendingSignal, currentPrice);
+        if (!result) {
+            return false;
+        }
+        // Persist updated signal state
+        this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
+            pendingSignal: this._pendingSignal,
+        });
+        // Call onWrite callback for testing persist storage
+        if (this.params.callbacks?.onWrite) {
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL(this._pendingSignal), backtest);
+        }
+        if (!backtest) {
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+        }
+        // Queue commit event for processing in tick()/backtest() with proper timestamp
+        this._commitQueue.push({
+            action: "average-buy",
+            symbol,
+            backtest,
+            currentPrice,
+            totalEntries: this._pendingSignal._entry?.length ?? 1,
+        });
+        return true;
+    }
 }
 
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
@@ -8250,6 +8450,27 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.activateScheduled(symbol, backtest, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Delegates to ClientStrategy.averageBuy() with current execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         */
+        this.averageBuy = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService averageBuy", {
+                symbol,
+                context,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.averageBuy(symbol, currentPrice, backtest);
+        };
     }
 }
 
@@ -8723,11 +8944,13 @@ const TO_RISK_SIGNAL = (signal, currentPrice) => {
         : 0;
     return {
         ...structuredClone(signal),
+        totalEntries: 1,
         priceOpen: signal.priceOpen ?? currentPrice,
         priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
         priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
         originalPriceTakeProfit: signal.priceTakeProfit,
+        originalPriceOpen: signal.priceOpen ?? currentPrice,
         partialExecuted,
     };
 };
@@ -11595,6 +11818,28 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.activateScheduled(backtest, symbol, context, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to add a new averaging entry to the position.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         */
+        this.averageBuy = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService averageBuy", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.averageBuy(backtest, symbol, currentPrice, context);
+        };
     }
 }
 
@@ -14142,6 +14387,18 @@ const backtest_columns = [
         format: (data) => `${data.signal.originalPriceStopLoss.toFixed(8)} USD`,
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => `${data.signal.originalPriceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => String(data.signal.totalEntries),
+        isVisible: () => true,
+    },
     {
         key: "pnl",
         label: "PNL (net)",
@@ -14429,6 +14686,20 @@ const live_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => data.originalPriceOpen !== undefined
+            ? `${data.originalPriceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => data.totalEntries !== undefined ? String(data.totalEntries) : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -14593,6 +14864,18 @@ const partial_columns = [
         format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(8)} USD` : "N/A"),
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(8)} USD` : "N/A"),
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => (data.totalEntries !== undefined ? String(data.totalEntries) : "N/A"),
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -14727,6 +15010,18 @@ const breakeven_columns = [
         format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(8)} USD` : "N/A"),
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(8)} USD` : "N/A"),
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => (data.totalEntries !== undefined ? String(data.totalEntries) : "N/A"),
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -14997,6 +15292,22 @@ const risk_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => data.currentSignal.originalPriceOpen !== undefined
+            ? `${data.currentSignal.originalPriceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => data.currentSignal.totalEntries !== undefined
+            ? String(data.currentSignal.totalEntries)
+            : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -15171,6 +15482,20 @@ const schedule_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => data.originalPriceOpen !== undefined
+            ? `${data.originalPriceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => data.totalEntries !== undefined ? String(data.totalEntries) : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -17260,6 +17585,8 @@ let ReportStorage$5 = class ReportStorage {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalEntries: data.signal.totalEntries,
+            originalPriceOpen: data.signal.originalPriceOpen,
             partialExecuted: data.signal.partialExecuted,
             scheduledAt: data.signal.scheduledAt,
         });
@@ -17289,6 +17616,8 @@ let ReportStorage$5 = class ReportStorage {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalEntries: data.signal.totalEntries,
+            originalPriceOpen: data.signal.originalPriceOpen,
             partialExecuted: data.signal.partialExecuted,
             duration: durationMin,
             pendingAt: data.signal.pendingAt,
@@ -17321,6 +17650,8 @@ let ReportStorage$5 = class ReportStorage {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalEntries: data.signal.totalEntries,
+            originalPriceOpen: data.signal.originalPriceOpen,
             partialExecuted: data.signal.partialExecuted,
             closeTimestamp: data.closeTimestamp,
             duration: durationMin,
@@ -20466,6 +20797,8 @@ let ReportStorage$3 = class ReportStorage {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            totalEntries: data.totalEntries,
+            originalPriceOpen: data.originalPriceOpen,
             partialExecuted: data.partialExecuted,
             note: data.note,
             pendingAt: data.pendingAt,
@@ -20500,6 +20833,8 @@ let ReportStorage$3 = class ReportStorage {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            totalEntries: data.totalEntries,
+            originalPriceOpen: data.originalPriceOpen,
             partialExecuted: data.partialExecuted,
             note: data.note,
             pendingAt: data.pendingAt,
@@ -21599,6 +21934,8 @@ let ReportStorage$2 = class ReportStorage {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            totalEntries: data.totalEntries,
+            originalPriceOpen: data.originalPriceOpen,
             partialExecuted: data.partialExecuted,
             note: data.note,
             pendingAt: data.pendingAt,
@@ -23602,6 +23939,8 @@ class ScheduleReportService {
                     priceStopLoss: data.signal?.priceStopLoss,
                     originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
                     originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalEntries: data.signal?.totalEntries,
+                    originalPriceOpen: data.signal?.originalPriceOpen,
                     partialExecuted: data.signal?.partialExecuted,
                     pendingAt: data.signal?.pendingAt,
                     minuteEstimatedTime: data.signal?.minuteEstimatedTime,
@@ -23646,6 +23985,8 @@ class ScheduleReportService {
                     priceStopLoss: data.signal?.priceStopLoss,
                     originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
                     originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalEntries: data.signal?.totalEntries,
+                    originalPriceOpen: data.signal?.originalPriceOpen,
                     partialExecuted: data.signal?.partialExecuted,
                     scheduledAt: data.signal?.scheduledAt,
                     pendingAt: data.signal?.pendingAt,
@@ -24123,6 +24464,8 @@ class PartialReportService {
                 priceStopLoss: data.data.priceStopLoss,
                 originalPriceTakeProfit: data.data.originalPriceTakeProfit,
                 originalPriceStopLoss: data.data.originalPriceStopLoss,
+                totalEntries: data.data.totalEntries,
+                originalPriceOpen: data.data.originalPriceOpen,
                 partialExecuted: data.data.partialExecuted,
                 _partial: data.data._partial,
                 note: data.data.note,
@@ -24164,6 +24507,8 @@ class PartialReportService {
                 priceStopLoss: data.data.priceStopLoss,
                 originalPriceTakeProfit: data.data.originalPriceTakeProfit,
                 originalPriceStopLoss: data.data.originalPriceStopLoss,
+                totalEntries: data.data.totalEntries,
+                originalPriceOpen: data.data.originalPriceOpen,
                 partialExecuted: data.data.partialExecuted,
                 _partial: data.data._partial,
                 note: data.data.note,
@@ -24286,6 +24631,8 @@ class BreakevenReportService {
                 priceStopLoss: data.data.priceStopLoss,
                 originalPriceTakeProfit: data.data.originalPriceTakeProfit,
                 originalPriceStopLoss: data.data.originalPriceStopLoss,
+                totalEntries: data.data.totalEntries,
+                originalPriceOpen: data.data.originalPriceOpen,
                 partialExecuted: data.data.partialExecuted,
                 _partial: data.data._partial,
                 note: data.data.note,
@@ -24594,7 +24941,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService partialProfit", {
                 symbol,
                 percentToClose,
@@ -24626,6 +24973,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24655,7 +25004,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService partialLoss", {
                 symbol,
                 percentToClose,
@@ -24687,6 +25036,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24716,7 +25067,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService trailingStop", {
                 symbol,
                 percentShift,
@@ -24748,6 +25099,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24777,7 +25130,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService trailingTake", {
                 symbol,
                 percentShift,
@@ -24809,6 +25162,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24837,7 +25192,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService breakeven", {
                 symbol,
                 currentPrice,
@@ -24867,6 +25222,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24896,7 +25253,7 @@ class StrategyReportService {
          * @param pendingAt - Pending timestamp in milliseconds
          * @param activateId - Optional identifier for the activation reason
          */
-        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId) => {
             this.loggerService.log("strategyReportService activateScheduled", {
                 symbol,
                 currentPrice,
@@ -24928,6 +25285,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24939,6 +25298,71 @@ class StrategyReportService {
                 walkerName: "",
             });
         };
+        /**
+         * Logs an average-buy (DCA) event when a new averaging entry is added to an open position.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Price at which the new averaging entry was executed
+         * @param effectivePriceOpen - Averaged entry price after this addition
+         * @param totalEntries - Total number of DCA entries after this addition
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Original entry price (unchanged by averaging)
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.averageBuy = async (symbol, currentPrice, effectivePriceOpen, totalEntries, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, originalPriceOpen) => {
+            this.loggerService.log("strategyReportService averageBuy", {
+                symbol,
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                isBacktest,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!pendingRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            await Report.writeData("strategy", {
+                action: "average-buy",
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                symbol,
+                timestamp,
+                createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                originalPriceOpen,
+                scheduledAt,
+                pendingAt,
+            }, {
+                signalId: pendingRow.id,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                strategyName: context.strategyName,
+                symbol,
+                walkerName: "",
+            });
+        };
         /**
          * Initializes the service for event logging.
          *
@@ -24969,43 +25393,50 @@ class StrategyReportService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unPartialLoss = strategyCommitSubject
                 .filter(({ action }) => action === "partial-loss")
                 .connect(async (event) => await this.partialLoss(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingStop = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-stop")
                 .connect(async (event) => await this.trailingStop(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingTake = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-take")
                 .connect(async (event) => await this.trailingTake(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unBreakeven = strategyCommitSubject
                 .filter(({ action }) => action === "breakeven")
                 .connect(async (event) => await this.breakeven(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unActivateScheduled = strategyCommitSubject
                 .filter(({ action }) => action === "activate-scheduled")
                 .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
-            const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId));
+            const unAverageBuy = strategyCommitSubject
+                .filter(({ action }) => action === "average-buy")
+                .connect(async (event) => await this.averageBuy(event.symbol, event.currentPrice, event.effectivePriceOpen, event.totalEntries, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.originalPriceOpen));
+            const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled(), () => unAverageBuy());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -25137,6 +25568,7 @@ class ReportStorage {
                 trailingTakeCount: 0,
                 breakevenCount: 0,
                 activateScheduledCount: 0,
+                averageBuyCount: 0,
             };
         }
         return {
@@ -25150,6 +25582,7 @@ class ReportStorage {
             trailingTakeCount: this._eventList.filter(e => e.action === "trailing-take").length,
             breakevenCount: this._eventList.filter(e => e.action === "breakeven").length,
             activateScheduledCount: this._eventList.filter(e => e.action === "activate-scheduled").length,
+            averageBuyCount: this._eventList.filter(e => e.action === "average-buy").length,
         };
     }
     /**
@@ -25199,6 +25632,7 @@ class ReportStorage {
             `- Trailing take: ${stats.trailingTakeCount}`,
             `- Breakeven: ${stats.breakevenCount}`,
             `- Activate scheduled: ${stats.activateScheduledCount}`,
+            `- Average buy: ${stats.averageBuyCount}`,
         ].join("\n");
     }
     /**
@@ -25386,7 +25820,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService partialProfit", {
                 symbol,
                 percentToClose,
@@ -25424,6 +25858,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25446,7 +25882,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService partialLoss", {
                 symbol,
                 percentToClose,
@@ -25484,6 +25920,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25506,7 +25944,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService trailingStop", {
                 symbol,
                 percentShift,
@@ -25544,6 +25982,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25566,7 +26006,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService trailingTake", {
                 symbol,
                 percentShift,
@@ -25604,6 +26044,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25625,7 +26067,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService breakeven", {
                 symbol,
                 currentPrice,
@@ -25661,6 +26103,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25683,7 +26127,7 @@ class StrategyMarkdownService {
          * @param pendingAt - Pending timestamp in milliseconds
          * @param activateId - Optional identifier for the activation reason
          */
-        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId) => {
             this.loggerService.log("strategyMarkdownService activateScheduled", {
                 symbol,
                 currentPrice,
@@ -25721,6 +26165,72 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
+                scheduledAt,
+                pendingAt,
+            });
+        };
+        /**
+         * Records an average-buy (DCA) event when a new averaging entry is added to an open position.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Price at which the new averaging entry was executed
+         * @param effectivePriceOpen - Averaged entry price after this addition
+         * @param totalEntries - Total number of DCA entries after this addition
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Original entry price (unchanged by averaging)
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.averageBuy = async (symbol, currentPrice, effectivePriceOpen, totalEntries, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, originalPriceOpen) => {
+            this.loggerService.log("strategyMarkdownService averageBuy", {
+                symbol,
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                isBacktest,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!pendingRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
+            storage.addEvent({
+                timestamp,
+                symbol,
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                signalId: pendingRow.id,
+                action: "average-buy",
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                createdAt,
+                backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                originalPriceOpen,
                 scheduledAt,
                 pendingAt,
             });
@@ -25869,43 +26379,50 @@ class StrategyMarkdownService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unPartialLoss = strategyCommitSubject
                 .filter(({ action }) => action === "partial-loss")
                 .connect(async (event) => await this.partialLoss(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingStop = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-stop")
                 .connect(async (event) => await this.trailingStop(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingTake = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-take")
                 .connect(async (event) => await this.trailingTake(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unBreakeven = strategyCommitSubject
                 .filter(({ action }) => action === "breakeven")
                 .connect(async (event) => await this.breakeven(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unActivateScheduled = strategyCommitSubject
                 .filter(({ action }) => action === "activate-scheduled")
                 .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
-            const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId));
+            const unAverageBuy = strategyCommitSubject
+                .filter(({ action }) => action === "average-buy")
+                .connect(async (event) => await this.averageBuy(event.symbol, event.currentPrice, event.effectivePriceOpen, event.totalEntries, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.originalPriceOpen));
+            const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled(), () => unAverageBuy());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -27711,6 +28228,7 @@ const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
 const TRAILING_PROFIT_METHOD_NAME = "strategy.commitTrailingTake";
 const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
 const ACTIVATE_SCHEDULED_METHOD_NAME = "strategy.commitActivateScheduled";
+const AVERAGE_BUY_METHOD_NAME = "strategy.commitAverageBuy";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -28063,6 +28581,45 @@ async function commitActivateScheduled(symbol, activateId) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     await bt.strategyCoreService.activateScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, activateId);
 }
+/**
+ * Adds a new DCA entry to the active pending signal.
+ *
+ * Adds a new averaging entry at the current market price to the position's
+ * entry history. Updates effectivePriceOpen (mean of all entries) and emits
+ * an average-buy commit event.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<boolean> - true if entry added, false if rejected
+ *
+ * @example
+ * ```typescript
+ * import { commitAverageBuy } from "backtest-kit";
+ *
+ * // Add DCA entry at current market price
+ * const success = await commitAverageBuy("BTCUSDT");
+ * if (success) {
+ *   console.log("DCA entry added");
+ * }
+ * ```
+ */
+async function commitAverageBuy(symbol) {
+    bt.loggerService.info(AVERAGE_BUY_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitAverageBuy requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitAverageBuy requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.averageBuy(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -30343,6 +30900,7 @@ const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
 const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.commitTrailingTake";
 const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
+const BACKTEST_METHOD_NAME_AVERAGE_BUY = "Backtest.commitAverageBuy";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -31239,6 +31797,49 @@ class BacktestUtils {
             }
             await bt.strategyCoreService.activateScheduled(true, symbol, context, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Adds a new averaging entry at currentPrice to the position's entry history.
+         * Updates effectivePriceOpen (mean of all entries) and emits average-buy commit event.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         *
+         * @example
+         * ```typescript
+         * // Add DCA entry at current price
+         * const success = await Backtest.commitAverageBuy("BTCUSDT", 42000, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "1h"
+         * });
+         * if (success) {
+         *   console.log('DCA entry added');
+         * }
+         * ```
+         */
+        this.commitAverageBuy = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_AVERAGE_BUY, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_AVERAGE_BUY);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_AVERAGE_BUY);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_AVERAGE_BUY);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_AVERAGE_BUY));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_AVERAGE_BUY));
+            }
+            return await bt.strategyCoreService.averageBuy(true, symbol, currentPrice, context);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -31415,6 +32016,7 @@ const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
 const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.commitTrailingTake";
 const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
+const LIVE_METHOD_NAME_AVERAGE_BUY = "Live.commitAverageBuy";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -32279,6 +32881,49 @@ class LiveUtils {
                 frameName: "",
             }, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Adds a new averaging entry at currentPrice to the position's entry history.
+         * Updates effectivePriceOpen (mean of all entries) and emits average-buy commit event.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         *
+         * @example
+         * ```typescript
+         * // Add DCA entry at current price
+         * const success = await Live.commitAverageBuy("BTCUSDT", 42000, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance"
+         * });
+         * if (success) {
+         *   console.log('DCA entry added');
+         * }
+         * ```
+         */
+        this.commitAverageBuy = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_AVERAGE_BUY, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_AVERAGE_BUY);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_AVERAGE_BUY);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_AVERAGE_BUY));
+            }
+            return await bt.strategyCoreService.averageBuy(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -34942,6 +35587,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             note: data.signal.note,
             scheduledAt: data.signal.scheduledAt,
             pendingAt: data.signal.pendingAt,
@@ -34967,6 +35614,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             pnlPercentage: data.pnl.pnlPercentage,
             closeReason: data.closeReason,
             duration: durationMin,
@@ -34992,6 +35641,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             scheduledAt: data.signal.scheduledAt,
             currentPrice: data.currentPrice,
             createdAt: data.createdAt,
@@ -35015,6 +35666,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             cancelReason: data.reason,
             cancelId: data.cancelId,
             duration: durationMin,
@@ -35047,6 +35700,8 @@ const CREATE_PARTIAL_PROFIT_NOTIFICATION_FN = (data) => ({
     priceStopLoss: data.data.priceStopLoss,
     originalPriceTakeProfit: data.data.originalPriceTakeProfit,
     originalPriceStopLoss: data.data.originalPriceStopLoss,
+    originalPriceOpen: data.data.originalPriceOpen,
+    totalEntries: data.data.totalEntries,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -35073,6 +35728,8 @@ const CREATE_PARTIAL_LOSS_NOTIFICATION_FN = (data) => ({
     priceStopLoss: data.data.priceStopLoss,
     originalPriceTakeProfit: data.data.originalPriceTakeProfit,
     originalPriceStopLoss: data.data.originalPriceStopLoss,
+    originalPriceOpen: data.data.originalPriceOpen,
+    totalEntries: data.data.totalEntries,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -35098,6 +35755,8 @@ const CREATE_BREAKEVEN_NOTIFICATION_FN = (data) => ({
     priceStopLoss: data.data.priceStopLoss,
     originalPriceTakeProfit: data.data.originalPriceTakeProfit,
     originalPriceStopLoss: data.data.originalPriceStopLoss,
+    originalPriceOpen: data.data.originalPriceOpen,
+    totalEntries: data.data.totalEntries,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -35128,6 +35787,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35151,6 +35812,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35173,6 +35836,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35196,6 +35861,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35219,6 +35886,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35242,6 +35911,33 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    if (data.action === "average-buy") {
+        return {
+            type: "average_buy.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            currentPrice: data.currentPrice,
+            effectivePriceOpen: data.effectivePriceOpen,
+            totalEntries: data.totalEntries,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -37631,6 +38327,7 @@ exports.addWalkerSchema = addWalkerSchema;
 exports.alignToInterval = alignToInterval;
 exports.checkCandles = checkCandles;
 exports.commitActivateScheduled = commitActivateScheduled;
+exports.commitAverageBuy = commitAverageBuy;
 exports.commitBreakeven = commitBreakeven;
 exports.commitCancelScheduled = commitCancelScheduled;
 exports.commitClosePending = commitClosePending;