backtest-kit 1.10.2 → 1.10.3

package/build/index.cjs

@@ -2124,8 +2124,10 @@ const TIMEOUT_SYMBOL = Symbol('timeout');
  * It hides internal implementation details while exposing effective values:
  *
  * - Replaces internal _trailingPriceStopLoss with effective priceStopLoss
+ * - Replaces internal _trailingPriceTakeProfit with effective priceTakeProfit
  * - Preserves original stop-loss in originalPriceStopLoss for reference
- * - Ensures external code never sees private _trailingPriceStopLoss field
+ * - Preserves original take-profit in originalPriceTakeProfit for reference
+ * - Ensures external code never sees private _trailing* fields
  * - Maintains backward compatibility with non-trailing positions
  *
  * Key differences from TO_RISK_SIGNAL (in ClientRisk.ts):
@@ -2140,34 +2142,37 @@ const TIMEOUT_SYMBOL = Symbol('timeout');
  * - Event emissions and logging
  * - Integration with ClientPartial and ClientRisk
  *
- * @param signal - Internal signal row with optional trailing stop-loss
- * @returns Signal in IPublicSignalRow format with effective stop-loss and hidden internals
+ * @param signal - Internal signal row with optional trailing stop-loss/take-profit
+ * @returns Signal in IPublicSignalRow format with effective SL/TP and hidden internals
  *
  * @example
  * ```typescript
- * // Signal without trailing SL
+ * // Signal without trailing SL/TP
  * const publicSignal = TO_PUBLIC_SIGNAL(signal);
  * // publicSignal.priceStopLoss = signal.priceStopLoss
+ * // publicSignal.priceTakeProfit = signal.priceTakeProfit
  * // publicSignal.originalPriceStopLoss = signal.priceStopLoss
+ * // publicSignal.originalPriceTakeProfit = signal.priceTakeProfit
  *
- * // Signal with trailing SL
+ * // Signal with trailing SL/TP
  * const publicSignal = TO_PUBLIC_SIGNAL(signalWithTrailing);
  * // publicSignal.priceStopLoss = signal._trailingPriceStopLoss (effective)
+ * // publicSignal.priceTakeProfit = signal._trailingPriceTakeProfit (effective)
  * // publicSignal.originalPriceStopLoss = signal.priceStopLoss (original)
+ * // publicSignal.originalPriceTakeProfit = signal.priceTakeProfit (original)
  * // publicSignal._trailingPriceStopLoss = undefined (hidden from external API)
+ * // publicSignal._trailingPriceTakeProfit = undefined (hidden from external API)
  * ```
  */
 const TO_PUBLIC_SIGNAL = (signal) => {
-    if (signal._trailingPriceStopLoss !== undefined) {
-        return {
-            ...structuredClone(signal),
-            priceStopLoss: signal._trailingPriceStopLoss,
-            originalPriceStopLoss: signal.priceStopLoss,
-        };
-    }
+    const hasTrailingSL = signal._trailingPriceStopLoss !== undefined;
+    const hasTrailingTP = signal._trailingPriceTakeProfit !== undefined;
     return {
         ...structuredClone(signal),
+        priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
+        priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
+        originalPriceTakeProfit: signal.priceTakeProfit,
     };
 };
 const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
@@ -2672,33 +2677,29 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
     });
 };
 const TRAILING_STOP_FN = (self, signal, percentShift) => {
-    // Calculate distance between entry and original stop-loss AS PERCENTAGE of entry price
-    const slDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
-    // Calculate new stop-loss distance percentage by adding shift
+    // Get current effective stop-loss (trailing or original)
+    const currentStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+    // Calculate distance between entry and CURRENT stop-loss AS PERCENTAGE of entry price
+    const currentSlDistancePercent = Math.abs((signal.priceOpen - currentStopLoss) / signal.priceOpen * 100);
+    // Calculate new stop-loss distance percentage by adding shift to CURRENT distance
     // Negative percentShift: reduces distance % (tightens stop, moves SL toward entry or beyond)
     // Positive percentShift: increases distance % (loosens stop, moves SL away from entry)
-    const newSlDistancePercent = slDistancePercent + percentShift;
+    const newSlDistancePercent = currentSlDistancePercent + percentShift;
     // Calculate new stop-loss price based on new distance percentage
     // Negative newSlDistancePercent means SL crosses entry into profit zone
     let newStopLoss;
     if (signal.position === "long") {
         // LONG: SL is below entry (or above entry if in profit zone)
         // Formula: entry * (1 - newDistance%)
-        // Example: entry=100, originalSL=90 (10%), shift=-15% → newDistance=-5% → 100 * 1.05 = 105 (profit zone)
-        // Example: entry=100, originalSL=90 (10%), shift=-5% → newDistance=5% → 100 * 0.95 = 95 (tighter)
-        // Example: entry=100, originalSL=90 (10%), shift=+5% → newDistance=15% → 100 * 0.85 = 85 (looser)
+        // Example: entry=100, currentSL=95 (5%), shift=-3% → newDistance=2% → 100 * 0.98 = 98 (tighter)
         newStopLoss = signal.priceOpen * (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=-15% → newDistance=-5% → 100 * 0.95 = 95 (profit zone)
-        // Example: entry=100, originalSL=110 (10%), shift=-5% → newDistance=5% → 100 * 1.05 = 105 (tighter)
-        // Example: entry=100, originalSL=110 (10%), shift=+5% → newDistance=15% → 100 * 1.15 = 115 (looser)
+        // Example: entry=100, currentSL=105 (5%), shift=-3% → newDistance=2% → 100 * 1.02 = 102 (tighter)
         newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
     }
-    // Get current effective stop-loss (trailing or original)
-    const currentStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
     // Determine if this is the first trailing stop call (direction not set yet)
     const isFirstCall = signal._trailingPriceStopLoss === undefined;
     if (isFirstCall) {
@@ -2709,7 +2710,7 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalStopLoss: signal.priceStopLoss,
-            originalDistancePercent: slDistancePercent,
+            currentDistancePercent: currentSlDistancePercent,
             previousStopLoss: currentStopLoss,
             newStopLoss,
             newDistancePercent: newSlDistancePercent,
@@ -2720,19 +2721,28 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
     }
     else {
         // Subsequent calls: only update if new SL continues in the same direction
-        const movingUp = newStopLoss > currentStopLoss;
-        const movingDown = newStopLoss < currentStopLoss;
-        // Determine initial direction based on first trailing SL vs original SL
-        const initialDirection = signal._trailingPriceStopLoss > signal.priceStopLoss ? "up" : "down";
-        let shouldUpdate = false;
-        if (initialDirection === "up" && movingUp) {
-            // Direction is UP, and new SL continues moving up
-            shouldUpdate = true;
-        }
-        else if (initialDirection === "down" && movingDown) {
-            // Direction is DOWN, and new SL continues moving down
-            shouldUpdate = true;
+        // Determine initial direction: "closer" or "farther" relative to entry
+        let initialDirection;
+        if (signal.position === "long") {
+            // LONG: closer = SL closer to entry = higher SL value (moving up)
+            initialDirection = signal._trailingPriceStopLoss > signal.priceStopLoss ? "closer" : "farther";
         }
+        else {
+            // SHORT: closer = SL closer to entry = lower SL value (moving down)
+            initialDirection = signal._trailingPriceStopLoss < signal.priceStopLoss ? "closer" : "farther";
+        }
+        // Determine new direction
+        let newDirection;
+        if (signal.position === "long") {
+            // LONG: closer = higher SL value
+            newDirection = newStopLoss > currentStopLoss ? "closer" : "farther";
+        }
+        else {
+            // SHORT: closer = lower SL value
+            newDirection = newStopLoss < currentStopLoss ? "closer" : "farther";
+        }
+        // Only allow continuation in same direction
+        const shouldUpdate = initialDirection === newDirection;
         if (!shouldUpdate) {
             self.params.logger.debug("TRAILING_STOP_FN: new SL not in same direction, skipping", {
                 signalId: signal.id,
@@ -2741,7 +2751,7 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
                 newStopLoss,
                 percentShift,
                 initialDirection,
-                attemptedDirection: movingUp ? "up" : movingDown ? "down" : "same",
+                attemptedDirection: newDirection,
             });
             return;
         }
@@ -2752,7 +2762,7 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalStopLoss: signal.priceStopLoss,
-            originalDistancePercent: slDistancePercent,
+            currentDistancePercent: currentSlDistancePercent,
             previousStopLoss: currentStopLoss,
             newStopLoss,
             newDistancePercent: newSlDistancePercent,
@@ -2762,6 +2772,99 @@ const TRAILING_STOP_FN = (self, signal, percentShift) => {
         });
     }
 };
+const TRAILING_PROFIT_FN = (self, signal, percentShift) => {
+    // Get current effective take-profit (trailing or original)
+    const currentTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+    // Calculate distance between entry and CURRENT take-profit AS PERCENTAGE of entry price
+    const currentTpDistancePercent = Math.abs((currentTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+    // Calculate new take-profit distance percentage by adding shift to CURRENT distance
+    // Negative percentShift: reduces distance % (brings TP closer to entry)
+    // Positive percentShift: increases distance % (moves TP further from entry)
+    const newTpDistancePercent = currentTpDistancePercent + percentShift;
+    // Calculate new take-profit price based on new distance percentage
+    let newTakeProfit;
+    if (signal.position === "long") {
+        // LONG: TP is above entry
+        // Formula: entry * (1 + newDistance%)
+        // Example: entry=100, currentTP=115 (15%), shift=-3% → newDistance=12% → 100 * 1.12 = 112 (closer)
+        newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+    }
+    else {
+        // SHORT: TP is below entry
+        // Formula: entry * (1 - newDistance%)
+        // Example: entry=100, currentTP=85 (15%), shift=-3% → newDistance=12% → 100 * 0.88 = 88 (closer)
+        newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+    }
+    // Determine if this is the first trailing profit call (direction not set yet)
+    const isFirstCall = signal._trailingPriceTakeProfit === undefined;
+    if (isFirstCall) {
+        // First call: set the direction and update TP unconditionally
+        signal._trailingPriceTakeProfit = newTakeProfit;
+        self.params.logger.info("TRAILING_PROFIT_FN executed (first call - direction set)", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            originalTakeProfit: signal.priceTakeProfit,
+            currentDistancePercent: currentTpDistancePercent,
+            previousTakeProfit: currentTakeProfit,
+            newTakeProfit,
+            newDistancePercent: newTpDistancePercent,
+            percentShift,
+            direction: newTakeProfit > currentTakeProfit ? "up" : "down",
+        });
+    }
+    else {
+        // Subsequent calls: only update if new TP continues in the same direction
+        // Determine initial direction: "closer" or "farther" relative to entry
+        let initialDirection;
+        if (signal.position === "long") {
+            // LONG: closer = TP closer to entry = lower TP value
+            initialDirection = signal._trailingPriceTakeProfit < signal.priceTakeProfit ? "closer" : "farther";
+        }
+        else {
+            // SHORT: closer = TP closer to entry = higher TP value  
+            initialDirection = signal._trailingPriceTakeProfit > signal.priceTakeProfit ? "closer" : "farther";
+        }
+        // Determine new direction
+        let newDirection;
+        if (signal.position === "long") {
+            // LONG: closer = lower TP value
+            newDirection = newTakeProfit < currentTakeProfit ? "closer" : "farther";
+        }
+        else {
+            // SHORT: closer = higher TP value
+            newDirection = newTakeProfit > currentTakeProfit ? "closer" : "farther";
+        }
+        // Only allow continuation in same direction
+        const shouldUpdate = initialDirection === newDirection;
+        if (!shouldUpdate) {
+            self.params.logger.debug("TRAILING_PROFIT_FN: new TP not in same direction, skipping", {
+                signalId: signal.id,
+                position: signal.position,
+                currentTakeProfit,
+                newTakeProfit,
+                percentShift,
+                initialDirection,
+                attemptedDirection: newDirection,
+            });
+            return;
+        }
+        // Update trailing take-profit
+        signal._trailingPriceTakeProfit = newTakeProfit;
+        self.params.logger.info("TRAILING_PROFIT_FN executed", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            originalTakeProfit: signal.priceTakeProfit,
+            currentDistancePercent: currentTpDistancePercent,
+            previousTakeProfit: currentTakeProfit,
+            newTakeProfit,
+            newDistancePercent: newTpDistancePercent,
+            percentShift,
+            direction: initialDirection,
+        });
+    }
+};
 const BREAKEVEN_FN = (self, signal, currentPrice) => {
     // Calculate breakeven threshold based on slippage and fees
     // Need to cover: entry slippage + entry fee + exit slippage + exit fee
@@ -3573,13 +3676,14 @@ const CHECK_PENDING_SIGNAL_COMPLETION_FN = async (self, signal, averagePrice) =>
     if (elapsedTime >= maxTimeToWait) {
         return await CLOSE_PENDING_SIGNAL_FN(self, signal, averagePrice, "time_expired");
     }
-    // Check take profit
-    if (signal.position === "long" && averagePrice >= signal.priceTakeProfit) {
-        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceTakeProfit, // КРИТИЧНО: используем точную цену TP
+    // Check take profit (use trailing TP if set, otherwise original TP)
+    const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+    if (signal.position === "long" && averagePrice >= effectiveTakeProfit) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, effectiveTakeProfit, // КРИТИЧНО: используем точную цену TP
         "take_profit");
     }
-    if (signal.position === "short" && averagePrice <= signal.priceTakeProfit) {
-        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceTakeProfit, // КРИТИЧНО: используем точную цену TP
+    if (signal.position === "short" && averagePrice <= effectiveTakeProfit) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, effectiveTakeProfit, // КРИТИЧНО: используем точную цену TP
         "take_profit");
     }
     // Check stop loss (use trailing SL if set, otherwise original SL)
@@ -3641,8 +3745,9 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
             }
             if (currentDistance > 0) {
-                // Moving towards TP
-                const tpDistance = signal.priceTakeProfit - signal.priceOpen;
+                // Moving towards TP (use trailing TP if set)
+                const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                const tpDistance = effectiveTakeProfit - signal.priceOpen;
                 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);
@@ -3664,8 +3769,9 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
             }
             if (currentDistance > 0) {
-                // Moving towards TP
-                const tpDistance = signal.priceOpen - signal.priceTakeProfit;
+                // Moving towards TP (use trailing TP if set)
+                const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                const tpDistance = signal.priceOpen - 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);
@@ -3927,11 +4033,12 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         }
         // Check TP/SL only if not expired
         // КРИТИЧНО: используем averagePrice (VWAP) для проверки достижения TP/SL (как в live mode)
-        // КРИТИЧНО: используем trailing SL если установлен
+        // КРИТИЧНО: используем trailing SL и TP если установлены
         const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+        const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
         if (!shouldClose && signal.position === "long") {
             // Для LONG: TP срабатывает если VWAP >= TP, SL если VWAP <= SL
-            if (averagePrice >= signal.priceTakeProfit) {
+            if (averagePrice >= effectiveTakeProfit) {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
@@ -3942,7 +4049,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         }
         if (!shouldClose && signal.position === "short") {
             // Для SHORT: TP срабатывает если VWAP <= TP, SL если VWAP >= SL
-            if (averagePrice <= signal.priceTakeProfit) {
+            if (averagePrice <= effectiveTakeProfit) {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
@@ -3955,7 +4062,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
             // КРИТИЧНО: используем точную цену TP/SL для закрытия (как в live mode)
             let closePrice;
             if (closeReason === "take_profit") {
-                closePrice = signal.priceTakeProfit;
+                closePrice = effectiveTakeProfit; // используем trailing TP если установлен
             }
             else if (closeReason === "stop_loss") {
                 closePrice = effectiveStopLoss;
@@ -3976,8 +4083,9 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 if (currentDistance > 0) {
-                    // Moving towards TP
-                    const tpDistance = signal.priceTakeProfit - signal.priceOpen;
+                    // Moving towards TP (use trailing TP if set)
+                    const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                    const tpDistance = effectiveTakeProfit - signal.priceOpen;
                     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);
                 }
@@ -3997,8 +4105,9 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 if (currentDistance > 0) {
-                    // Moving towards TP
-                    const tpDistance = signal.priceOpen - signal.priceTakeProfit;
+                    // Moving towards TP (use trailing TP if set)
+                    const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+                    const tpDistance = signal.priceOpen - 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);
                 }
@@ -4983,6 +5092,32 @@ class ClientStrategy {
             });
             return;
         }
+        // Check for conflict with existing trailing take profit
+        const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+        if (signal.position === "long" && newStopLoss >= effectiveTakeProfit) {
+            // LONG: New SL would be at or above current TP - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingStop: SL/TP conflict detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                effectiveTakeProfit,
+                reason: "newStopLoss >= effectiveTakeProfit (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && newStopLoss <= effectiveTakeProfit) {
+            // SHORT: New SL would be at or below current TP - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingStop: SL/TP conflict detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                effectiveTakeProfit,
+                reason: "newStopLoss <= effectiveTakeProfit (SHORT position)"
+            });
+            return;
+        }
         // Execute trailing logic
         TRAILING_STOP_FN(this, this._pendingSignal, percentShift);
         // Persist updated signal state (inline setPendingSignal content)
@@ -4999,6 +5134,136 @@ class ClientStrategy {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
     }
+    /**
+     * Adjusts the trailing take-profit distance for an active pending signal.
+     *
+     * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+     * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+     * Once direction is set on first call, subsequent calls must continue in same direction.
+     *
+     * Price intrusion protection: If current price has already crossed the new TP level,
+     * the update is skipped to prevent immediate TP triggering.
+     *
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise that resolves when trailing TP is updated
+     *
+     * @example
+     * ```typescript
+     * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+     * // Move TP further by 50%: newTP = 100 + 15% = 115
+     * await strategy.trailingProfit("BTCUSDT", 50, 102, false);
+     *
+     * // SHORT: entry=100, originalTP=90, distance=10%, currentPrice=98
+     * // Move TP closer by 30%: newTP = 100 - 7% = 93
+     * await strategy.trailingProfit("BTCUSDT", -30, 98, false);
+     * ```
+     */
+    async trailingProfit(symbol, percentShift, currentPrice, backtest) {
+        this.params.logger.debug("ClientStrategy trailingProfit", {
+            symbol,
+            percentShift,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        // Validation: must have pending signal
+        if (!this._pendingSignal) {
+            throw new Error(`ClientStrategy trailingProfit: No pending signal exists for symbol=${symbol}`);
+        }
+        // Validation: percentShift must be valid
+        if (typeof percentShift !== "number" || !isFinite(percentShift)) {
+            throw new Error(`ClientStrategy trailingProfit: percentShift must be a finite number, got ${percentShift} (${typeof percentShift})`);
+        }
+        if (percentShift < -100 || percentShift > 100) {
+            throw new Error(`ClientStrategy trailingProfit: percentShift must be in range [-100, 100], got ${percentShift}`);
+        }
+        if (percentShift === 0) {
+            throw new Error(`ClientStrategy trailingProfit: percentShift cannot be 0`);
+        }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy trailingProfit: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Calculate what the new take profit would be
+        const signal = this._pendingSignal;
+        const tpDistancePercent = Math.abs((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+        const newTpDistancePercent = tpDistancePercent + percentShift;
+        let newTakeProfit;
+        if (signal.position === "long") {
+            newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+        }
+        else {
+            newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+        }
+        // Check for price intrusion before executing trailing logic
+        if (signal.position === "long" && currentPrice > newTakeProfit) {
+            // LONG: Price already crossed the new take profit level - skip setting TP
+            this.params.logger.debug("ClientStrategy trailingProfit: price intrusion detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                currentPrice,
+                reason: "currentPrice above newTakeProfit (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && currentPrice < newTakeProfit) {
+            // SHORT: Price already crossed the new take profit level - skip setting TP
+            this.params.logger.debug("ClientStrategy trailingProfit: price intrusion detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                currentPrice,
+                reason: "currentPrice below newTakeProfit (SHORT position)"
+            });
+            return;
+        }
+        // Check for conflict with existing trailing stop loss
+        const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+        if (signal.position === "long" && newTakeProfit <= effectiveStopLoss) {
+            // LONG: New TP would be at or below current SL - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingProfit: TP/SL conflict detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                effectiveStopLoss,
+                reason: "newTakeProfit <= effectiveStopLoss (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && newTakeProfit >= effectiveStopLoss) {
+            // SHORT: New TP would be at or above current SL - invalid configuration
+            this.params.logger.debug("ClientStrategy trailingProfit: TP/SL conflict detected, skipping TP update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newTakeProfit,
+                effectiveStopLoss,
+                reason: "newTakeProfit >= effectiveStopLoss (SHORT position)"
+            });
+            return;
+        }
+        // Execute trailing logic
+        TRAILING_PROFIT_FN(this, this._pendingSignal, percentShift);
+        // Persist updated signal state (inline setPendingSignal content)
+        // Note: this._pendingSignal already mutated by TRAILING_PROFIT_FN, no reassignment needed
+        this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
+            pendingSignal: this._pendingSignal,
+        });
+        // Call onWrite callback for testing persist storage
+        if (this.params.callbacks?.onWrite) {
+            const publicSignal = TO_PUBLIC_SIGNAL(this._pendingSignal);
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
+        }
+        if (!backtest) {
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+        }
+    }
 }
 
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
@@ -5787,6 +6052,45 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.trailingStop(symbol, percentShift, currentPrice, backtest);
         };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+         *
+         * Delegates to ClientStrategy.trailingProfit() with current execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await strategyConnectionService.trailingProfit(
+         *   false,
+         *   "BTCUSDT",
+         *   50,
+         *   102,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.trailingProfit = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService trailingProfit", {
+                symbol,
+                context,
+                percentShift,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.trailingProfit(symbol, percentShift, currentPrice, backtest);
+        };
         /**
          * Delegates to ClientStrategy.breakeven() with current execution context.
          *
@@ -6256,16 +6560,19 @@ const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
  *
  * - Falls back to currentPrice if priceOpen is not set (for ISignalDto/scheduled signals)
  * - Replaces priceStopLoss with trailing SL if active (for positions with trailing stops)
+ * - Replaces priceTakeProfit with trailing TP if active (for positions with trailing take-profit)
  * - Preserves original stop-loss in originalPriceStopLoss for reference
+ * - Preserves original take-profit in originalPriceTakeProfit for reference
  *
  * Use cases:
  * - Risk validation before opening a position (checkSignal)
  * - Pre-flight validation of scheduled signals
  * - Calculating position size based on stop-loss distance
+ * - Calculating risk-reward ratio using effective SL/TP
  *
  * @param signal - Signal DTO or row (may not have priceOpen for scheduled signals)
  * @param currentPrice - Current market price, used as fallback for priceOpen if not set
- * @returns Signal in IRiskSignalRow format with guaranteed priceOpen and effective stop-loss
+ * @returns Signal in IRiskSignalRow format with guaranteed priceOpen and effective SL/TP
  *
  * @example
  * ```typescript
@@ -6273,24 +6580,24 @@ const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
  * const riskSignal = TO_RISK_SIGNAL(scheduledSignal, 45000);
  * // riskSignal.priceOpen = 45000 (fallback to currentPrice)
  *
- * // For signal with trailing SL
+ * // For signal with trailing SL/TP
  * const riskSignal = TO_RISK_SIGNAL(activeSignal, 46000);
- * // riskSignal.priceStopLoss = activeSignal._trailingPriceStopLoss
+ * // riskSignal.priceStopLoss = activeSignal._trailingPriceStopLoss (effective)
+ * // riskSignal.priceTakeProfit = activeSignal._trailingPriceTakeProfit (effective)
+ * // riskSignal.originalPriceStopLoss = activeSignal.priceStopLoss (original)
+ * // riskSignal.originalPriceTakeProfit = activeSignal.priceTakeProfit (original)
  * ```
  */
 const TO_RISK_SIGNAL = (signal, currentPrice) => {
-    if ("_trailingPriceStopLoss" in signal) {
-        return {
-            ...structuredClone(signal),
-            priceOpen: signal.priceOpen ?? currentPrice,
-            priceStopLoss: signal._trailingPriceStopLoss,
-            originalPriceStopLoss: signal.priceStopLoss,
-        };
-    }
+    const hasTrailingSL = "_trailingPriceStopLoss" in signal && signal._trailingPriceStopLoss !== undefined;
+    const hasTrailingTP = "_trailingPriceTakeProfit" in signal && signal._trailingPriceTakeProfit !== undefined;
     return {
         ...structuredClone(signal),
         priceOpen: signal.priceOpen ?? currentPrice,
+        priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
+        priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
+        originalPriceTakeProfit: signal.priceTakeProfit,
     };
 };
 /** Key generator for active position map */
@@ -7223,6 +7530,41 @@ class StrategyCoreService {
             await this.validate(symbol, context);
             return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, currentPrice, context);
         };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         * Validates context and delegates to StrategyConnectionService.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await strategyCoreService.trailingProfit(
+         *   false,
+         *   "BTCUSDT",
+         *   50,
+         *   102,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.trailingProfit = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService trailingProfit", {
+                symbol,
+                percentShift,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.trailingProfit(backtest, symbol, percentShift, currentPrice, context);
+        };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
          * Validates context and delegates to StrategyConnectionService.
@@ -17926,6 +18268,7 @@ const CANCEL_METHOD_NAME = "strategy.cancel";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.partialProfit";
 const PARTIAL_LOSS_METHOD_NAME = "strategy.partialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.trailingStop";
+const TRAILING_PROFIT_METHOD_NAME = "strategy.trailingProfit";
 const BREAKEVEN_METHOD_NAME = "strategy.breakeven";
 /**
  * Stops the strategy from generating new signals.
@@ -18121,6 +18464,45 @@ async function trailingStop(symbol, percentShift, currentPrice) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
 }
+/**
+ * Adjusts the trailing take-profit distance for an active pending signal.
+ *
+ * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+ * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+ * Once direction is set on first call, subsequent calls must continue in same direction.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+ * @param currentPrice - Current market price to check for intrusion
+ * @returns Promise that resolves when trailing TP is updated
+ *
+ * @example
+ * ```typescript
+ * import { trailingProfit } from "backtest-kit";
+ *
+ * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+ * // Move TP further by 50%: newTP = 100 + 15% = 115
+ * await trailingProfit("BTCUSDT", 50, 102);
+ * ```
+ */
+async function trailingProfit(symbol, percentShift, currentPrice) {
+    bt.loggerService.info(TRAILING_PROFIT_METHOD_NAME, {
+        symbol,
+        percentShift,
+        currentPrice,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("trailingProfit requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("trailingProfit requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.trailingProfit(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
+}
 /**
  * Moves stop-loss to breakeven when price reaches threshold.
  *
@@ -20066,6 +20448,7 @@ const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.cancel";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.partialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.partialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.trailingStop";
+const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.trailingProfit";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -20722,6 +21105,48 @@ class BacktestUtils {
             }
             await bt.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
         };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+         * Once direction is set on first call, subsequent calls must continue in same direction.
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await Backtest.trailingProfit("BTCUSDT", 50, 102, {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.trailingProfit = async (symbol, percentShift, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_PROFIT, {
+                symbol,
+                percentShift,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_TRAILING_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_TRAILING_PROFIT);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_PROFIT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_PROFIT));
+            }
+            await bt.strategyCoreService.trailingProfit(true, symbol, percentShift, currentPrice, context);
+        };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
          *
@@ -20926,6 +21351,7 @@ const LIVE_METHOD_NAME_CANCEL = "LiveUtils.cancel";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.partialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.partialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.trailingStop";
+const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.trailingProfit";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -21560,6 +21986,49 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Adjusts the trailing take-profit distance for an active pending signal.
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
+         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
+         * Once direction is set on first call, subsequent calls must continue in same direction.
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise that resolves when trailing TP is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
+         * // Move TP further by 50%: newTP = 100 + 15% = 115
+         * await Live.trailingProfit("BTCUSDT", 50, 102, {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.trailingProfit = async (symbol, percentShift, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_TRAILING_PROFIT, {
+                symbol,
+                percentShift,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_TRAILING_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_PROFIT);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT));
+            }
+            await bt.strategyCoreService.trailingProfit(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
          *
@@ -24500,5 +24969,6 @@ exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.stop = stop;
+exports.trailingProfit = trailingProfit;
 exports.trailingStop = trailingStop;
 exports.validate = validate;