backtest-kit 7.7.0 → 8.0.0

package/build/index.mjs

@@ -3845,6 +3845,27 @@ class ClientExchange {
         const vwap = sumPriceVolume / totalVolume;
         return vwap;
     }
+    /**
+     * Returns the close price of the last completed candle for the given interval.
+     *
+     * Fetches a single candle for the requested interval and returns its close price.
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle time interval (e.g., "1m", "1h")
+     * @returns Promise resolving to close price of the last candle
+     * @throws Error if no candles available
+     */
+    async getClosePrice(symbol, interval) {
+        this.params.logger.debug(`ClientExchange getClosePrice`, {
+            symbol,
+            interval,
+        });
+        const candles = await this.getCandles(symbol, interval, 1);
+        if (candles.length === 0) {
+            throw new Error(`ClientExchange getClosePrice: no candles data for symbol=${symbol}`);
+        }
+        return candles[candles.length - 1].close;
+    }
     /**
      * Formats quantity according to exchange-specific rules for the given symbol.
      * Applies proper decimal precision and rounding based on symbol's lot size filters.
@@ -4250,6 +4271,22 @@ class ExchangeConnectionService {
             });
             return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
         };
+        /**
+         * Returns the close price of the last completed candle for the given interval.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1h", "1d")
+         * @returns Promise resolving to close price of the last candle
+         */
+        this.getClosePrice = async (symbol, interval) => {
+            this.loggerService.log("exchangeConnectionService getClosePrice", {
+                symbol,
+                interval,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getClosePrice(symbol, interval);
+        };
         /**
          * Formats price according to exchange-specific precision rules.
          *
@@ -5488,6 +5525,10 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
                 _peak: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0, priceClose: 0, priceOpen: 0, pnlEntries: 0 },
                 _fall: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0, priceClose: 0, priceOpen: 0, pnlEntries: 0 },
             };
+            {
+                const { pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen } = toProfitLossDto(signalRow, signal.priceOpen);
+                signalRow._fall = { price: signal.priceOpen, timestamp: currentTime, pnlPercentage, pnlCost, priceClose, priceOpen, pnlEntries };
+            }
             // Валидируем сигнал перед возвратом
             validatePendingSignal(signalRow, currentPrice);
             return signalRow;
@@ -5537,6 +5578,10 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         _peak: { price: currentPrice, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0, priceClose: 0, priceOpen: 0, pnlEntries: 0 },
         _fall: { price: currentPrice, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0, priceClose: 0, priceOpen: 0, pnlEntries: 0 },
     };
+    {
+        const { pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen } = toProfitLossDto(signalRow, currentPrice);
+        signalRow._fall = { price: currentPrice, timestamp: currentTime, pnlPercentage, pnlCost, priceClose, priceOpen, pnlEntries };
+    }
     // Валидируем сигнал перед возвратом
     validatePendingSignal(signalRow, currentPrice);
     return signalRow;
@@ -6249,6 +6294,10 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         _peak: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0, pnlEntries: 0, priceClose: 0, priceOpen: 0 },
         _fall: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0, pnlEntries: 0, priceClose: 0, priceOpen: 0 },
     };
+    {
+        const { pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen } = toProfitLossDto(activatedSignal, activatedSignal.priceOpen);
+        activatedSignal._fall = { price: activatedSignal.priceOpen, timestamp: activationTime, pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen };
+    }
     // Sync open: if external system rejects — cancel scheduled signal instead of opening
     const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(activationTime, activatedSignal.priceOpen, activatedSignal, self);
     if (!syncOpenAllowed) {
@@ -7132,6 +7181,10 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         _peak: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0, pnlEntries: 0, priceClose: 0, priceOpen: 0 },
         _fall: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0, pnlEntries: 0, priceClose: 0, priceOpen: 0 },
     };
+    {
+        const { pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen } = toProfitLossDto(activatedSignal, activatedSignal.priceOpen);
+        activatedSignal._fall = { price: activatedSignal.priceOpen, timestamp: activationTime, pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen };
+    }
     // Sync open: if external system rejects — cancel scheduled signal instead of opening
     const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(activationTime, activatedSignal.priceOpen, activatedSignal, self);
     if (!syncOpenAllowed) {
@@ -7329,6 +7382,10 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                 _peak: { price: activatedSignal.priceOpen, timestamp: candle.timestamp, pnlPercentage: 0, pnlCost: 0, priceClose: 0, priceOpen: 0, pnlEntries: 0 },
                 _fall: { price: activatedSignal.priceOpen, timestamp: candle.timestamp, pnlPercentage: 0, pnlCost: 0, priceClose: 0, priceOpen: 0, pnlEntries: 0 },
             };
+            {
+                const { pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen } = toProfitLossDto(pendingSignal, pendingSignal.priceOpen);
+                pendingSignal._fall = { price: pendingSignal.priceOpen, timestamp: candle.timestamp, pnlPercentage, pnlCost, priceClose, priceOpen, pnlEntries };
+            }
             // Sync open: if external system rejects — cancel scheduled signal instead of opening
             const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(candle.timestamp, pendingSignal.priceOpen, pendingSignal, self);
             if (!syncOpenAllowed) {
@@ -8773,6 +8830,10 @@ class ClientStrategy {
                 _peak: { price: activatedSignal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0, priceClose: 0, pnlEntries: 0, priceOpen: 0 },
                 _fall: { price: activatedSignal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0, priceClose: 0, pnlEntries: 0, priceOpen: 0 },
             };
+            {
+                const { pnlPercentage, pnlCost, pnlEntries, priceClose, priceOpen } = toProfitLossDto(pendingSignal, pendingSignal.priceOpen);
+                pendingSignal._fall = { price: pendingSignal.priceOpen, timestamp: currentTime, pnlPercentage, pnlCost, priceClose, pnlEntries, priceOpen };
+            }
             const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(currentTime, currentPrice, pendingSignal, this);
             if (!syncOpenAllowed) {
                 this.params.logger.info("ClientStrategy tick: user-activated signal rejected by sync", {
@@ -14840,6 +14901,34 @@ class ExchangeCoreService {
                 backtest,
             });
         };
+        /**
+         * Returns the close price of the last completed candle for the given interval with execution context.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param when - Timestamp for context (used in backtest mode)
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to close price of the last candle
+         */
+        this.getClosePrice = async (symbol, interval, when, backtest) => {
+            this.loggerService.log("exchangeCoreService getClosePrice", {
+                symbol,
+                interval,
+                when,
+                backtest,
+            });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService getClosePrice requires a method context");
+            }
+            await this.validate(this.methodContextService.context.exchangeName);
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getClosePrice(symbol, interval);
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
         /**
          * Formats price with execution context.
          *
@@ -19308,6 +19397,24 @@ const heat_columns = [
         format: (data) => data.avgFallPnl !== null ? str(data.avgFallPnl, "%") : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "sortinoRatio",
+        label: "Sortino",
+        format: (data) => data.sortinoRatio !== null ? str(data.sortinoRatio) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "calmarRatio",
+        label: "Calmar",
+        format: (data) => data.calmarRatio !== null ? str(data.calmarRatio) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "recoveryFactor",
+        label: "Recovery",
+        format: (data) => data.recoveryFactor !== null ? str(data.recoveryFactor) : "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -20870,6 +20977,30 @@ const walker_strategy_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "sortinoRatio",
+        label: "Sortino",
+        format: (data) => data.stats.sortinoRatio !== null
+            ? `${data.stats.sortinoRatio.toFixed(3)}`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "calmarRatio",
+        label: "Calmar",
+        format: (data) => data.stats.calmarRatio !== null
+            ? `${data.stats.calmarRatio.toFixed(3)}`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "recoveryFactor",
+        label: "Recovery",
+        format: (data) => data.stats.recoveryFactor !== null
+            ? `${data.stats.recoveryFactor.toFixed(3)}`
+            : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "firstEventTime",
         label: "First Event",
@@ -21419,13 +21550,13 @@ class ReportBase {
          * Waits for drain event if write buffer is full.
          * Times out after 15 seconds and returns TIMEOUT_SYMBOL.
          */
-        this[_d] = timeout(async (line) => {
+        this[_d] = queued(timeout(async (line) => {
             if (!this._stream.write(line)) {
                 await new Promise((resolve) => {
                     this._stream.once("drain", resolve);
                 });
             }
-        }, 15000);
+        }, 15000));
         LOGGER_SERVICE$3.debug(REPORT_BASE_METHOD_NAME_CTOR, {
             reportName: this.reportName,
             baseDir,
@@ -21713,6 +21844,9 @@ let ReportStorage$a = class ReportStorage {
                 expectedYearlyReturns: null,
                 avgPeakPnl: null,
                 avgFallPnl: null,
+                sortinoRatio: null,
+                calmarRatio: null,
+                recoveryFactor: null,
             };
         }
         const totalSignals = this._signalList.length;
@@ -21746,6 +21880,16 @@ let ReportStorage$a = class ReportStorage {
         // Calculate average peak and fall PNL across all signals
         const avgPeakPnl = this._signalList.reduce((sum, s) => sum + (s.signal.peakProfit?.pnlPercentage ?? 0), 0) / totalSignals;
         const avgFallPnl = this._signalList.reduce((sum, s) => sum + (s.signal.maxDrawdown?.pnlPercentage ?? 0), 0) / totalSignals;
+        // Downside per signal: maxDrawdown.pnlPercentage captures the worst intra-trade dip
+        const fallReturns = this._signalList.map((s) => s.signal.maxDrawdown?.pnlPercentage ?? 0);
+        // Calculate Sortino Ratio: avgPnl / stdDev(maxDrawdown per signal)
+        const fallVariance = fallReturns.reduce((sum, r) => sum + Math.pow(r, 2), 0) / totalSignals;
+        const fallDeviation = Math.sqrt(fallVariance);
+        const sortinoRatio = fallDeviation > 0 ? avgPnl / fallDeviation : 0;
+        // Avg absolute peak drawdown per signal — used as denominator for Calmar and Recovery
+        const avgAbsFall = fallReturns.reduce((sum, r) => sum + Math.abs(r), 0) / totalSignals;
+        const calmarRatio = avgAbsFall > 0 ? expectedYearlyReturns / avgAbsFall : 0;
+        const recoveryFactor = avgAbsFall > 0 ? totalPnl / avgAbsFall : 0;
         return {
             signalList: this._signalList,
             totalSignals,
@@ -21761,6 +21905,9 @@ let ReportStorage$a = class ReportStorage {
             expectedYearlyReturns: isUnsafe$3(expectedYearlyReturns) ? null : expectedYearlyReturns,
             avgPeakPnl: isUnsafe$3(avgPeakPnl) ? null : avgPeakPnl,
             avgFallPnl: isUnsafe$3(avgFallPnl) ? null : avgFallPnl,
+            sortinoRatio: isUnsafe$3(sortinoRatio) ? null : sortinoRatio,
+            calmarRatio: isUnsafe$3(calmarRatio) ? null : calmarRatio,
+            recoveryFactor: isUnsafe$3(recoveryFactor) ? null : recoveryFactor,
         };
     }
     /**
@@ -21807,6 +21954,9 @@ let ReportStorage$a = class ReportStorage {
             `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`,
             `**Avg Peak PNL:** ${stats.avgPeakPnl === null ? "N/A" : `${stats.avgPeakPnl > 0 ? "+" : ""}${stats.avgPeakPnl.toFixed(2)}% (higher is better)`}`,
             `**Avg Max Drawdown PNL:** ${stats.avgFallPnl === null ? "N/A" : `${stats.avgFallPnl.toFixed(2)}% (closer to 0 is better)`}`,
+            `**Sortino Ratio:** ${stats.sortinoRatio === null ? "N/A" : `${stats.sortinoRatio.toFixed(3)} (higher is better)`}`,
+            `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better)`}`,
+            `**Recovery Factor:** ${stats.recoveryFactor === null ? "N/A" : `${stats.recoveryFactor.toFixed(3)} (higher is better)`}`,
         ].join("\n");
     }
     /**
@@ -22407,6 +22557,9 @@ let ReportStorage$9 = class ReportStorage {
                 expectedYearlyReturns: null,
                 avgPeakPnl: null,
                 avgFallPnl: null,
+                sortinoRatio: null,
+                calmarRatio: null,
+                recoveryFactor: null,
             };
         }
         const closedEvents = this._eventList.filter((e) => e.action === "closed");
@@ -22456,6 +22609,21 @@ let ReportStorage$9 = class ReportStorage {
         const avgFallPnl = totalClosed > 0
             ? closedEvents.reduce((sum, e) => sum + (e.fallPnl || 0), 0) / totalClosed
             : 0;
+        // Downside per signal: fallPnl captures the worst intra-trade dip (maxDrawdown.pnlPercentage)
+        const fallReturns = closedEvents.map((e) => e.fallPnl || 0);
+        // Calculate Sortino Ratio: avgPnl / stdDev(maxDrawdown per signal)
+        let sortinoRatio = 0;
+        if (totalClosed > 0) {
+            const fallVariance = fallReturns.reduce((sum, r) => sum + Math.pow(r, 2), 0) / totalClosed;
+            const fallDeviation = Math.sqrt(fallVariance);
+            sortinoRatio = fallDeviation > 0 ? avgPnl / fallDeviation : 0;
+        }
+        // Avg absolute peak drawdown per signal — denominator for Calmar and Recovery
+        const avgAbsFall = totalClosed > 0
+            ? fallReturns.reduce((sum, r) => sum + Math.abs(r), 0) / totalClosed
+            : 0;
+        const calmarRatio = avgAbsFall > 0 ? expectedYearlyReturns / avgAbsFall : 0;
+        const recoveryFactor = avgAbsFall > 0 ? totalPnl / avgAbsFall : 0;
         return {
             eventList: this._eventList,
             totalEvents: this._eventList.length,
@@ -22472,6 +22640,9 @@ let ReportStorage$9 = class ReportStorage {
             expectedYearlyReturns: isUnsafe$2(expectedYearlyReturns) ? null : expectedYearlyReturns,
             avgPeakPnl: isUnsafe$2(avgPeakPnl) ? null : avgPeakPnl,
             avgFallPnl: isUnsafe$2(avgFallPnl) ? null : avgFallPnl,
+            sortinoRatio: isUnsafe$2(sortinoRatio) ? null : sortinoRatio,
+            calmarRatio: isUnsafe$2(calmarRatio) ? null : calmarRatio,
+            recoveryFactor: isUnsafe$2(recoveryFactor) ? null : recoveryFactor,
         };
     }
     /**
@@ -22518,6 +22689,9 @@ let ReportStorage$9 = class ReportStorage {
             `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`,
             `**Avg Peak PNL:** ${stats.avgPeakPnl === null ? "N/A" : `${stats.avgPeakPnl > 0 ? "+" : ""}${stats.avgPeakPnl.toFixed(2)}% (higher is better)`}`,
             `**Avg Max Drawdown PNL:** ${stats.avgFallPnl === null ? "N/A" : `${stats.avgFallPnl.toFixed(2)}% (closer to 0 is better)`}`,
+            `**Sortino Ratio:** ${stats.sortinoRatio === null ? "N/A" : `${stats.sortinoRatio.toFixed(3)} (higher is better)`}`,
+            `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better)`}`,
+            `**Recovery Factor:** ${stats.recoveryFactor === null ? "N/A" : `${stats.recoveryFactor.toFixed(3)} (higher is better)`}`,
         ].join("\n");
     }
     /**
@@ -23963,6 +24137,9 @@ let ReportStorage$7 = class ReportStorage {
             "",
             `**Best ${results.metric}:** ${formatMetric(results.bestMetric)}`,
             `**Total Signals:** ${bestStrategySignals}`,
+            `**Sortino Ratio:** ${results.bestStats?.sortinoRatio != null ? `${results.bestStats.sortinoRatio.toFixed(3)} (higher is better)` : "N/A"}`,
+            `**Calmar Ratio:** ${results.bestStats?.calmarRatio != null ? `${results.bestStats.calmarRatio.toFixed(3)} (higher is better)` : "N/A"}`,
+            `**Recovery Factor:** ${results.bestStats?.recoveryFactor != null ? `${results.bestStats.recoveryFactor.toFixed(3)} (higher is better)` : "N/A"}`,
             "",
             "## Top Strategies Comparison",
             "",
@@ -24429,6 +24606,27 @@ class HeatmapStorage {
             avgPeakPnl = signals.reduce((acc, s) => acc + (s.signal.peakProfit?.pnlPercentage ?? 0), 0) / signals.length;
             avgFallPnl = signals.reduce((acc, s) => acc + (s.signal.maxDrawdown?.pnlPercentage ?? 0), 0) / signals.length;
         }
+        // Downside per signal: maxDrawdown.pnlPercentage captures the worst intra-trade dip
+        const fallReturns = signals.map((s) => s.signal.maxDrawdown?.pnlPercentage ?? 0);
+        // Calculate Sortino Ratio: avgPnl / stdDev(maxDrawdown per signal)
+        let sortinoRatio = null;
+        if (signals.length > 0 && avgPnl !== null) {
+            const fallVariance = fallReturns.reduce((acc, r) => acc + Math.pow(r, 2), 0) / signals.length;
+            const fallDeviation = Math.sqrt(fallVariance);
+            if (fallDeviation > 0) {
+                sortinoRatio = avgPnl / fallDeviation;
+            }
+        }
+        // Avg absolute peak drawdown per signal — denominator for Calmar and Recovery
+        const avgAbsFall = signals.length > 0
+            ? fallReturns.reduce((acc, r) => acc + Math.abs(r), 0) / signals.length
+            : 0;
+        let calmarRatio = null;
+        let recoveryFactor = null;
+        if (avgAbsFall > 0 && totalPnl !== null) {
+            calmarRatio = totalPnl / avgAbsFall;
+            recoveryFactor = totalPnl / avgAbsFall;
+        }
         // Apply safe math checks
         if (isUnsafe(winRate))
             winRate = null;
@@ -24454,6 +24652,12 @@ class HeatmapStorage {
             avgPeakPnl = null;
         if (isUnsafe(avgFallPnl))
             avgFallPnl = null;
+        if (isUnsafe(sortinoRatio))
+            sortinoRatio = null;
+        if (isUnsafe(calmarRatio))
+            calmarRatio = null;
+        if (isUnsafe(recoveryFactor))
+            recoveryFactor = null;
         return {
             symbol,
             totalPnl,
@@ -24473,6 +24677,9 @@ class HeatmapStorage {
             expectancy,
             avgPeakPnl,
             avgFallPnl,
+            sortinoRatio,
+            calmarRatio,
+            recoveryFactor,
         };
     }
     /**
@@ -29339,6 +29546,9 @@ class WalkerReportService {
                 annualizedSharpeRatio: data.stats.annualizedSharpeRatio,
                 certaintyRatio: data.stats.certaintyRatio,
                 expectedYearlyReturns: data.stats.expectedYearlyReturns,
+                sortinoRatio: data.stats.sortinoRatio,
+                calmarRatio: data.stats.calmarRatio,
+                recoveryFactor: data.stats.recoveryFactor,
                 firstEventTime,
                 lastEventTime,
             }, {
@@ -33528,6 +33738,7 @@ async function getBacktestTimeframe(symbol) {
 
 const EXCHANGE_METHOD_NAME_GET_CANDLES = "ExchangeUtils.getCandles";
 const EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE = "ExchangeUtils.getAveragePrice";
+const EXCHANGE_METHOD_NAME_GET_CLOSE_PRICE = "ExchangeUtils.getClosePrice";
 const EXCHANGE_METHOD_NAME_FORMAT_QUANTITY = "ExchangeUtils.formatQuantity";
 const EXCHANGE_METHOD_NAME_FORMAT_PRICE = "ExchangeUtils.formatPrice";
 const EXCHANGE_METHOD_NAME_GET_ORDER_BOOK = "ExchangeUtils.getOrderBook";
@@ -33885,6 +34096,35 @@ class ExchangeInstance {
             const vwap = sumPriceVolume / totalVolume;
             return vwap;
         };
+        /**
+         * Returns the close price of the last completed candle for the given interval.
+         *
+         * Fetches a single candle for the requested interval and returns its close price.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle time interval (e.g., "1m", "1h")
+         * @returns Promise resolving to close price of the last candle
+         * @throws Error if no candles available
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const close = await instance.getClosePrice("BTCUSDT", "1h");
+         * console.log(close); // 50125.43
+         * ```
+         */
+        this.getClosePrice = async (symbol, interval) => {
+            backtest.loggerService.debug(`ExchangeInstance getClosePrice`, {
+                exchangeName: this.exchangeName,
+                symbol,
+                interval,
+            });
+            const candles = await this.getCandles(symbol, interval, 1);
+            if (candles.length === 0) {
+                throw new Error(`ExchangeInstance getClosePrice: no candles data for symbol=${symbol}`);
+            }
+            return candles[candles.length - 1].close;
+        };
         /**
          * Format quantity according to exchange precision rules.
          *
@@ -34242,6 +34482,28 @@ class ExchangeUtils {
             const instance = this._getInstance(context.exchangeName);
             return await instance.getAveragePrice(symbol);
         };
+        /**
+         * Returns the close price of the last completed candle for the given interval.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle time interval (e.g., "1m", "1h")
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to close price of the last candle
+         * @throws Error if no candles available
+         *
+         * @example
+         * ```typescript
+         * const close = await Exchange.getClosePrice("BTCUSDT", "1h", {
+         *   exchangeName: "binance"
+         * });
+         * console.log(close); // 50125.43
+         * ```
+         */
+        this.getClosePrice = async (symbol, interval, context) => {
+            backtest.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_CLOSE_PRICE);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.getClosePrice(symbol, interval);
+        };
         /**
          * Format quantity according to exchange precision rules.
          *
@@ -34828,6 +35090,7 @@ function getActionSchema(actionName) {
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
+const GET_CLOSE_PRICE_METHOD_NAME = "exchange.getClosePrice";
 const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
 const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
 const GET_DATE_METHOD_NAME = "exchange.getDate";
@@ -34925,6 +35188,32 @@ async function getAveragePrice(symbol) {
     }
     return await backtest.exchangeConnectionService.getAveragePrice(symbol);
 }
+/**
+ * Returns the close price of the last completed candle for the given interval.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
+ * @returns Promise resolving to close price of the last candle
+ *
+ * @example
+ * ```typescript
+ * const close = await getClosePrice("BTCUSDT", "1h");
+ * console.log(close); // 50125.43
+ * ```
+ */
+async function getClosePrice(symbol, interval) {
+    backtest.loggerService.info(GET_CLOSE_PRICE_METHOD_NAME, {
+        symbol,
+        interval,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getClosePrice requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getClosePrice requires a method context");
+    }
+    return await backtest.exchangeConnectionService.getClosePrice(symbol, interval);
+}
 /**
  * Formats a price value according to exchange rules.
  *
@@ -61557,4 +61846,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRecentAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSessionAdapter, PersistSignalAdapter, PersistStateAdapter, PersistStorageAdapter, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRecentAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSessionAdapter, PersistSignalAdapter, PersistStateAdapter, PersistStorageAdapter, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };