backtest-kit 7.7.0 → 8.0.0

package/build/index.cjs

@@ -3865,6 +3865,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.
@@ -4270,6 +4291,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.
          *
@@ -5508,6 +5545,10 @@ const GET_SIGNAL_FN = functoolsKit.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;
@@ -5557,6 +5598,10 @@ const GET_SIGNAL_FN = functoolsKit.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;
@@ -6269,6 +6314,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) {
@@ -7152,6 +7201,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) {
@@ -7349,6 +7402,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) {
@@ -8793,6 +8850,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", {
@@ -14860,6 +14921,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.
          *
@@ -19328,6 +19417,24 @@ const heat_columns = [
         format: (data) => data.avgFallPnl !== null ? functoolsKit.str(data.avgFallPnl, "%") : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "sortinoRatio",
+        label: "Sortino",
+        format: (data) => data.sortinoRatio !== null ? functoolsKit.str(data.sortinoRatio) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "calmarRatio",
+        label: "Calmar",
+        format: (data) => data.calmarRatio !== null ? functoolsKit.str(data.calmarRatio) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "recoveryFactor",
+        label: "Recovery",
+        format: (data) => data.recoveryFactor !== null ? functoolsKit.str(data.recoveryFactor) : "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -20890,6 +20997,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",
@@ -21439,13 +21570,13 @@ class ReportBase {
          * Waits for drain event if write buffer is full.
          * Times out after 15 seconds and returns TIMEOUT_SYMBOL.
          */
-        this[_d] = functoolsKit.timeout(async (line) => {
+        this[_d] = functoolsKit.queued(functoolsKit.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,
@@ -21733,6 +21864,9 @@ let ReportStorage$a = class ReportStorage {
                 expectedYearlyReturns: null,
                 avgPeakPnl: null,
                 avgFallPnl: null,
+                sortinoRatio: null,
+                calmarRatio: null,
+                recoveryFactor: null,
             };
         }
         const totalSignals = this._signalList.length;
@@ -21766,6 +21900,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,
@@ -21781,6 +21925,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,
         };
     }
     /**
@@ -21827,6 +21974,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");
     }
     /**
@@ -22427,6 +22577,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");
@@ -22476,6 +22629,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,
@@ -22492,6 +22660,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,
         };
     }
     /**
@@ -22538,6 +22709,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");
     }
     /**
@@ -23983,6 +24157,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",
             "",
@@ -24449,6 +24626,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;
@@ -24474,6 +24672,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,
@@ -24493,6 +24697,9 @@ class HeatmapStorage {
             expectancy,
             avgPeakPnl,
             avgFallPnl,
+            sortinoRatio,
+            calmarRatio,
+            recoveryFactor,
         };
     }
     /**
@@ -29359,6 +29566,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,
             }, {
@@ -33548,6 +33758,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";
@@ -33905,6 +34116,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.
          *
@@ -34262,6 +34502,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.
          *
@@ -34848,6 +35110,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";
@@ -34945,6 +35208,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.
  *
@@ -61690,6 +61979,7 @@ exports.getAveragePrice = getAveragePrice;
 exports.getBacktestTimeframe = getBacktestTimeframe;
 exports.getBreakeven = getBreakeven;
 exports.getCandles = getCandles;
+exports.getClosePrice = getClosePrice;
 exports.getColumns = getColumns;
 exports.getConfig = getConfig;
 exports.getContext = getContext;