Esta estrategia es un sistema de negociación cuantitativo de alta frecuencia enfocado en capturar oportunidades de ruptura de precios durante las sesiones de negociación de Londres y Estados Unidos. Logra retornos comerciales estables a través de sesiones de negociación personalizadas (Zonas de muerte), gestión dinámica de posiciones y gestión precisa de pedidos. El núcleo de la estrategia es establecer un marco comercial completo a través del análisis de acción de precios dentro de sesiones específicas, combinado con datos de puntos altos y bajos del período de retroceso.
La estrategia se basa en los siguientes principios fundamentales:
La estrategia construye un sistema de negociación de alta frecuencia completo mediante la utilización integral de métodos de gestión en múltiples dimensiones, incluidos el tiempo, el precio y la posición.
/*backtest start: 2019-12-23 08:00:00 end: 2024-12-10 08:00:00 period: 1d basePeriod: 1d exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}] */ //@version=6 strategy("ENIGMA ENDGAME Strategy", overlay=true, margin_long=100, margin_short=100) // Description: // The ENIGMA ENDGAME strategy leverages price action breakouts within specific kill zones (London and US sessions) to capture profitable opportunities. // The strategy uses dynamic position sizing based on account equity, precise entry logic via buy-stop and sell-stop orders, and robust risk management to achieve consistent profitability. // Features include: // - Customizable kill zones for session-specific trading. // - Risk management with dynamic position sizing based on user-defined percentages. // - Multiple entry opportunities with lookback-based high/low tracking. // - Automatic pending order cancellation to avoid stale trades. // - Adjustable risk-reward ratios for optimal profit-taking. // Define customizable kill zones for London and US sessions london_start_hour = input.int(2, minval=0, maxval=23, title="London Start Hour (UTC)") london_end_hour = input.int(5, minval=0, maxval=23, title="London End Hour (UTC)") us_start_hour = input.int(8, minval=0, maxval=23, title="US Start Hour (UTC)") us_end_hour = input.int(11, minval=0, maxval=23, title="US End Hour (UTC)") // Risk management parameters risk_percentage = input.float(0.1, title="Risk Percentage per Trade (%)", step=0.01) account_balance = strategy.equity // Define lookback parameters lookback_period = 3 cancel_after_bars = input.int(5, title="Cancel Pending Orders After Bars") // User-defined risk-reward ratio risk_reward_ratio = input.float(1.0, title="Risk-Reward Ratio", minval=0.1, step=0.1) // Kill zone function in_kill_zone = (hour(time) >= london_start_hour and hour(time) < london_end_hour) or (hour(time) >= us_start_hour and hour(time) < us_end_hour) // Calculate Position Size Based on Risk calc_position_size(entry_price, stop_loss) => // This function calculates the position size based on the account equity, risk percentage, and stop-loss distance. risk = account_balance * (risk_percentage / 100) stop_loss_distance = math.abs(entry_price - stop_loss) // Validate stop-loss distance stop_loss_distance := stop_loss_distance < syminfo.mintick * 10 ? syminfo.mintick * 10 : stop_loss_distance position_size = risk / stop_loss_distance // Clamp position size math.min(position_size, 10000000000.0) // Limit to Pine Script max qty // Initialize arrays to store high/low levels var float[] buy_highs = array.new_float(0) var float[] sell_lows = array.new_float(0) var int[] pending_orders = array.new_int(0) // Buy and Sell Arrow Conditions bullish_arrow = close > open and close > high[1] and in_kill_zone // Triggers buy logic when price action breaks out in the upward direction within a kill zone. bearish_arrow = close < open and close < low[1] and in_kill_zone // Triggers sell logic when price action breaks out in the downward direction within a kill zone. // Store Highs and Place Buy-Stops if bullish_arrow array.clear(buy_highs) // Clears previous data to store new highs. for i = 1 to lookback_period array.push(buy_highs, high[i]) // Tracks highs from the lookback period. // Place buy-stop orders for high_level in buy_highs stop_loss = low - syminfo.mintick * 10 // 1 pip below the low take_profit = high_level + (high_level - stop_loss) * risk_reward_ratio // Calculate take-profit based on the risk-reward ratio. strategy.entry("Buy", strategy.long, stop=high_level, qty=calc_position_size(high_level, stop_loss)) strategy.exit("Take Profit", "Buy", limit=take_profit, stop=stop_loss) // Store Lows and Place Sell-Stops if bearish_arrow array.clear(sell_lows) // Clears previous data to store new lows. for i = 1 to lookback_period array.push(sell_lows, low[i]) // Tracks lows from the lookback period. // Place sell-stop orders for low_level in sell_lows stop_loss = high + syminfo.mintick * 10 // 1 pip above the high take_profit = low_level - (stop_loss - low_level) * risk_reward_ratio // Calculate take-profit based on the risk-reward ratio. strategy.entry("Sell", strategy.short, stop=low_level, qty=calc_position_size(low_level, stop_loss)) strategy.exit("Take Profit", "Sell", limit=take_profit, stop=stop_loss) // Cancel Pending Orders After Defined Bars if array.size(pending_orders) > 0 for i = 0 to array.size(pending_orders) - 1 if bar_index - array.get(pending_orders, i) >= cancel_after_bars array.remove(pending_orders, i) // Removes outdated pending orders. // Alerts for debugging alertcondition(bullish_arrow, title="Buy Alert", message="Buy signal generated.") alertcondition(bearish_arrow, title="Sell Alert", message="Sell signal generated.")