backtest-kit 1.10.1 → 1.10.2

package/build/index.cjs

@@ -2792,6 +2792,19 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
                 const thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice >= thresholdPrice;
                 if (isThresholdReached && breakevenPrice > trailingStopLoss) {
+                    // Check for price intrusion before setting new SL
+                    if (currentPrice < breakevenPrice) {
+                        // Price already crossed the breakeven level - skip setting SL
+                        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+                            signalId: signal.id,
+                            position: signal.position,
+                            priceOpen: signal.priceOpen,
+                            breakevenPrice,
+                            currentPrice,
+                            reason: "currentPrice below breakevenPrice (LONG position)"
+                        });
+                        return false;
+                    }
                     // Breakeven is better than current trailing SL - upgrade to breakeven
                     signal._trailingPriceStopLoss = breakevenPrice;
                     self.params.logger.info("BREAKEVEN_FN: upgraded negative trailing stop to breakeven", {
@@ -2844,6 +2857,19 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
                 const thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice <= thresholdPrice;
                 if (isThresholdReached && breakevenPrice < trailingStopLoss) {
+                    // Check for price intrusion before setting new SL
+                    if (currentPrice > breakevenPrice) {
+                        // Price already crossed the breakeven level - skip setting SL
+                        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+                            signalId: signal.id,
+                            position: signal.position,
+                            priceOpen: signal.priceOpen,
+                            breakevenPrice,
+                            currentPrice,
+                            reason: "currentPrice above breakevenPrice (SHORT position)"
+                        });
+                        return false;
+                    }
                     // Breakeven is better than current trailing SL - upgrade to breakeven
                     signal._trailingPriceStopLoss = breakevenPrice;
                     self.params.logger.info("BREAKEVEN_FN: upgraded negative trailing stop to breakeven", {
@@ -2914,6 +2940,31 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
         });
         return false;
     }
+    // Check for price intrusion before setting new SL
+    if (signal.position === "long" && currentPrice < breakevenPrice) {
+        // LONG: Price already crossed the breakeven level - skip setting SL
+        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            breakevenPrice,
+            currentPrice,
+            reason: "currentPrice below breakevenPrice (LONG position)"
+        });
+        return false;
+    }
+    if (signal.position === "short" && currentPrice > breakevenPrice) {
+        // SHORT: Price already crossed the breakeven level - skip setting SL
+        self.params.logger.debug("BREAKEVEN_FN: price intrusion detected, skipping SL update", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            breakevenPrice,
+            currentPrice,
+            reason: "currentPrice above breakevenPrice (SHORT position)"
+        });
+        return false;
+    }
     // Move SL to breakeven (entry price)
     signal._trailingPriceStopLoss = breakevenPrice;
     self.params.logger.info("BREAKEVEN_FN executed", {
@@ -4075,6 +4126,112 @@ class ClientStrategy {
         });
         return this._scheduledSignal ? TO_PUBLIC_SIGNAL(this._scheduledSignal) : null;
     }
+    /**
+     * Checks if breakeven threshold has been reached for the current pending signal.
+     *
+     * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+     * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+     * Threshold: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2 transactions
+     *
+     * For LONG position:
+     * - Returns true when: currentPrice >= priceOpen * (1 + threshold%)
+     * - Example: entry=100, threshold=0.4% → true when price >= 100.4
+     *
+     * For SHORT position:
+     * - Returns true when: currentPrice <= priceOpen * (1 - threshold%)
+     * - Example: entry=100, threshold=0.4% → true when price <= 99.6
+     *
+     * Special cases:
+     * - Returns false if no pending signal exists
+     * - Returns true if trailing stop is already in profit zone (breakeven already achieved)
+     * - Returns false if threshold not reached yet
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - Current market price to check against threshold
+     * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+     * const canBreakeven = await strategy.getBreakeven("BTCUSDT", 100.5);
+     * // Returns true (price >= 100.4)
+     *
+     * if (canBreakeven) {
+     *   await strategy.breakeven("BTCUSDT", 100.5, false);
+     * }
+     * ```
+     */
+    async getBreakeven(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getBreakeven", {
+            symbol,
+            currentPrice,
+        });
+        // No pending signal - breakeven not available
+        if (!this._pendingSignal) {
+            return false;
+        }
+        const signal = this._pendingSignal;
+        // Calculate breakeven threshold based on slippage and fees
+        // Need to cover: entry slippage + entry fee + exit slippage + exit fee
+        // Total: (slippage + fee) * 2 transactions
+        const breakevenThresholdPercent = (GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE + GLOBAL_CONFIG.CC_PERCENT_FEE) * 2 + GLOBAL_CONFIG.CC_BREAKEVEN_THRESHOLD;
+        // Check if trailing stop is already set
+        if (signal._trailingPriceStopLoss !== undefined) {
+            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;
+                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 isThresholdReached = currentPrice >= thresholdPrice;
+                const breakevenPrice = signal.priceOpen;
+                // 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;
+                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 isThresholdReached = currentPrice <= thresholdPrice;
+                const breakevenPrice = signal.priceOpen;
+                // 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;
+        // 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);
+            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);
+            isThresholdReached = currentPrice <= thresholdPrice;
+            // Can move to breakeven only if threshold reached and SL is above entry
+            canMoveToBreakeven = isThresholdReached && currentStopLoss > breakevenPrice;
+        }
+        return canMoveToBreakeven;
+    }
     /**
      * Returns the stopped state of the strategy.
      *
@@ -4738,30 +4895,38 @@ class ClientStrategy {
      * - Throws if percentShift is not a finite number
      * - Throws if percentShift < -100 or > 100
      * - Throws if percentShift === 0
+     * - Throws if currentPrice is not a positive finite number
      * - Skips if new SL would cross entry price
+     * - Skips if currentPrice already crossed new SL level (price intrusion protection)
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
      * @param percentShift - Percentage shift of SL distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to check for intrusion
      * @param backtest - Whether running in backtest mode (controls persistence)
      * @returns Promise that resolves when trailing SL is updated and persisted
      *
      * @example
      * ```typescript
-     * // LONG position: entry=100, originalSL=90, distance=10
+     * // LONG position: entry=100, originalSL=90, distance=10%, currentPrice=102
+     *
+     * // Move SL 50% closer to entry (tighten): reduces distance by 50%
+     * await strategy.trailingStop("BTCUSDT", -50, 102, false);
+     * // newDistance = 10% - 50% = 5%, newSL = 100 * (1 - 0.05) = 95
      *
-     * // Move SL 50% closer to entry (tighten)
-     * await strategy.trailingStop("BTCUSDT", -50, false);
-     * // newSL = 100 - 10*(1-0.5) = 95
+     * // Move SL 30% away from entry (loosen): increases distance by 30%
+     * await strategy.trailingStop("BTCUSDT", 30, 102, false);
+     * // newDistance = 10% + 30% = 40%, newSL = 100 * (1 - 0.4) = 60
      *
-     * // Move SL 30% away from entry (loosen, allow more drawdown)
-     * await strategy.trailingStop("BTCUSDT", 30, false);
-     * // newSL = 100 - 10*(1+0.3) = 87 (SKIPPED: worse than current 95)
+     * // Price intrusion example: currentPrice=92, trying to set SL=95
+     * await strategy.trailingStop("BTCUSDT", -50, 92, false);
+     * // SKIPPED: currentPrice (92) < newSL (95) - would trigger immediate stop
      * ```
      */
-    async trailingStop(symbol, percentShift, backtest) {
+    async trailingStop(symbol, percentShift, currentPrice, backtest) {
         this.params.logger.debug("ClientStrategy trailingStop", {
             symbol,
             percentShift,
+            currentPrice,
             hasPendingSignal: this._pendingSignal !== null,
         });
         // Validation: must have pending signal
@@ -4778,6 +4943,46 @@ class ClientStrategy {
         if (percentShift === 0) {
             throw new Error(`ClientStrategy trailingStop: percentShift cannot be 0`);
         }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy trailingStop: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Calculate what the new stop loss would be
+        const signal = this._pendingSignal;
+        const slDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+        const newSlDistancePercent = slDistancePercent + percentShift;
+        let newStopLoss;
+        if (signal.position === "long") {
+            newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
+        }
+        else {
+            newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
+        }
+        // Check for price intrusion before executing trailing logic
+        if (signal.position === "long" && currentPrice < newStopLoss) {
+            // LONG: Price already crossed the new stop loss level - skip setting SL
+            this.params.logger.debug("ClientStrategy trailingStop: price intrusion detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                currentPrice,
+                reason: "currentPrice below newStopLoss (LONG position)"
+            });
+            return;
+        }
+        if (signal.position === "short" && currentPrice > newStopLoss) {
+            // SHORT: Price already crossed the new stop loss level - skip setting SL
+            this.params.logger.debug("ClientStrategy trailingStop: price intrusion detected, skipping SL update", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                newStopLoss,
+                currentPrice,
+                reason: "currentPrice above newStopLoss (SHORT position)"
+            });
+            return;
+        }
         // Execute trailing logic
         TRAILING_STOP_FN(this, this._pendingSignal, percentShift);
         // Persist updated signal state (inline setPendingSignal content)
@@ -4963,6 +5168,7 @@ class RiskUtils {
                 strategyName: context.strategyName,
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5019,6 +5225,7 @@ class RiskUtils {
                 strategyName: context.strategyName,
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5067,6 +5274,7 @@ class RiskUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5277,6 +5485,46 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getScheduledSignal(symbol);
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+         * to cover transaction costs and allow breakeven to be set.
+         *
+         * Delegates to ClientStrategy.getBreakeven() with current execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+         * const canBreakeven = await strategyConnectionService.getBreakeven(
+         *   false,
+         *   "BTCUSDT",
+         *   100.5,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * // Returns true (price >= 100.4)
+         *
+         * if (canBreakeven) {
+         *   await strategyConnectionService.breakeven(false, "BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService getBreakeven", {
+                symbol,
+                context,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getBreakeven(symbol, currentPrice);
+        };
         /**
          * Retrieves the stopped state of the strategy.
          *
@@ -5511,30 +5759,33 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL 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 SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
          * await strategyConnectionService.trailingStop(
          *   false,
          *   "BTCUSDT",
          *   -50,
+         *   102,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
          * );
          * ```
          */
-        this.trailingStop = async (backtest, symbol, percentShift, context) => {
+        this.trailingStop = async (backtest, symbol, percentShift, currentPrice, context) => {
             this.loggerService.log("strategyConnectionService trailingStop", {
                 symbol,
                 context,
                 percentShift,
+                currentPrice,
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.trailingStop(symbol, percentShift, backtest);
+            await strategy.trailingStop(symbol, percentShift, currentPrice, backtest);
         };
         /**
          * Delegates to ClientStrategy.breakeven() with current execution context.
@@ -6675,6 +6926,46 @@ class StrategyCoreService {
             await this.validate(symbol, context);
             return await this.strategyConnectionService.getScheduledSignal(backtest, symbol, context);
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to check if price has moved far enough to cover transaction costs.
+         *
+         * Does not require execution context as this is a state query operation.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * // Check if breakeven is available for LONG position (entry=100, threshold=0.4%)
+         * const canBreakeven = await strategyCoreService.getBreakeven(
+         *   false,
+         *   "BTCUSDT",
+         *   100.5,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * // Returns true (price >= 100.4)
+         *
+         * if (canBreakeven) {
+         *   await strategyCoreService.breakeven(false, "BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService getBreakeven", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.getBreakeven(backtest, symbol, currentPrice, context);
+        };
         /**
          * Checks if the strategy has been stopped.
          *
@@ -6904,30 +7195,33 @@ class StrategyCoreService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL 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 SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
          * await strategyCoreService.trailingStop(
          *   false,
          *   "BTCUSDT",
          *   -50,
+         *   102,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
          * );
          * ```
          */
-        this.trailingStop = async (backtest, symbol, percentShift, context) => {
+        this.trailingStop = async (backtest, symbol, percentShift, currentPrice, context) => {
             this.loggerService.log("strategyCoreService trailingStop", {
                 symbol,
                 percentShift,
+                currentPrice,
                 context,
                 backtest,
             });
             await this.validate(symbol, context);
-            return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, context);
+            return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, currentPrice, context);
         };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
@@ -7036,6 +7330,7 @@ class RiskGlobalService {
         this.loggerService = inject(TYPES.loggerService);
         this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.riskValidationService = inject(TYPES.riskValidationService);
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         /**
          * Validates risk configuration.
          * Memoized to avoid redundant validations for the same risk-exchange-frame combination.
@@ -7048,6 +7343,7 @@ class RiskGlobalService {
                 payload,
             });
             this.riskValidationService.validate(payload.riskName, "riskGlobalService validate");
+            this.exchangeValidationService.validate(payload.exchangeName, "riskGlobalService validate");
         });
         /**
          * Checks if a signal should be allowed based on risk limits.
@@ -15320,6 +15616,10 @@ class PartialGlobalService {
          * Risk validation service for validating risk existence.
          */
         this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * Exchange validation service for validating exchange existence.
+         */
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -15333,6 +15633,7 @@ class PartialGlobalService {
                 methodName,
             });
             this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
             const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
@@ -16294,6 +16595,10 @@ class BreakevenGlobalService {
          * Risk validation service for validating risk existence.
          */
         this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * Exchange validation service for validating exchange existence.
+         */
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -16307,6 +16612,7 @@ class BreakevenGlobalService {
                 methodName,
             });
             this.strategyValidationService.validate(context.strategyName, methodName);
+            this.exchangeValidationService.validate(context.exchangeName, methodName);
             const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
@@ -17787,21 +18093,23 @@ async function partialLoss(symbol, percentToClose) {
  *
  * @param symbol - Trading pair symbol
  * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+ * @param currentPrice - Current market price to check for intrusion
  * @returns Promise that resolves when trailing SL is updated
  *
  * @example
  * ```typescript
  * import { trailingStop } from "backtest-kit";
  *
- * // LONG: entry=100, originalSL=90, distance=10
- * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
- * await trailingStop("BTCUSDT", -50);
+ * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+ * // Tighten stop by 50%: newSL = 100 - 5% = 95
+ * await trailingStop("BTCUSDT", -50, 102);
  * ```
  */
-async function trailingStop(symbol, percentShift) {
+async function trailingStop(symbol, percentShift, currentPrice) {
     bt.loggerService.info(TRAILING_STOP_METHOD_NAME, {
         symbol,
         percentShift,
+        currentPrice,
     });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("trailingStop requires an execution context");
@@ -17811,7 +18119,7 @@ async function trailingStop(symbol, percentShift) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, { exchangeName, frameName, strategyName });
+    await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
  * Moves stop-loss to breakeven when price reaches threshold.
@@ -19753,6 +20061,7 @@ const BACKTEST_METHOD_NAME_TASK = "BacktestUtils.task";
 const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
 const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal";
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
+const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
 const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.cancel";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.partialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.partialLoss";
@@ -20123,6 +20432,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20154,6 +20464,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20163,6 +20474,47 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getScheduledSignal(true, symbol, context);
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+         * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * const canBreakeven = await Backtest.getBreakeven("BTCUSDT", 100.5, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "backtest_frame"
+         * });
+         * if (canBreakeven) {
+         *   console.log("Breakeven threshold reached");
+         *   await Backtest.breakeven("BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_BREAKEVEN, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_BREAKEVEN);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_BREAKEVEN);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_BREAKEVEN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_BREAKEVEN));
+            }
+            return await bt.strategyCoreService.getBreakeven(true, symbol, currentPrice, context);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -20191,6 +20543,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20230,6 +20583,7 @@ class BacktestUtils {
                 cancelId,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20273,6 +20627,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20316,6 +20671,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_LOSS);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_PARTIAL_LOSS);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20333,27 +20689,30 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL 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 SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
-         * await Backtest.trailingStop("BTCUSDT", -50, {
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
+         * await Backtest.trailingStop("BTCUSDT", -50, 102, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
          * });
          * ```
          */
-        this.trailingStop = async (symbol, percentShift, context) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_STOP, {
                 symbol,
                 percentShift,
+                currentPrice,
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_TRAILING_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_TRAILING_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20361,7 +20720,7 @@ class BacktestUtils {
                 riskList &&
                     riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_STOP));
             }
-            await bt.strategyCoreService.trailingStop(true, symbol, percentShift, context);
+            await bt.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
         };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
@@ -20391,6 +20750,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, "Backtest.breakeven");
+            bt.exchangeValidationService.validate(context.exchangeName, "Backtest.breakeven");
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20424,6 +20784,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20458,6 +20819,7 @@ class BacktestUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20500,6 +20862,7 @@ class BacktestUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -20558,6 +20921,7 @@ const LIVE_METHOD_NAME_TASK = "LiveUtils.task";
 const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
 const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
+const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
 const LIVE_METHOD_NAME_CANCEL = "LiveUtils.cancel";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.partialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.partialLoss";
@@ -20899,6 +21263,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
@@ -20932,6 +21297,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
@@ -20943,6 +21309,48 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Checks if breakeven threshold has been reached for the current pending signal.
+         *
+         * Uses the same formula as BREAKEVEN_FN to determine if price has moved far enough
+         * to cover transaction costs (slippage + fees) and allow breakeven to be set.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to check against threshold
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+         *
+         * @example
+         * ```typescript
+         * const canBreakeven = await Live.getBreakeven("BTCUSDT", 100.5, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance"
+         * });
+         * if (canBreakeven) {
+         *   console.log("Breakeven threshold reached");
+         *   await Live.breakeven("BTCUSDT", 100.5, context);
+         * }
+         * ```
+         */
+        this.getBreakeven = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_BREAKEVEN, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_BREAKEVEN);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_BREAKEVEN);
+            {
+                const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN));
+            }
+            return await bt.strategyCoreService.getBreakeven(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -20966,6 +21374,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
@@ -21007,6 +21416,7 @@ class LiveUtils {
                 cancelId,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL);
@@ -21051,6 +21461,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
@@ -21095,6 +21506,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_LOSS);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_LOSS);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS);
@@ -21114,32 +21526,35 @@ class LiveUtils {
          *
          * @param symbol - Trading pair symbol
          * @param percentShift - Percentage adjustment to SL 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 SL is updated
          *
          * @example
          * ```typescript
-         * // LONG: entry=100, originalSL=90, distance=10
-         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
-         * await Live.trailingStop("BTCUSDT", -50, {
+         * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
+         * // Tighten stop by 50%: newSL = 100 - 5% = 95
+         * await Live.trailingStop("BTCUSDT", -50, 102, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
          * ```
          */
-        this.trailingStop = async (symbol, percentShift, context) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
             bt.loggerService.info(LIVE_METHOD_NAME_TRAILING_STOP, {
                 symbol,
                 percentShift,
+                currentPrice,
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_TRAILING_STOP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_STOP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP);
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP));
             }
-            await bt.strategyCoreService.trailingStop(false, symbol, percentShift, {
+            await bt.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -21173,6 +21588,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, "Live.breakeven");
+            bt.exchangeValidationService.validate(context.exchangeName, "Live.breakeven");
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, "Live.breakeven");
@@ -21208,6 +21624,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
@@ -21240,6 +21657,7 @@ class LiveUtils {
                 context,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
@@ -21280,6 +21698,7 @@ class LiveUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
@@ -21373,6 +21792,7 @@ class ScheduleUtils {
                 backtest,
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
@@ -21401,6 +21821,7 @@ class ScheduleUtils {
                 backtest,
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
@@ -21433,6 +21854,7 @@ class ScheduleUtils {
                 path,
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
@@ -21521,6 +21943,7 @@ class Performance {
      */
     static async getData(symbol, context, backtest = false) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
+        bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_GET_DATA);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
@@ -21553,6 +21976,7 @@ class Performance {
      */
     static async getReport(symbol, context, backtest = false, columns) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+        bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
@@ -21582,6 +22006,7 @@ class Performance {
      */
     static async dump(symbol, context, backtest = false, path = "./dump/performance", columns) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_DUMP);
+        bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_DUMP);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
@@ -22172,6 +22597,7 @@ class HeatUtils {
         this.getData = async (context, backtest = false) => {
             bt.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
@@ -22213,6 +22639,7 @@ class HeatUtils {
         this.getReport = async (context, backtest = false, columns) => {
             bt.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
@@ -22251,6 +22678,7 @@ class HeatUtils {
         this.dump = async (context, backtest = false, path, columns) => {
             bt.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
@@ -22583,6 +23011,7 @@ class PartialUtils {
         this.getData = async (symbol, context, backtest = false) => {
             bt.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
@@ -22632,6 +23061,7 @@ class PartialUtils {
         this.getReport = async (symbol, context, backtest = false, columns) => {
             bt.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
@@ -22674,6 +23104,7 @@ class PartialUtils {
         this.dump = async (symbol, context, backtest = false, path, columns) => {
             bt.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
@@ -23863,6 +24294,7 @@ class BreakevenUtils {
         this.getData = async (symbol, context, backtest = false) => {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_GET_DATA);
@@ -23908,6 +24340,7 @@ class BreakevenUtils {
         this.getReport = async (symbol, context, backtest = false, columns) => {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_GET_REPORT);
@@ -23950,6 +24383,7 @@ class BreakevenUtils {
         this.dump = async (symbol, context, backtest = false, path, columns) => {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_DUMP);