Overview

The Multi-Dimensional Market Analysis Quantitative Trading Strategy is a highly intelligent quantitative trading system that integrates multiple technical indicators and market state recognition algorithms to analyze market behavior in real-time and provide trading signals. The core of this strategy lies in its unique market type recognition mechanism, which can automatically identify 10 different market states (such as bull market, bear market, box, volatility, etc.), and dynamically adjust indicator weights based on the current market environment to optimize the decision-making process. The strategy combines trend following, momentum analysis, volume analysis, and candlestick pattern recognition across multiple dimensions, calculating market signal strength through a comprehensive scoring system to ultimately form clear buy or sell decisions.

Strategy Principles

The strategy principles are based on a multi-layered market analysis framework:

1. Basic Indicator Calculation: First, the strategy calculates various technical indicators as the foundation for decision-making, including EMA(55), volume SMA(20/40/10), MACD(12,26,9), RSI(14), and ATR(14).
2. Market State Recognition: The strategy has designed a comprehensive market type recognition algorithm that can accurately determine when the current market is in one of the following 10 states:

• Bull: Price above EMA55, MACD line above signal line, RSI>50, relative volume>1
• Bear: Price below EMA55, MACD line below signal line, RSI<50, volume greater than average
• Sideways: Difference between price and EMA55 less than 0.5 times ATR, and ATR lower than its 20-period average
• Volatile: ATR higher than 1.2 times its 20-period average
• Momentum: Price change greater than 1.5 times ATR, and volume greater than 1.5 times its 20-period average
• Mean Reversion: RSI>70 or RSI❤0
• Box: Sideways and price range less than 0.8 times its 20-period average
• Macro: Absolute value of price change greater than 2 times ATR
• Wolf: Price change less than -ATR and price below EMA55
• Eagle: Bull market and ATR lower than 0.8 times its 20-period average

3. Dynamic Weight Matrix: The strategy automatically adjusts the weights of various indicators based on the identified market type. For example, in a bull market environment, the weights of trend and MACD indicators are increased to 2.0, while in other market types, the weights of various indicators differ.

4. Comprehensive Scoring System: The strategy calculates a 0–100 comprehensive score through weighted calculation of each indicator’s score. A score greater than 65 indicates a strong buy signal, less than 35 indicates a strong sell signal, and the middle range suggests unclear market conditions, recommending observation.

5. Trading Rules: The strategy opens long positions when it identifies bull market, eagle market, or momentum market with a score greater than 65; it opens short positions when it identifies bear market or wolf market with a score less than 35. When the conditions are no longer met, it automatically closes positions.

Strategy Advantages

1. Multi-dimensional Analysis: The strategy not only focuses on price trends but also comprehensively considers volume, volatility, market state, and other dimensions, capturing market opportunities from all angles.
2. Intelligent Market Recognition: It can automatically identify 10 different market states. This refined market classification greatly improves the strategy’s adaptability, allowing it to maintain effectiveness in different market environments.
3. Dynamic Weight Adjustment: The core advantage of the strategy is its dynamic weight mechanism, which automatically adjusts the importance of various indicators according to different market types, avoiding blindly following certain indicators in unsuitable market environments.
4. Visual Decision Panel: The strategy provides a detailed visual panel that clearly displays the status of various indicators, market type, and comprehensive score, making it easy for traders to understand the current decision logic.
5. Integration of Multiple Technical Analysis Methods: The strategy organically combines trend following, momentum, mean reversion, volume analysis, and candlestick pattern recognition, forming a comprehensive analysis system.
6. Clear Entry and Exit Signals: Through the comprehensive scoring system, the strategy provides clear trading signals, reducing the subjectivity and indecision in trading decisions.

Strategy Risks

1. Parameter Sensitivity: The strategy uses multiple indicators and thresholds, and these parameter settings may significantly impact strategy performance. In different market environments or instruments, these parameters may need adjustment, otherwise, they may lead to false signals. The solution is to optimize parameters through backtesting or create adaptive parameter sets for different trading instruments.
2. Rapid Market Transition Risk: When market states change rapidly, the strategy may not capture changes in time, leading to delayed reactions. This can be mitigated by adding short-term indicators or setting more sensitive market state transition detection mechanisms.
3. False Breakout Risk: In box markets, false breakouts may occur, leading to incorrect signals. It is recommended to add confirmation mechanisms to the strategy, such as waiting for the price to continue in the breakout direction for a certain period or combining with other indicators for confirmation.
4. Overtrading Risk: In highly volatile markets, scores may fluctuate frequently, leading to overtrading. This can be reduced by setting minimum holding periods or adding trade filtering conditions to reduce unnecessary trades.
5. System Complexity: The strategy combines multiple indicators and market states, making the system relatively complex, which may increase the risk of errors or overfitting. It is recommended to periodically evaluate the contribution of each component, retain the truly effective parts, and simplify the system.

Strategy Optimization Directions

1. Adaptive Parameter Adjustment: Currently, the strategy uses fixed parameter values. An adaptive mechanism could be introduced to automatically adjust indicator parameters based on market volatility, such as using longer-period moving averages in high-volatility markets and shorter-period ones in low-volatility markets. This can improve the strategy’s adaptability in different market environments.
2. Enhanced Market State Transition Detection: Machine learning algorithms could be introduced to optimize market state recognition by training models to learn the characteristics of different market states, improving recognition accuracy and transition sensitivity.
3. Integration of Multiple Timeframe Information: The current strategy only analyzes based on a single timeframe. Multi-timeframe analysis could be introduced to ensure that the trading direction is consistent with the trend of larger timeframes, increasing the win rate.
4. Risk Management Optimization: Position size and stop-loss levels could be dynamically adjusted based on market volatility and current market state, reducing positions in high-risk environments and appropriately increasing positions in low-risk environments.
5. Drawdown Control Mechanism: Design a risk control mechanism based on account drawdown that automatically reduces trading frequency or pauses trading when the strategy drawdown reaches a certain threshold, protecting capital safety.
6. Optimization of Candlestick Pattern Recognition: The current strategy only recognizes simple hammer lines and engulfing patterns. More high-reliability candlestick patterns could be expanded and combined with volume confirmation to improve pattern recognition accuracy.
7. Seasonality and Time Factors: Analysis of trading sessions, day of the week, month, and other time factors could be introduced to capture the seasonal characteristics of the market and optimize trading timing.

Summary

The Multi-Dimensional Market Analysis Quantitative Trading Strategy is a comprehensive, intelligent quantitative trading system that achieves multi-dimensional market analysis by integrating multiple technical indicators and innovative market state recognition mechanisms. The core advantage of the strategy lies in its ability to accurately identify different market environments and dynamically adjust the weights of various indicators, thereby optimizing the decision-making process and improving trading success rates.

This strategy is particularly suitable for medium to long-term traders because it can effectively identify market trend transition points and maintain positions in favorable market environments. The strategy’s visual panel also provides traders with a clear market analysis view, facilitating understanding of the current market state and decision logic.

Despite the high complexity of the strategy, its modular design allows each part to be independently optimized and adjusted, enabling traders to customize it according to their preferences and market characteristics. By implementing the aforementioned optimization suggestions, this strategy has the potential to further improve its stability and profitability in various market environments, becoming a powerful quantitative trading tool.

Strategy source code

/*backtest
start: 2024-07-22 00:00:00
end: 2025-07-20 08:00:00
period: 2d
basePeriod: 2d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT","balance":2000000}]
*/

//@version=6
strategy("Panel Pro+ Quantum SmartPrompt", overlay=true, max_lines_count=500, max_bars_back=500, calc_on_every_tick=true)

// --- COLORS AND DESIGN
col_fondo    = color.new(color.rgb(245,245,220), 0)
col_borde    = color.rgb(130,130,130)
col_verde    = color.rgb(0,190,80)
col_amarillo = color.rgb(245,200,50)
col_rojo     = color.rgb(240,40,40)
col_texto    = color.rgb(30,30,30)

// --- BASE INDICATORS
ema_suprem   = ta.ema(close, 55)
sma_vol20    = ta.sma(volume, 20)
sma_vol40    = ta.sma(volume, 40)
sma_vol10    = ta.sma(volume, 10)
[macdLine, signalLine, _] = ta.macd(close, 12, 26, 9)
rsi_val      = ta.rsi(close, 14)
atr14        = ta.atr(14)
range20      = ta.stdev(close, 20)
delta        = close - open
sniper_umbral= ta.percentile_nearest_rank(volume, 40, 80)
rvol         = volume / sma_vol20

// --- PRE-CALCULATIONS FOR WARNINGS
smaATR20 = ta.sma(atr14, 20)
smaATR20x12 = smaATR20 * 1.2
smaATR20x08 = smaATR20 * 0.8
smaRange20 = ta.sma(range20, 20)
smaRange20x08 = smaRange20 * 0.8

// --- VOLUMES
vol_abs      = volume
vol_abs_umbral = sma_vol20 * 1.2
vol_abs_col  = vol_abs > vol_abs_umbral ? col_verde : vol_abs > sma_vol20 ? col_amarillo : col_rojo
vol_abs_prompt = vol_abs > vol_abs_umbral ? "High flight." : vol_abs > sma_vol20 ? "Vol avg." : "Low vol."

rvol_col     = rvol > 1.5 ? col_verde : rvol > 0.8 ? col_amarillo : col_rojo
rvol_prompt  = rvol > 1.5 ? "Strong RVOL." : rvol > 0.8 ? "Average RVOL." : "Weak RVOL."

delta_col    = delta > 0 ? col_verde : delta < 0 ? col_rojo : col_amarillo
delta_prompt = delta > 0 ? "Delta+" : delta < 0 ? "Delta-" : "Neutral"

sniper_col   = volume > sniper_umbral ? col_verde : volume > sma_vol20 ? col_amarillo : col_rojo
sniper_prompt= volume > sniper_umbral ? "Sniper: High vol." : volume > sma_vol20 ? "Sniper: Okay." : "Sniper: Bye."

bloques      = volume > (ta.highest(volume, 10) * 0.8) ? "Big" : volume > sma_vol20 ? "Normal" : "Low"
bloques_col  = bloques == "Big" ? col_verde : bloques == "Normal" ? col_amarillo : col_rojo
bloques_prompt = bloques == "Big" ? "Large blocks." : bloques == "Normal" ? "Normal blocks." : "Small blocks."

tick_col     = volume > sma_vol20 ? col_verde : col_rojo
tick_prompt  = volume > sma_vol20 ? "High tick." : "Low tick."

// --- TREND AND OTHER INDICATORS
tendencia    = close > ema_suprem ? 1 : close < ema_suprem ? -1 : 0
tendencia_txt= tendencia == 1 ? "Bullish" : tendencia == -1 ? "Bassist" : "Lateral"
tendencia_col= tendencia == 1 ? col_verde : tendencia == -1 ? col_rojo : col_amarillo
tendencia_prompt = tendencia == 1 ? "Positive momentum." : tendencia == -1 ? "Negative momentum." : "No clear force."

rsi_col      = rsi_val > 70 ? col_rojo : rsi_val < 30 ? col_verde : col_amarillo
rsi_prompt   = rsi_val > 70 ? "Overbought." : rsi_val < 30 ? "Oversold." : "RSI neutro."

macd_col     = macdLine > signalLine ? col_verde : macdLine < signalLine ? col_rojo : col_amarillo
macd_prompt  = macdLine > signalLine ? "Bullish MACD." : macdLine < signalLine ? "MACD bajista." : "MACD neutro."

// --- SIMPLIFIED SAILING PATTERNS
is_hammer    = (high - low) > 3 * math.abs(open - close) and
               (close - low) / (0.001 + high - low) > 0.6 and
               (open - low) / (0.001 + high - low) > 0.6
is_engulfing = close > open[1] and open < close[1] and
               close > open and open < close

pattern      = is_hammer ? 1 : is_engulfing ? 2 : 0
pattern_str  = pattern == 1 ? "Hammer" : pattern == 2 ? "Engulfing" : "-"
pattern_col  = pattern == 1 ? col_verde : pattern == 2 ? col_amarillo : col_rojo
pattern_prompt = pattern == 1 ? "Hammer: possible twist." : pattern == 2 ? "Engulfing: possible change." : "No clear pattern."

// --- DETECTION OF 10 MARKET TYPES (INTEGRATED)
isBull      = close > ema_suprem and macdLine > signalLine and rsi_val > 50 and rvol > 1
isBear      = close < ema_suprem and macdLine < signalLine and rsi_val < 50 and volume > sma_vol20
isSideways  = math.abs(close - ema_suprem) < atr14*0.5 and atr14 < smaATR20
isVolatile  = atr14 > smaATR20x12
isMomentum  = ta.change(close,1) > atr14*1.5 and volume > sma_vol20*1.5
isMeanRev   = rsi_val > 70 or rsi_val < 30
isBox       = isSideways and range20 < smaRange20x08
isMacro     = math.abs(ta.change(close,1)) > atr14*2
isWolf      = ta.change(close,1) < -atr14 and close < ema_suprem
isEagle     = isBull and atr14 < smaATR20x08

var string marketType = ""
var string marketEmoji = ""
var string marketPrompt = ""
var color  marketColor = na

if isEagle
    marketType := "Eagle"
    marketEmoji := "🦅"
    marketPrompt := "Eagle: Fast bull, hold long."
    marketColor := col_verde
else if isBull
    marketType := "Bull"
    marketEmoji := "📈"
    marketPrompt := "Bull: buy on pullbacks."
    marketColor := col_verde
else if isWolf
    marketType := "Wolf"
    marketEmoji := "🐺"
    marketPrompt := "Wolf: short opportunity."
    marketColor := col_amarillo
else if isBear
    marketType := "Bear"
    marketEmoji := "📉"
    marketPrompt := "Bear: reverses a ralli."
    marketColor := col_rojo
else if isBox
    marketType := "Box"
    marketEmoji := "📦"
    marketPrompt := "Box: operate ruptures."
    marketColor := col_amarillo
else if isSideways
    marketType := "Sideways"
    marketEmoji := "↔️"
    marketPrompt := "Range: support/res edges."
    marketColor := col_amarillo
else if isVolatile
    marketType := "Volatile"
    marketEmoji := "🌪"
    marketPrompt := "Volatile: fast scalping."
    marketColor := col_amarillo
else if isMomentum
    marketType := "Momentum"
    marketEmoji := "🚁"
    marketPrompt := "Momentum: impulsive sails."
    marketColor := col_amarillo
else if isMeanRev
    marketType := "MeanRev"
    marketEmoji := "🔁"
    marketPrompt := "Reversal in extremes."
    marketColor := col_amarillo
else if isMacro
    marketType := "Macro"
    marketEmoji := "📅"
    marketPrompt := "Macro event: confirm."
    marketColor := col_amarillo
else
    marketType := "Unknown"
    marketEmoji := "❓"
    marketPrompt := "No clear regime."
    marketColor := col_amarillo

// --- DYNAMIC WEIGHTING MATRIX
// You can adjust these values in the future. Each row represents the market type, and each column represents an indicator.
ponderaciones = array.new_float(10)
if marketType == "Bull"
    array.set(ponderaciones, 0, 2.0) // trend
    array.set(ponderaciones, 1, 1.5) // rsi
    array.set(ponderaciones, 2, 2.0) // macd
    array.set(ponderaciones, 3, 1.3) // vol abs
    array.set(ponderaciones, 4, 1.2) // rvol
    array.set(ponderaciones, 5, 1.0) // delta
    array.set(ponderaciones, 6, 1.2) // sniper
    array.set(ponderaciones, 7, 1.0) // blocks
    array.set(ponderaciones, 8, 1.0) // tick
    array.set(ponderaciones, 9, 1.0) // pattern
else if marketType == "Bear"
    array.set(ponderaciones, 0, 2.0)
    array.set(ponderaciones, 1, 1.5)
    array.set(ponderaciones, 2, 2.0)
    array.set(ponderaciones, 3, 1.5)
    array.set(ponderaciones, 4, 1.3)
    array.set(ponderaciones, 5, 1.1)
    array.set(ponderaciones, 6, 1.2)
    array.set(ponderaciones, 7, 1.1)
    array.set(ponderaciones, 8, 1.0)
    array.set(ponderaciones, 9, 1.0)
// ... You can complete for all types according to your preference.

// --- DYNAMIC GLOBAL SCORING
// (You can expand the weighting for other types just like the example above)
base_score = 0.0
base_score := base_score + ((tendencia == 1 ? 20 : tendencia == -1 ? -20 : 0) * array.get(ponderaciones,0))
base_score := base_score + ((rsi_col == col_verde ? 10 : rsi_col == col_rojo ? -10 : 0) * array.get(ponderaciones,1))
base_score := base_score + ((macd_col == col_verde ? 10 : macd_col == col_rojo ? -10 : 0) * array.get(ponderaciones,2))
base_score := base_score + ((vol_abs_col == col_verde ? 8 : vol_abs_col == col_rojo ? -8 : 0) * array.get(ponderaciones,3))
base_score := base_score + ((rvol_col == col_verde ? 7 : rvol_col == col_rojo ? -7 : 0) * array.get(ponderaciones,4))
base_score := base_score + ((delta_col == col_verde ? 6 : delta_col == col_rojo ? -6 : 0) * array.get(ponderaciones,5))
base_score := base_score + ((sniper_col == col_verde ? 8 : sniper_col == col_rojo ? -8 : 0) * array.get(ponderaciones,6))
base_score := base_score + ((bloques_col == col_verde ? 5 : bloques_col == col_rojo ? -5 : 0) * array.get(ponderaciones,7))
base_score := base_score + ((tick_col == col_verde ? 5 : -5) * array.get(ponderaciones,8))
base_score := base_score + ((pattern == 1 ? 7 : pattern == 2 ? 5 : 0) * array.get(ponderaciones,9))

score_pct = math.max(0, math.min(100, 50 + base_score))
prompt_global = score_pct > 65 ? "🟢 Strong signal: Consider entry." : score_pct < 35 ? "🔴 Weak signal: DO NOT enter." : "🟡 Mixed signal: Better to wait."
explicacion_global = score_pct > 65 ? "Optimal conditions. 👍" : score_pct < 35 ? "Weak or mixed indicators. 🚫" : "Sideways or transition market. ⏸"

// --- ADVANCED VISUAL PANEL
var table t = table.new(position.middle_left, 5, 14, bgcolor=col_fondo, border_width=2, border_color=col_borde)
if barstate.islast
    table.cell(t, 0, 0, "🔎", bgcolor=col_fondo, text_color=col_texto)
    table.cell(t, 1, 0, "🪙 Tipo", bgcolor=col_fondo, text_color=col_texto)
    table.cell(t, 2, 0, "⚡️", bgcolor=col_fondo, text_color=col_texto)
    table.cell(t, 3, 0, "Worth", bgcolor=col_fondo, text_color=col_texto)
    table.cell(t, 4, 0, "Prompt", bgcolor=col_fondo, text_color=col_texto)
    table.cell(t, 1, 1, "Trend", text_color=col_texto)
    table.cell(t, 2, 1, "", bgcolor=tendencia_col)
    table.cell(t, 3, 1, tendencia_txt, text_color=col_texto)
    table.cell(t, 4, 1, tendencia_prompt, text_color=col_texto)
    table.cell(t, 1, 2, "RSI", text_color=col_texto)
    table.cell(t, 2, 2, "", bgcolor=rsi_col)
    table.cell(t, 3, 2, str.tostring(rsi_val, "#.##"), text_color=col_texto)
    table.cell(t, 4, 2, rsi_prompt, text_color=col_texto)
    table.cell(t, 1, 3, "MACD", text_color=col_texto)
    table.cell(t, 2, 3, "", bgcolor=macd_col)
    table.cell(t, 3, 3, str.tostring(macdLine, "#.##"), text_color=col_texto)
    table.cell(t, 4, 3, macd_prompt, text_color=col_texto)
    table.cell(t, 1, 4, "Absolute", text_color=col_texto)
    table.cell(t, 2, 4, "", bgcolor=vol_abs_col)
    table.cell(t, 3, 4, str.tostring(vol_abs), text_color=col_texto)
    table.cell(t, 4, 4, vol_abs_prompt, text_color=col_texto)
    table.cell(t, 1, 5, "Relative", text_color=col_texto)
    table.cell(t, 2, 5, "", bgcolor=rvol_col)
    table.cell(t, 3, 5, str.tostring(rvol, "#.##"), text_color=col_texto)
    table.cell(t, 4, 5, rvol_prompt, text_color=col_texto)
    table.cell(t, 1, 6, "Delta", text_color=col_texto)
    table.cell(t, 2, 6, "", bgcolor=delta_col)
    table.cell(t, 3, 6, str.tostring(delta, "#.##"), text_color=col_texto)
    table.cell(t, 4, 6, delta_prompt, text_color=col_texto)
    table.cell(t, 1, 7, "Sniper", text_color=col_texto)
    table.cell(t, 2, 7, "", bgcolor=sniper_col)
    table.cell(t, 3, 7, sniper_col == col_verde ? "Yeah" : "No", text_color=col_texto)
    table.cell(t, 4, 7, sniper_prompt, text_color=col_texto)
    table.cell(t, 1, 8, "Blocks", text_color=col_texto)
    table.cell(t, 2, 8, "", bgcolor=bloques_col)
    table.cell(t, 3, 8, bloques, text_color=col_texto)
    table.cell(t, 4, 8, bloques_prompt, text_color=col_texto)
    table.cell(t, 1, 9, "Tick", text_color=col_texto)
    table.cell(t, 2, 9, "", bgcolor=tick_col)
    table.cell(t, 3, 9, str.tostring(volume), text_color=col_texto)
    table.cell(t, 4, 9, tick_prompt, text_color=col_texto)
    table.cell(t, 1,10, "Sailing Pattern", text_color=col_texto)
    table.cell(t, 2,10, pattern_str, bgcolor=pattern_col, text_color=col_texto)
    table.cell(t, 3,10, pattern != 0 ? pattern_str : "No pattern", text_color=col_texto)
    table.cell(t, 4,10, pattern_prompt, text_color=col_texto)
    // Global
    table.cell(t, 1,11, "📊 Global", text_color=color.black, bgcolor=color.new(col_fondo, 40))
    table.cell(t, 2,11, "", bgcolor=score_pct > 65 ? col_verde : score_pct < 35 ? col_rojo : col_amarillo)
    table.cell(t, 3,11, str.tostring(score_pct, "#") + "%", text_color=color.black)
    table.cell(t, 4,11, prompt_global, text_color=color.black)
    // Global Explanation
    table.cell(t, 1,12, "Explanation", text_color=color.black, bgcolor=color.new(col_fondo, 40))
    table.cell(t, 2,12, "", bgcolor=color.new(col_fondo, 0))
    table.cell(t, 3,12, "", bgcolor=color.new(col_fondo, 0))
    table.cell(t, 4,12, explicacion_global, text_color=color.black)
    // Market Detection
    table.cell(t, 1,13, "Market", text_color=col_texto)
    table.cell(t, 2,13, "", bgcolor=marketColor)
    table.cell(t, 3,13, marketEmoji + " " + marketType, text_color=col_texto)
    table.cell(t, 4,13, marketPrompt, text_color=col_texto)

// === STRATEGIC OPERATING RULES AND ALERTS ===
longCond = (marketType == "Bull" or marketType == "Eagle" or marketType == "Momentum") and score_pct > 65
shortCond = (marketType == "Bear" or marketType == "Wolf") and score_pct < 35

if longCond and strategy.position_size <= 0
    strategy.entry("LONG", strategy.long)
    alert("🟢 LONG Entrance: Market " + marketType + " | " + prompt_global, alert.freq_once_per_bar)
if shortCond and strategy.position_size >= 0
    strategy.entry("CORTO", strategy.short)
    alert("🔴 SHORT Entry: Market " + marketType + " | " + prompt_global, alert.freq_once_per_bar)
if (not longCond and strategy.position_size > 0)
    strategy.close("LONG", comment="LONG Exit")
if (not shortCond and strategy.position_size < 0)
    strategy.close("SHORT", comment="SHORT Exit")

The original address: Multi-Dimensional Market Analysis Quantitative Trading Strategy

Overview

The ADX and Supertrend Persistent Entry Trading Strategy is a quantitative trading method that combines directional indicators with trend confirmation tools. This strategy integrates the Average Directional Index (ADX), Directional Movement Index (DMI), and Supertrend indicator, supplemented by volume-weighted Order Block analysis to build a comprehensive trading system. The strategy particularly emphasizes a persistent condition verification mechanism, triggering trading signals only after multiple technical conditions are met, which effectively improves trading quality and reduces the occurrence of false signals.

Strategy Principles

The core logic of this strategy is based on the following key components:

1. ADX and DMI Indicator Analysis: The system uses the ADX indicator to measure market trend strength and determines trend direction by comparing +DI and -DI values. When the ADX value is above a set threshold (default 25), it indicates a strong market trend; +DI greater than -DI suggests a bullish trend, while the opposite indicates a bearish trend.
2. Supertrend Trend Confirmation: The Supertrend indicator serves as a secondary trend confirmation tool, supporting buying when it shows a bullish signal (trend == -1) and selling when it shows a bearish signal (trend == 1). Changes in Supertrend are also used as exit signal triggers.
3. Volume-Weighted Order Blocks: The strategy introduces a dynamic support and resistance zone identification mechanism based on volume. When volume exceeds a specific multiple of the average level (default 2x) and price reaches local highs or lows, the system marks these areas as potential order blocks and maintains their validity for a set period (default 15 periods).
4. Persistent Condition Verification: The most unique part of the strategy is its persistent condition verification mechanism. The system tracks various trading conditions through four boolean flags: trend condition, ADX condition, DMI condition, and zone condition. Trading signals are triggered only when all conditions are met. This mechanism ensures that trading occurs in optimal market environments.

Buy conditions:

• ADX above threshold (default 25)
• +DI greater than -DI
• Supertrend in bullish state
• Price not within volume resistance zone

Sell conditions:

• ADX above threshold (default 25)
• -DI greater than +DI
• Supertrend in bearish state
• Price not within volume support zone

Exit logic: When the Supertrend indicator changes trend direction, the strategy closes the current position.

Strategy Advantages

1. Multiple Confirmation Mechanism: By integrating multiple technical indicators, the strategy greatly reduces false signals and improves trading accuracy. The combination of ADX and Supertrend, in particular, ensures both trend strength and provides clear directional guidance.
2. Persistent Condition Verification: The strategy’s persistent verification mechanism allows the system to act only when all conditions mature, rather than triggering trades based on single signals. This design greatly enhances the strategy’s robustness and reduces unnecessary trades under unfavorable market conditions.
3. Dynamic Support and Resistance Identification: Volume-based order block analysis provides the strategy with dynamic support and resistance references, making trading decisions more aligned with market microstructure and avoiding counter-trend trading at key price zones.
4. Clear Exit Mechanism: The strategy uses Supertrend reversals as exit signals, providing objective and timely stop-loss and take-profit methods, effectively managing the risk of each trade.
5. High Adaptability: Through multiple adjustable parameters, the strategy can adapt to different market environments and trading instruments, enhancing its practicality and flexibility.

Strategy Risks

1. Parameter Sensitivity: The strategy’s effectiveness largely depends on parameter settings. The choice of ADX length, Supertrend multiplier, and ATR period significantly impacts strategy performance. Inappropriate parameter settings may lead to overtrading or missing important opportunities. The solution is to optimize parameters through historical backtesting and prepare different parameter combinations for different market environments.
2. Trend Reversal Risk: Despite using multiple confirmation mechanisms, the strategy may still face lag risk during strong market reversals or high volatility environments. The solution is to consider introducing volatility filters or dynamically adjusting ADX thresholds to adapt to different market volatility states.
3. Volume Anomaly Risk: The strategy is relatively dependent on volume analysis and may produce incorrect order block identification in cases of abnormal volume (such as sudden non-regular large volume). The solution is to add volume smoothing processing or introduce additional anomaly detection mechanisms.
4. Over-Optimization Risk: Because the strategy contains multiple adjustable parameters, it can easily lead to over-optimization, making the strategy perform well on historical data but poorly in actual trading. The solution is to use forward testing and out-of-sample testing to ensure the strategy’s robustness.
5. Liquidity Risk: In low-liquidity markets, large transactions may lead to slippage or order execution delays, affecting strategy effectiveness. The solution is to add additional liquidity filtering conditions in low-liquidity environments or adjust position size.

Strategy Optimization Directions

1. Dynamic Parameter Adjustment: The strategy can be further optimized to automatically adjust ADX thresholds and Supertrend parameters based on market volatility. For example, ADX thresholds can be increased during high volatility periods to reduce false breakout signals, and thresholds can be lowered during low volatility periods to increase sensitivity. This adaptive mechanism allows the strategy to better adapt to different market phases.
2. Time Filter Integration: Introducing time filters can avoid trading during market opening, closing, or periods of poor liquidity. This optimization is particularly suitable for intraday trading strategies and can significantly reduce unnecessary trades caused by market noise.
3. Multi-Timeframe Analysis: By integrating trend information from higher timeframes, the strategy can ensure that trading direction remains consistent with the larger trend. For example, executing trades only when daily and hourly trend directions align can improve win rates and reduce counter-trend trading risk.
4. Risk Management Enhancement: The current strategy’s exit mechanism is relatively simple and can be enhanced by adding trailing stops, profit-to-loss ratio filtering, or volatility-based stop-loss calculations. These improvements can better protect profits and control risk for each trade.
5. Market State Classification: Introducing a market state classification mechanism enables the strategy to identify different market environments such as consolidation periods, trend periods, and high volatility periods, and adjust trading logic accordingly. This optimization can avoid trading under market conditions unsuitable for the strategy, further enhancing the strategy’s robustness.

Summary

The ADX and Supertrend Persistent Entry Trading Strategy builds a comprehensive and robust trading system by integrating multiple technical indicators and a unique persistent condition verification mechanism. The strategy particularly emphasizes trading under ideal market conditions, avoiding many common false signal traps. Through the combined use of ADX, DMI, and Supertrend, the strategy can effectively identify strong trend environments and determine the correct trading direction; while volume-weighted order block analysis provides additional microstructure support, helping to avoid counter-trend trading at key support and resistance areas.

Despite its many advantages, users should still be aware of potential issues such as parameter sensitivity, trend reversal risk, and over-optimization. The strategy still has significant room for optimization through the introduction of dynamic parameter adjustment, multi-timeframe analysis, and enhanced risk management mechanisms. Ultimately, this approach, combining technical indicators and market microstructure analysis, represents a balanced and comprehensive quantitative trading approach suitable for investors seeking high-quality trading signals rather than high-frequency trading.

Strategy source code

/*backtest
start: 2024-07-22 00:00:00
end: 2025-07-20 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT","balance":2000000}]
*/

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

// © algostudio

//Code Generated using PineGPT  - www.marketcalls.in

//@version=6
strategy("ADX + Supertrend Persistent Entry Logic", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=10, process_orders_on_close=true, calc_on_every_tick=true, max_bars_back=500)

// === INPUTS === //
adxLen = input.int(7, "ADX Length")
dilen = input.int(7, "+DI/-DI Length")
adxThresh = input.float(25, "ADX Threshold")
supertrendFactor = input.float(2.0, "Supertrend Multiplier", minval=0.1)
supertrendLen = input.int(7, "Supertrend ATR Length")
volLookback = input.int(10, "Volume Zone Lookback")
volMult = input.float(2.0, "Volume Threshold Multiplier")
zoneDuration = input.int(15, "Zone Display Duration")

// === ADX AND DI CALCULATION === //
[plusDI, minusDI, adx] = ta.dmi(dilen, adxLen)

// === SUPER TREND CALCULATION === //
[supertrend, trend] = ta.supertrend(supertrendFactor, supertrendLen)

bullishSupertrendShift = trend == -1 and trend[1] == 1
bearishSupertrendShift = trend == 1 and trend[1] == -1

// === DYNAMIC ORDER BLOCK ZONES (Volume weighted) === //
volThreshold = ta.sma(volume, volLookback) * volMult
volHighs = high == ta.highest(high, 5) and volume > volThreshold
volLows = low == ta.lowest(low, 5) and volume > volThreshold

obSupportValid = ta.valuewhen(volLows, low, 0)
bbResistanceValid = ta.valuewhen(volHighs, high, 0)
obSupportStart = ta.valuewhen(volLows, bar_index, 0)
bbResistanceStart = ta.valuewhen(volHighs, bar_index, 0)
obSupportEnd = obSupportStart + zoneDuration
bbResistanceEnd = bbResistanceStart + zoneDuration

inObZone = bar_index >= obSupportStart and bar_index <= obSupportEnd
inBbZone = bar_index >= bbResistanceStart and bar_index <= bbResistanceEnd

// === PLOT ZONES === //
plot(inObZone ? obSupportValid : na, title="OB Support Line", color=color.green, linewidth=2)
plot(inBbZone ? bbResistanceValid : na, title="BB Resistance Line", color=color.red, linewidth=2)
plot(supertrend, color=trend == 1 ? color.red : color.green, title="Supertrend")

// === PERSISTENT FLAGS === //
var bool buyTrendMet = false
var bool buyAdxMet = false
var bool buyDiMet = false
var bool buyZoneClear = false

var bool sellTrendMet = false
var bool sellAdxMet = false
var bool sellDiMet = false
var bool sellZoneClear = false

// === READY FLAGS (declare early to resolve use-before-declare issues) === //
buyReady = buyTrendMet and buyAdxMet and buyDiMet and buyZoneClear
sellReady = sellTrendMet and sellAdxMet and sellDiMet and sellZoneClear

// Track condition flags
buyTrendMet := trend == -1 ? true : buyTrendMet
buyAdxMet := adx > adxThresh ? true : (buyReady ? buyAdxMet : false)
buyDiMet := plusDI > minusDI ? true : buyDiMet
buyZoneClear := not inBbZone ? true : buyZoneClear

sellTrendMet := trend == 1 ? true : sellTrendMet
sellAdxMet := adx > adxThresh ? true : (sellReady ? sellAdxMet : false)
sellDiMet := minusDI > plusDI ? true : sellDiMet
sellZoneClear := not inObZone ? true : sellZoneClear

// Recalculate readiness after condition updates
buyReady := buyTrendMet and buyAdxMet and buyDiMet and buyZoneClear
sellReady := sellTrendMet and sellAdxMet and sellDiMet and sellZoneClear

// === STRATEGY ENTRIES === //
if buyReady
    strategy.entry("Buy", strategy.long)
    buyTrendMet := false
    buyAdxMet := false
    buyDiMet := false
    buyZoneClear := false

if sellReady
    strategy.entry("Sell", strategy.short)
    sellTrendMet := false
    sellAdxMet := false
    sellDiMet := false
    sellZoneClear := false

// === STRATEGY EXITS === //
if strategy.position_size > 0 and trend == 1
    strategy.close("Buy")

if strategy.position_size < 0 and trend == -1
    strategy.close("Sell")

// === PLOTS === //
plotshape(buyReady, location=location.belowbar, color=color.green, style=shape.labelup, text="BUY")
plotshape(sellReady, location=location.abovebar, color=color.red, style=shape.labeldown, text="SELL")

// For more tutorials on Tradingview Pinescript visit , visit https://www.marketcalls.in/category/tradingview

Strategy parameters

The original address: ADX and Supertrend Persistent Entry Strategy

⚠️ Important Disclaimer

This article demonstrates a volume-boosting self-matching trading strategy intended solely for learning purposes related to trading system architecture. It fundamentally differs from traditional arbitrage or market-making strategies. The core idea of this strategy is to simulate volume through same-price buy-sell matching to obtain exchange rebates or tier-based trading fee discounts, rather than profiting from market inefficiencies.

The provided code is only a reference framework and has not been tested in live trading environments. The strategy implementation is purely for technical study and research, and has not been thoroughly validated under real market conditions. Readers must perform extensive backtesting and risk evaluation before considering any real-world application. Do not use this strategy for live trading without proper due diligence.

In the cryptocurrency market, market-making strategies serve not only to improve liquidity and facilitate trading, but also form a core component of many quantitative trading systems. Market makers quote both buy and sell prices, provide liquidity, and capture profits under various market conditions. Professional market-making systems are often highly sophisticated, involving ultra-low-latency optimization, advanced risk management modules, and cross-exchange arbitrage mechanisms. In this article, we explore the basic concept behind a volume-boosting self-matching trading strategy and demonstrate how to implement a simplified educational framework on the FMZ Quant Trading Platform.

The main content is adapted from the original work “Market Making Strategy: Concepts and Implementation” by Zinan, with some optimizations and adjustments. While some coding practices may now appear outdated, this version recreated on the FMZ platform still offers valuable insights into the structure of trading algorithms and the fundamentals of self-matching trading logic.

Concept of Market Making Strategies

A Market Making Strategy refers to a trading approach where a trader (market maker) places both buy and sell orders in the market simultaneously, thereby providing liquidity and contributing to market stability. This strategy not only helps maintain market depth but also offers counterparties for other traders. By quoting buy and sell prices across various price levels, market makers aim to profit from market fluctuations.

In the context of cryptocurrency markets, market makers play a critical role — especially in markets with low trading volume or high volatility. By offering liquidity, market makers help reduce slippage and make it easier for other traders to execute orders at favorable prices.

The core principle of traditional market-making strategies lies in capturing the bid-ask spread by providing liquidity. Market makers post buy orders at lower prices and sell orders at higher prices, profiting from the difference when orders are filled. For example, when the spot price in the market rises, market makers sell at a higher price and buy at a lower price, earning the difference. The primary sources of income include:

• Bid-ask spread: Traditional market makers earn profits by placing limit buy and sell orders and capturing the price difference between the bid and ask.
• Volume-based incentives: The profitability of market makers is closely tied to the trading volume they provide. Higher volume not only leads to more frequent order fills and profit opportunities but also unlocks additional benefits:
  1). Fee rebates: Many exchanges offer fee rebates to incentivize liquidity provision. In some cases, makers receive negative fees — meaning the exchange pays the market maker for executed trades.
  2). VIP tier discounts: Reaching specific volume thresholds may qualify market makers for lower trading fees, reducing operational costs.
  3). Market maker incentive programs: Some exchanges run dedicated incentive programs that reward market makers based on the quality and consistency of their liquidity provision.

However, market makers also face significant market risk, especially in highly volatile environments such as the cryptocurrency space. Rapid price swings may cause market makers’ quoted prices to deviate significantly from actual market conditions, potentially resulting in losses.

Types of Market Making Strategies

In the cryptocurrency market, market makers typically choose different strategies based on market conditions, trading volume, and volatility. Common types of market-making strategies include:

• Passive market making: In this approach, the market maker places buy and sell limit orders based on market depth, historical volatility, and other indicators, then waits for the market to fill those orders. This strategy is characterized by low frequency and a conservative risk profile, relying on natural market movements to generate profit.
• Active market making: Active market makers dynamically adjust order prices and sizes in real time based on market conditions to improve execution probability. They often place orders close to the current mid-price, aiming to better capture opportunities from short-term volatility.
• Volume-boosting self-matching strategy: The focus of this article. A volume-boosting self-matching strategy involves placing simultaneous buy and sell orders at the same price to artificially increase trading volume. Unlike traditional market-making, this strategy is not designed to profit from bid-ask spreads. Instead, it seeks to benefit from exchange incentives such as fee rebates, VIP tier discounts, or liquidity mining rewards.

In a volume-boosting self-matching strategy, the market maker posts buy and sell orders at the same price level. While these trades do not generate profits from price differentials, they quickly accumulate trading volume. Profitability is entirely dependent on the exchange’s incentive mechanisms rather than market inefficiencies or arbitrage.

Key characteristics:

• Same-price orders: Unlike traditional market-making, buy and sell orders are placed at the same price, eliminating spread-based profits.
• Volume-oriented execution: The primary objective is to accumulate trade volume rapidly, not to exploit price arbitrage.
• Incentive-driven profitability: Returns are fully reliant on exchange incentives such as fee rebates, VIP tier benefits, or dedicated market maker reward programs.

Important distinction:
Compared to traditional market-making strategies, volume-boosting self-matching strategies do not generate profit by providing genuine market liquidity. Instead, they create trading volume artificially to capitalize on policy-driven rewards offered by exchanges. This type of strategy may carry regulatory or compliance risks in certain jurisdictions and must be carefully evaluated before any live trading deployment.

Profit Logic Behind Volume-Boosting Self-Matching Strategies

Upon analyzing the code implementation, it becomes evident that the buy and sell prices are exactly the same in this strategy:

def make_duiqiao_dict(self, trade_amount):
    mid_price = self.mid_price  # Med price
    trade_price = round(mid_price, self.price_precision)  # Accurate transaction price
    trade_dict = {
        'trade_price': trade_price,  # The same price is used for both buying and selling
        'amount': trade_amount
    }
    return trade_dict

Actual Profit Mechanism

1. Volume-boosting via self-matching

• The core objective of this strategy is to increase trading volume rapidly through high-frequency self-matching.
• Profit is derived from exchange incentives such as fee rebates, VIP tier upgrades, or liquidity mining rewards.
• This approach is applicable on exchanges that offer formal market maker incentive programs.

2. Fee rebate mechanism

• The strategy relies on exchanges offering negative maker fees (maker rates are negative)
• By providing liquidity, the strategy earns rebates on filled orders.
• It requires the exchange to support market maker fee discounts or rebate structures.

Suitable Scenarios & Associated Risks

✅ Suitable scenarios

• Exchanges with clear market maker rebate or incentive policies.
• Traders aiming to meet high trading volume requirements for VIP tier upgrades.
• Platforms that run liquidity mining or commission rebate campaigns.

❌ Unsuitable scenarios

• Exchanges that do not offer fee rebates or incentives.
• Platforms with high transaction fees, where self-matching leads to net losses.
• Exchanges that explicitly prohibit wash trading or enforce restrictions on artificial volume.

⚠️ Risk warnings

• If both buy and sell orders are filled simultaneously, the strategy may incur a net loss after fees.
• Changes in exchange policies may render the strategy unprofitable or non-viable.
• Continuous monitoring of fee structures and trading costs is required.
• The strategy may face compliance risks in jurisdictions where volume-boosting trading is regulated or restricted.

Self-Matching Strategy Architecture Analysis

This section presents a simplified implementation of a volume-boosting self-matching strategy, inspired by the framework developed by Zinan. The focus is on how to accumulate trading volume through same-price buy and sell orders within a live exchange environment. The strategy architecture is structured around two main classes: MidClass and MarketMaker. These components are responsible for handling exchange interactions and executing the self-matching logic, respectively.

The architecture follows a layered design, separating the exchange interface logic from the trading strategy logic. This ensures modularity, extensibility, and clean separation of concerns. The main components are:

1. MidClass: The exchange middle layer is responsible for interacting with the exchange interface to obtain market data, account information, order status, etc. This layer encapsulates all interactions with external exchanges to ensure that the trading logic and the exchange interface are decoupled.
2. MarketMaker: The market making strategy class is responsible for executing the cross-trading strategy, generating pending orders, checking order status, updating strategy status, etc. It interacts with the exchange middle layer to provide specific market making and self-matching trading operations.

MidClass

MidClass is the middle layer of the exchange. Its main responsibility is to handle the interaction with the exchange, encapsulate all external API calls, and provide a simple interface for MarketMaker to use. Its architecture includes the following key functions:

1. Market data retrieval:
Fetches real-time market data such as tickers, order book depth, and candlestick data (K-lines). Regular updates are essential to ensure the strategy operates on up-to-date information.

2. Account information management:
Retrieves account data, including balances, available margin, and open positions. This is critical for capital allocation and risk control.

3. Order management:
Provides functionality to place, query, and cancel orders. This is the foundation of executing a market-making or self-matching strategy and ensures robust control over open orders.

4. Data Synchronization:
Maintains persistent connections with the exchange and updates internal state for use by the strategy layer.

By encapsulating these features in MidClass, the strategy logic within MarketMaker remains focused on execution rather than infrastructure. This structure improves the maintainability and scalability of the system, making it easier to add support for different exchanges or optimize existing functions.

MarketMaker

MarketMaker is the core class of the self-matching strategy, responsible for executing market-making operations and handling self-matching trades. Its architecture typically includes the following key modules:

1. Initialization:

• Initialize the exchange middleware (MidClass) to retrieve exchange metadata such as trading pair details, precision, tick size, and order book depth.
• Initialize the market-making strategy, set up key parameters like order quantity, price spread, and execution intervals. These parameters directly affect how the strategy behaves and performs in the market.

2. Data refresh:

• Periodic market data updates, including real-time account information, market price, depth, K-line, etc. These data provide basic information for executing strategies.
• The frequency of updates can be dynamically adjusted based on market volatility to ensure timely responses to market changes.

3. Self-matching execution logic:

• Order book construction: Based on current market depth and price dynamics, construct a dictionary of orders (both bids and asks) with specified price and size. This is typically calculated using predefined strategy parameters.
• Self-matching execution: Once the order structure is ready, MarketMaker submits both buy and sell orders at the same price level to the market. The goal is to accumulate trade volume quickly via same-price order matching.
• Order status monitoring: During execution, MarketMaker will check the status of the order constantly to ensure that the pending order can be processed in time. If the order fails to be executed, it will adjust the pending order price or quantity until the order is completed.

4. Strategy state update:

• Strategy status update: Regularly update key performance indicators such as cumulative trading volume, filled order count, and total fees. These metrics allow real-time tracking of the strategy’s performance.
• Dynamic risk management: The strategy adapts its behavior based on current market conditions. MarketMaker can modify execution logic in real time to reduce risk and maintain operational efficiency across varying market environments.

Self-Matching Strategy Logic Reconstruction

The implementation of a self-matching strategy relies on precise market data and fast execution. The MarketMaker class monitors real-time market conditions and leverages same-price buy and sell orders (self-matching) to rapidly accumulate trading volume, which is the core objective of this strategy.

Initialization

In the MarketMaker class’s initialization method, the first step is to retrieve the exchange’s precision settings, followed by initializing key strategy parameters such as quantity precision and price precision.

self.precision_info = self.exchange_mid.get_precision()  # Get precision information
self.price_precision = self.precision_info['price_precision']  # Price precision
self.amount_precision = self.precision_info['amount_precision']  # Trading volume precision

Generating the Self-Matching Order Dictionary

At the heart of the self-matching strategy is the construction of an order dictionary containing both buy and sell orders at the same price level, along with their respective quantities. The code generates the dictionary of self-matching trading orders by calculating the middle price.

def make_duiqiao_dict(self, trade_amount):
    mid_price = self.mid_price  # Mid Price
    trade_price = round(mid_price, self.price_precision)  # Accurate transaction price
    trade_dict = {
        'trade_price': trade_price,
        'amount': trade_amount
    }
    return trade_dict

Executing Self-Matching Trades

According to the generated dictionary of self-matching trading orders, the self-matching trading transaction is executed. In the code, the create_order method of the exchange middle layer is called to place buy orders and sell orders at the same time.

def make_trade_by_dict(self, trade_dict):
    if self.position_amount > trade_dict['amount'] and self.can_buy_amount > trade_dict['amount']:
        buy_id = self.exchange_mid.create_order('buy', trade_dict['trade_price'], trade_dict['amount'])  # Pending buy order
        sell_id = self.exchange_mid.create_order('sell', trade_dict['trade_price'], trade_dict['amount'])  # Pending sell order
        self.traded_pairs['dui_qiao'].append({
            'buy_id': buy_id, 'sell_id': sell_id, 'init_time': time.time(), 'amount': trade_dict['amount']
        })

Order Status Monitoring

The strategy periodically checks the status of active orders and handles any unfilled or partially filled ones. In the code, this is done by calling the GetOrder method from the exchange middleware (MidClass). Based on the returned order status, the strategy decides whether to cancel the orders. The self-matching order management logic includes the following key steps:

1. Fetching order status:

• The strategy retrieves the current status of both the buy and sell orders through the exchange API.
• If the status retrieval fails (e.g., due to a missing order or network issue), the strategy cancels the corresponding order and removes it from the active tracking list.

2. Evaluating order status:

• The status returned is used to determine whether the order is filled, partially filled, or still open.
• Typical order status include:
  0(ORDER_STATE_PENDING): Order is open and waiting to be filled.
  1(ORDER_STATE_CLOSED): Order has been completely filled.
  2(ORDER_STATE_CANCELED): Order has been canceled.
  3(ORDER_STATE_UNKNOWN): Order status is unknown or undefined.

3. Handling order status:

• Both orders unfilled:
  If both buy and sell orders remain unfilled (status 0), the strategy checks the polling interval (e.g., current_time % 5 == 0) to decide whether to cancel them.
  After cancellation, the strategy updates the order count and removes the orders from the internal record.
• One order filled, the other unfilled:
  If one side of the self-matching order pair is filled (status == 1) and the other remains unfilled (status == 0), the strategy uses the polling interval condition to decide whether to cancel the unfilled order.
  After cancelling an open order, update the volume and the list of open orders and remove the order from the record.
• Both orders filled:
  If both the buy and sell orders are fully executed (status == 1), the strategy updates the trade volume counter, and the order pair is removed from the internal tracking list.
• Unknown order status:
  If the order status is neither 0 nor 1, it is recorded as unknown status and logged.

4. Updating internal records:
After processing the order statuses, the strategy updates the total accumulated trade volume, the list of unfilled or partially filled orders, the order submission and cancellation counters.

Future Strategy Outlook

The self-matching strategy presented in this article is primarily intended as an educational example for understanding the architectural design of trading frameworks. Its practical application in live trading is limited. For readers interested in real market-making strategies, we plan to introduce more advanced and practical models in future content:

1. Order book market-making strategy

• A true arbitrage-based approach that captures the bid-ask spread.
• Places limit orders between the best bid and ask to earn the spread profit.
• Closely aligns with the traditional profit model of professional market makers.

2. Dynamic market-making strategy

• Adapts quote prices in real-time based on market volatility.
• Integrates inventory management and risk control mechanisms.
• Suitable for adaptive execution across varying market conditions.

3. Multi-level market-making strategy

• Places orders at multiple price levels simultaneously.
• Diversifies execution risk and enhances overall return stability.
• Closer to how professional market-making systems operate in production.

These upcoming strategies will emphasize realistic profit logic and robust risk management, providing quantitative traders with more actionable and valuable insights for developing production-ready systems.

Strategy Outlook

Self-matching strategies that rely on exchange incentive policies, such as fee rebates, VIP tier upgrades, or liquidity mining rewards — are inherently vulnerable to changes in those policies. If an exchange adjusts its fee structure or removes such incentives, the strategy may become ineffective or even result in net losses. To mitigate this, the strategy must incorporate adaptability to policy changes, such as dynamic monitoring of fee rates and trading incentives, multiple profit sources to reduce over-reliance on a single incentive. fallback mechanisms or automatic shutdown triggers if profitability thresholds are not met. Moreover, self-matching strategies may raise regulatory red flags, as they can be interpreted as attempts to manipulate market volume. In many jurisdictions, such behavior may violate market integrity laws.

Therefore, traders must stay updated on local legal and compliance requirements, consult with legal professionals when deploying volume-based strategies, avoid practices that could be construed as deceptive or manipulative.

We hope readers use this strategy framework as a foundation to build more robust, compliant, and innovative trading systems. The true value of quantitative trading lies in continuous learning, experimentation, and refinement. May your journey in quant trading be insightful, adaptive, and rewarding!

Strategy Code

import time, json

class MidClass:
    def __init__(self, exchange_instance):
        '''
        Initialize the exchange middle layer
        
        Args:
            exchange_instance: FMZ's exchange structure
        '''
        self.init_timestamp = time.time()  # Record initialization time
        self.exchange = exchange_instance  # Save the exchange object
        self.exchange_name = self.exchange.GetName()  # Get the exchange name
        self.trading_pair = self.exchange.GetCurrency()  # Get the trading pair name (such as BTC_USDT)

    def get_precision(self):
        '''
        Get the accuracy information of the trading pair
        
        Returns:
            Returns a dictionary containing precision information, or None on failure.
        '''
        symbol_code = self.exchange.GetCurrency()
        ticker = self.exchange.GetTicker(symbol_code)  # Backtesting system needs
        exchange_info = self.exchange.GetMarkets()
        data = exchange_info.get(symbol_code)

        if not data:
            Log("Failed to obtain market information", GetLastError())
            return None

        # Get the accuracy information of the trading pair
        self.precision_info = {
            'tick_size': data['TickSize'],                  # Price accuracy
            'amount_size': data['AmountSize'],              # Quantity accuracy
            'price_precision': data['PricePrecision'],      # Price decimal places precision
            'amount_precision': data['AmountPrecision'],    # Number of decimal places of precision
            'min_qty': data['MinQty'],                      # Minimum order quantity
            'max_qty': data['MaxQty']                       # Maximum order quantity
        }

        return self.precision_info

    def get_account(self):
        '''
        Get account information
        
        Returns:
            Returns True if the information is successfully obtained, and returns False if the information is failed.
        '''

        self.balance = '---'  # Account balance
        self.amount = '---'  # Account holdings
        self.frozen_balance = '---'  # Freeze balance
        self.frozen_stocks = '---'  # Freeze positions
        self.init_balance = None
        self.init_stocks = None
        self.init_equity = None

        try:
            account_info = self.exchange.GetAccount()  # Get account information
            self.balance = account_info['Balance']  # Update account balance
            self.amount = account_info['Stocks']  # Update the holdings
            self.frozen_balance = account_info['FrozenBalance']  # Update frozen balance
            self.frozen_stocks = account_info['FrozenStocks']  # Update frozen positions
            self.equity = self.balance + self.frozen_balance + (self.amount + self.frozen_stocks) * self.last_price
            
            if not self.init_balance or not self.init_stocks or not self.init_equity:
                if _G("init_balance") and _G("init_balance") > 0 and _G("init_stocks") and _G("init_stocks") > 0:
                    self.init_balance = round(_G("init_balance"), 2)
                    self.init_stocks = round(_G("init_stocks"), 2)
                    self.init_equity = round(_G("init_equity"), 2)
                else:
                    self.init_balance = round(self.balance + self.frozen_balance, 2)
                    self.init_stocks = self.amount + self.frozen_stocks
                    self.init_equity = round(self.init_balance + (self.init_stocks * self.last_price), 2)
                    _G("init_balance", self.init_balance)
                    _G("init_stocks", self.init_stocks)
                    _G("init_equity", self.init_equity)

                    Log('Obtaining initial equity', self.init_equity)

            self.profit = self.equity - self.init_equity
            self.profitratio = round((self.equity - self.init_equity)/self.init_equity, 4) * 100

            return True
        except:
            return False  # Failed to obtain account information

    def get_ticker(self):
        '''
        Get market price information (such as bid price, ask price, highest price, lowest price, etc.)
        
        Returns:
            Returns True if the information is successfully obtained, and returns False if the information is failed.
        '''
        self.high_price = '---'  # The highest price
        self.low_price = '---'  # The lowest price
        self.sell_price = '---'  # Ask price
        self.buy_price = '---'  # Bid price
        self.last_price = '---'  # Latest transaction price
        self.volume = '---'  # Trading volume
        
        try:
            ticker_info = self.exchange.GetTicker()  # Get market price information
        
            self.high_price = ticker_info['High']  # Update highest price
            self.low_price = ticker_info['Low']  # Update lowest price
            self.sell_price = ticker_info['Sell']  # Update ask price
            self.buy_price = ticker_info['Buy']  # Update bid price
            self.last_price = ticker_info['Last']  # Update the latest transaction price
            self.volume = ticker_info['Volume']  # Update trading volume
            return True
        except:
            return False  # Failed to obtain market price information
        
    def get_depth(self):
        '''
        Get depth information (list of pending orders for buy and sell orders)
        
        Returns:
            Returns True if the information is successfully obtained, and returns False if the information is failed.
        '''
        self.ask_orders = '---'  # Ask order list
        self.bid_orders = '---'  # Bid order list
        
        try:
            depth_info = self.exchange.GetDepth()  # Get depth information
            self.ask_orders = depth_info['Asks']  # Update the sell order list
            self.bid_orders = depth_info['Bids']  # Update buy order list
            return True
        except:
            return False  # Failed to obtain depth information
        
    def get_ohlc_data(self, period=PERIOD_M5):
        '''
        Get K-line information
        
        Args:
            period: K-line period, PERIOD_M1 refers to 1 minute, PERIOD_M5 refers to 5 minutes, PERIOD_M15 refers to 15 minutes,
            PERIOD_M30 means 30 minutes, PERIOD_H1 means 1 hour, PERIOD_D1 means one day.
        '''
        self.ohlc_data = self.exchange.GetRecords(period)  # Get K-line data
        
    def create_order(self, order_type, price, amount):
        '''
        Submit an order
        
        Args:
            order_type: Order type, 'buy' refers to a buy order, 'sell' refers to a sell order
            price: Order price
            amount: Order amount 
            
        Returns:
            Order ID number, which can be used to cancel the order
        '''
        if order_type == 'buy':
            try:
                order_id = self.exchange.Buy(price, amount)  # Submit a buy order
            except:
                return False  # Buy order submission failed
            
        elif order_type == 'sell':
            try:
                order_id = self.exchange.Sell(price, amount)  # Submit a sell order
            except:
                return False  # Sell order submission failed
        
        return order_id  # Returns the order ID
    
    def get_orders(self):
        '''
        Get a list of uncompleted orders
        
        Returns:
            List of uncompleted orders
        '''
        self.open_orders = self.exchange.GetOrders()  # Get uncompleted orders
        return self.open_orders
    
    def cancel_order(self, order_id):
        '''
        Cancel a pending order
        
        Args:
            order_id: The ID number of the pending order you wish to cancel
            
        Returns:
            Returns True if the pending order is successfully cancelled, and returns False if the pending order is failed.
        '''
        return self.exchange.CancelOrder(order_id)  # Cancel the order
        
    def refresh_data(self):
        '''
        Refresh information (account, market price, depth, K-line)
        
        Returns:
            If the refresh information is successfully returned, 'refresh_data_finish!' will be returned. Otherwise, the corresponding refresh failure information prompt will be returned.
        '''

        if not self.get_ticker():  # Refresh market price information
            return 'false_get_ticker'

        if not self.get_account():  # Refresh account information
            return 'false_get_account'
        
        if not self.get_depth():  # Refresh depth information
            return 'false_get_depth'
        
        try:
            self.get_ohlc_data()  # Refresh K-line information
        except:
            return 'false_get_K_line_info'
        
        return 'refresh_data_finish!'  # Refresh successfully

class MarketMaker:
    def __init__(self, mid_class):
        '''
        Initialize market making strategy
        
        Args:
            mid_class: Exchange middle layer object
        '''
        self.exchange_mid = mid_class  # Exchange middle layer object
        self.precision_info = self.exchange_mid.get_precision()  # Get accuracy information

        self.done_amount = {'dui_qiao': 0}  # Completed transactions
        self.price_precision = self.precision_info['price_precision']  # Price precision
        self.amount_precision = self.precision_info['amount_precision']  # Trading volume precision
        
        self.traded_pairs = {'dui_qiao': []}  # Trading pairs with pending orders
        self.pending_orders = []  # Uncompleted order status
        self.pending_order_count = 0  # Number of pending orders

        self.buy_amount = 0
        self.sell_amount = 0

        self.fee = 0
        self.fee_rate = 0.08 / 100

        self.chart = {
            "__isStock": True,
            "tooltip": {"xDateFormat": "%Y-%m-%d %H:%M:%S, %A"},
            "title": {"text": "Number of pending orders"},
            "xAxis": {"type": "datetime"},
            "yAxis": {
                "title": {"text": "Number of pending orders"},
                "opposite": False
            },
            "series": [
                {"name": "Buy order quantity", "id": "Buy order quantity", "data": []},
                {"name": "Sell order quantity", "id": "Sell order quantity", "dashStyle": "shortdash", "data": []}
            ]
        }
    
    def refresh_data(self):
        '''
        Refresh data (account, market price, depth, K-line)
        '''
        self.exchange_mid.refresh_data()  # Refresh exchange data
        self.position_amount = 0 if isinstance(self.exchange_mid.amount, str) else self.exchange_mid.amount  # Holding positions
        self.available_balance = 0 if isinstance(self.exchange_mid.balance, str) else self.exchange_mid.balance  # Account balance
        Log('Check ticker', self.exchange_mid.buy_price)
        self.can_buy_amount = self.available_balance / float(self.exchange_mid.buy_price)  # Quantity available for purchase
        self.mid_price = (self.exchange_mid.sell_price + self.exchange_mid.buy_price) / 2  # Mid Price

    def make_duiqiao_dict(self, trade_amount):
        
        '''
        Generate a dictionary of self-matching orders
        
        Args:
            trade_amount: Volume per transaction
        
        Returns:
            Dictionary list of self-matching orders
        '''
        Log('3 Create a dictionary for self-matching orders')

        mid_price = self.mid_price  # Mid price

        trade_price = round(mid_price, self.price_precision)  # Accurate transaction price

        trade_dict = {
            'trade_price': trade_price,
            'amount': trade_amount
        }

        Log('Returns the market order dictionary:', trade_dict)
        return trade_dict
    
    def make_trade_by_dict(self, trade_dict):
        '''
        Execute transactions according to the transaction dictionary
        
        Args:
            trade_dict: transaction dictionary
        '''
        Log('4 Start trading by dictionary')
        self.refresh_data()  # Refresh data
        
        if trade_dict:
            Log('Current account funds: Coin balance: ', self.position_amount, 'Funds balance: ', self.can_buy_amount)
            Log('Check open positions: Coin limit: ', self.position_amount > trade_dict['amount'], 'Funding restrictions: ', self.can_buy_amount > trade_dict['amount'])
            if self.position_amount > trade_dict['amount'] and self.can_buy_amount > trade_dict['amount']:
                buy_id = self.exchange_mid.create_order('buy', trade_dict['trade_price'], trade_dict['amount'])  # Pending buy order
                sell_id = self.exchange_mid.create_order('sell', trade_dict['trade_price'], trade_dict['amount'])  # Pending sell order
                
                self.traded_pairs['dui_qiao'].append({
                    'buy_id': buy_id, 'sell_id': sell_id, 'init_time': time.time(), 'amount': trade_dict['amount']
                })
                    
                self.last_time = time.time()  # Update last transaction time
        
    def handle_pending_orders(self):
        '''
        Processing unfulfilled orders
        '''
        pending_orders = self.exchange_mid.get_orders()  # Get uncompleted orders
        if len(pending_orders) > 0:
            for order in pending_orders:
                self.exchange_mid.cancel_order(order['Id'])  # Cancel uncompleted orders

    def check_order_status(self, current_time):
        '''
        Check order status
        current_time: Polling check times
        '''
        Log('1 Start order information check')
        Log(self.traded_pairs['dui_qiao'])
        self.buy_pending = 0
        self.sell_pending = 0
        for traded_pair in self.traded_pairs['dui_qiao'].copy():
            Log('Check the order:', traded_pair['buy_id'], traded_pair['sell_id'])

            try:
                buy_order_status = self.exchange_mid.exchange.GetOrder(traded_pair['buy_id'])  # Get buy order status
                sell_order_status = self.exchange_mid.exchange.GetOrder(traded_pair['sell_id'])  # Get sell order status
            except:
                Log(traded_pair, 'cancel')
                self.exchange_mid.cancel_order(traded_pair['buy_id'])  # Cancel buy order
                self.exchange_mid.cancel_order(traded_pair['sell_id'])  # Cancel sell order
                self.traded_pairs['dui_qiao'].remove(traded_pair)  # Remove order
                return

            Log('Check the order:', traded_pair['buy_id'], buy_order_status, traded_pair['sell_id'], sell_order_status, [sell_order_status['Status'], buy_order_status['Status']])
            if [sell_order_status['Status'], buy_order_status['Status']] == [0, 0]:
                self.buy_pending += 1
                self.sell_pending += 1
                if current_time % 5 == 0:
                    Log('Check pending orders and cancel pending orders (two unfinished)', buy_order_status['Status'], sell_order_status['Status'], current_time % 5)
                    self.exchange_mid.cancel_order(traded_pair['buy_id'])  # Cancel buy order
                    self.exchange_mid.cancel_order(traded_pair['sell_id'])  # Cancel sell order
                    self.pending_order_count += 1  # The number of pending orders increases by 1
                    self.traded_pairs['dui_qiao'].remove(traded_pair)  # Remove order

            elif {sell_order_status['Status'], buy_order_status['Status']} == {1, 0}:
                if buy_order_status['Status'] == ORDER_STATE_PENDING:
                    self.buy_pending += 1
                if sell_order_status['Status'] == ORDER_STATE_PENDING:
                    self.sell_pending += 1
                if current_time % 5 == 0:
                    Log('Check pending orders and cancel pending orders (part one is not yet completed)', buy_order_status['Status'], sell_order_status['Status'])
                    self.done_amount['dui_qiao'] += traded_pair['amount']  # Update transaction volume
                    if buy_order_status['Status'] == ORDER_STATE_PENDING:
                        self.sell_amount += traded_pair['amount']
                        self.fee += sell_order_status['Amount'] * self.fee_rate * sell_order_status['Price']
                        Log('Cancel the buy order and add the unfinished buy list', traded_pair['buy_id'])
                        self.exchange_mid.cancel_order(traded_pair['buy_id'])  # Cancel buy order
                        self.pending_orders.append(['buy', buy_order_status['Status']])  # Record uncompleted orders
                        Log('Before clearing:', self.traded_pairs['dui_qiao'])
                        Log('Clear id:', traded_pair)
                        self.traded_pairs['dui_qiao'].remove(traded_pair)  # Remove order
                        Log('After clearing:', self.traded_pairs['dui_qiao'])
                    elif sell_order_status['Status'] == ORDER_STATE_PENDING:
                        self.buy_amount += traded_pair['amount']
                        self.fee += buy_order_status['Amount'] * self.fee_rate * buy_order_status['Price']
                        Log('Cancel the sell order and add it to the unfinished sell list', traded_pair['sell_id'])
                        self.exchange_mid.cancel_order(traded_pair['sell_id'])  # Cancel sell order
                        self.pending_orders.append(['sell', sell_order_status['Status']])  # Record uncompleted orders
                        Log('Before clearing:', self.traded_pairs['dui_qiao'])
                        Log('Clear id:', traded_pair)
                        self.traded_pairs['dui_qiao'].remove(traded_pair)  # Remove order
                        Log('After clearing:', self.traded_pairs['dui_qiao'])
                
            elif [sell_order_status['Status'], buy_order_status['Status']] == [1, 1]:
                Log('Both orders have been completed')
                self.buy_amount += traded_pair['amount']
                self.sell_amount += traded_pair['amount']
                self.fee += buy_order_status['Amount'] * self.fee_rate * buy_order_status['Price']
                self.fee += sell_order_status['Amount'] * self.fee_rate * sell_order_status['Price']
                Log('Completion status:', buy_order_status['Status'], sell_order_status['Status'], traded_pair['amount'])
                self.done_amount['dui_qiao'] += 2 * traded_pair['amount']  # Update transaction volume
                self.traded_pairs['dui_qiao'].remove(traded_pair)  # Remove order
            else:
                Log('Two orders are in unknown status:', buy_order_status, sell_order_status)
                Log('Unknown order status:', buy_order_status['Status'], sell_order_status['Status'])
                Log('Unknown order information:', traded_pair)
        
    def update_status(self):

        self.exchange_mid.refresh_data()

        table1 = {
            "type": "table",
            "title": "Account information",
            "cols": [
                "Initial funds", "Existing funds", "Self-matching buy amount", "Self-matching sell  amount", "Fee rate", "Total return", "Rate of return"
            ],
            "rows": [
                [   
                    self.exchange_mid.init_equity,
                    self.exchange_mid.equity,
                    round(self.buy_amount, 4),
                    round(self.sell_amount, 4),
                    round(self.fee, 2),
                    self.exchange_mid.profit,
                    str(self.exchange_mid.profitratio) + "%"
                ],
            ],
        }

        LogStatus(
            f"Initialization time: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(self.exchange_mid.init_timestamp))}\n",
            f"`{json.dumps(table1)}`\n",
            f"Last execution time: {_D()}\n"
        )

        LogProfit(round(self.exchange_mid.profit, 3), '&')

    def plot_pending(self):
        
        Log('Number of knock-on orders:', self.buy_pending, self.sell_pending)
        self.obj_chart = Chart(self.chart)
        now_time = int(time.time() * 1000)
        # Update pending order buy volume data
        self.obj_chart.add(0, [now_time, self.buy_pending])
        # Update pending order selling volume data
        self.obj_chart.add(1, [now_time, self.sell_pending])


def main():
    '''
    Main function, running market making strategy
    '''
    exchange.IO('simulate', True)
    exchange.IO("trade_super_margin")
    
    target_amount = 1  # Target transaction volume
    trade_amount = 0.01  # Volume per transaction
    trade_dict = {}  # Initialize transaction dictionary
    
    exchange_mid = MidClass(exchange)  # Initialize the exchange middle layer
    Log(exchange_mid.refresh_data())  # Refresh data
    market_maker = MarketMaker(exchange_mid)  # Initialize market making strategy

    check_times = 0
    
    while market_maker.done_amount['dui_qiao'] < target_amount:  # Loop until the target transaction volume is reached
        Log(market_maker.traded_pairs['dui_qiao'])
        market_maker.check_order_status(check_times)  # Check order status
        Sleep(1000)  # Wait 1 second
        market_maker.refresh_data()  # Refresh data
        
        if len(market_maker.traded_pairs['dui_qiao']) < 1: # Price moves, market orders are cancelled, wait until all orders are completed, and create a new order dictionary
            
            Log('2 The number of trading pairs on the market is less than 1')
            trade_dict = market_maker.make_duiqiao_dict(trade_amount)  # Generate a dictionary of pending orders
            Log('New trading dictionary', trade_dict)
        
        if trade_dict:  # Check if the dictionary is not empty
            market_maker.make_trade_by_dict(trade_dict)  # Execute a trade

        Log('Market making quantity:', market_maker.done_amount['dui_qiao'])  # Record transaction volume

        market_maker.plot_pending()
        market_maker.update_status()

        check_times += 1
        
    Log(market_maker.position_amount, market_maker.can_buy_amount)  # Record holdings and available purchase quantities
    Log('Existing orders:', exchange.GetOrders())  # Record existing orders

def onexit():
    Log("Execute the sweep function")

    _G("init_balance", None)
    _G("init_stocks", None)
    _G("init_equity", None)

From: An Overview of Market Making Strategies in Crypto: Architecture Design and FMZ Implementation of the Self-Matching Trading Strategy

Overview

The Multi-Indicator Breakout Trend Following Strategy is a quantitative trading approach based on the classic Turtle Trading system, designed to capture strong market trends through multi-period breakout signals. The core of this strategy lies in utilizing price breakouts across different time periods as entry and exit signals, while incorporating ATR (Average True Range) for risk control and position sizing. This strategy can function both as an indicator to identify market breakout signals and as a complete automated trading system. Its strength lies in systematically capturing trending opportunities while enhancing capital efficiency through strict risk management.

Strategy Principles

The fundamental principle of this strategy is to identify potential trend movements by recognizing when prices break through historical highs or lows. The specific implementation logic is as follows:

1. Entry Mechanism: The strategy uses the highest and lowest prices over the N1 period (default 20 periods) as breakout references. When the price breaks above the highest price of the previous N1 periods, a long entry signal is generated; when the price breaks below the lowest price of the previous N1 periods, a short entry signal is generated.
2. Exit Mechanism: The strategy employs a dual exit mechanism:

• Stop Loss Exit: Dynamic stop loss levels are set based on ATR, defaulting to the entry price minus (for longs) or plus (for shorts) 2 times the ATR value.
• Trend Reversal Exit: When the price falls below the lowest price of the N2 period (default 10 periods), long positions are closed; when the price breaks above the highest price of the N2 period, short positions are closed.

3. Position Management: The strategy calculates trading unit size based on volatility (ATR) and risk ratio, ensuring that each trade’s risk is controlled at a fixed percentage (default 1%) of account capital. The calculation formula is:

• Trading Units = Risk Amount / (ATR * Value Per Point)

where Risk Amount equals the initial capital multiplied by the risk percentage.

4. Trade Execution: The strategy only executes new entry signals when there are no existing positions, avoiding repeated entries, while recording the entry price for calculating stop loss positions.

Strategy Advantages

1. Trend Following Capability: The strategy is focused on capturing major trends by identifying potential trend starting points through breakout signals, effectively utilizing trending market movements.
2. Dynamic Risk Control: Stop loss positions are calculated using ATR, dynamically adjusting the stop loss distance based on actual market volatility. This approach avoids both the frequent stops caused by fixed stops being too close and the excessive losses from stops being too far.
3. Adaptive Position Sizing: Position size is dynamically adjusted based on market volatility and account risk ratio, automatically reducing positions in highly volatile markets and appropriately increasing positions in low volatility markets, achieving balanced control of risk exposure.
4. Parameter Adjustability: The strategy provides interfaces for adjusting multiple key parameters (N1, N2, ATR period, risk ratio, etc.), allowing users to optimize based on different market environments and personal risk preferences.
5. Systematic Trading: Fully systematized trading rules eliminate emotional interference, strictly following preset entry, exit, and capital management rules, improving trading discipline.

Strategy Risks

1. Poor Performance in Ranging Markets: As a trend following strategy, it tends to generate frequent false breakout signals in sideways, ranging markets, leading to consecutive stop losses. A solution could be to add volatility filtering conditions, considering entry only when volatility exceeds a certain threshold.
2. Slippage and Commission Impact: In high-frequency trading or markets with insufficient liquidity, slippage and commissions may significantly affect strategy performance. This issue can be mitigated by reducing trading frequency or adding signal confirmation mechanisms.
3. Parameter Sensitivity: Strategy performance is relatively sensitive to N1 and N2 parameter settings, with optimal parameters potentially varying greatly across different markets and timeframes. It is recommended to find robust parameter combinations through historical backtesting, avoiding curve-fitting from excessive optimization.
4. Gap Risk: In price gaps caused by sudden major events, stop loss orders may not execute at the expected price, causing losses beyond expectations. Consider adding maximum loss limits or introducing volatility adjustment factors.
5. Capital Management Risk: Despite the strategy’s risk control mechanisms, consecutive stop losses in extreme market conditions may still lead to significant drawdowns in the capital curve. It is advisable to set limits on the maximum number of consecutive losses or introduce overall risk exposure controls.

Optimization Directions

1. Multi-Timeframe Confirmation: Introduce longer period trend confirmation mechanisms, considering entry only when trends across multiple timeframes are consistent, improving signal quality. For example, add conditions to check whether the daily trend direction is consistent with the current trading period’s trend direction.
2. Volatility Filtering: Introduce volatility filtering conditions, executing trade signals only when market volatility is within a reasonable range, avoiding entry in overly calm or excessively volatile markets. Relative ATR values (such as ATR/price ratio) can be used as filtering indicators.
3. Signal Confirmation Mechanism: Add breakout confirmation mechanisms, such as requiring the price to maintain a certain time or amplitude after breakout before confirming signal validity, reducing losses from false breakouts.
4. Dynamic Parameter Adjustment: Dynamically adjust N1 and N2 parameters based on market conditions, using different parameter combinations in different volatility environments, improving the strategy’s adaptability to market environments.
5. Incorporate Trend Strength Assessment: Combine trend strength indicators (such as ADX, linear regression slope, etc.) to evaluate current trend strength, considering entry only when trend strength reaches a certain threshold, improving the accuracy of trend capture.
6. Optimize Stop Loss Mechanism: Consider introducing trailing stops or support/resistance-based stop methods, giving trends more room to develop while maintaining risk control functionality.

Summary

The Multi-Indicator Breakout Trend Following Strategy is a systematic trading approach that combines classic Turtle Trading concepts with modern risk management techniques. By determining trend direction through multi-period price breakouts and implementing dynamic stop losses and position control with ATR, this strategy can effectively capture significant trending opportunities in the market.

The core advantages of this strategy lie in its systematic trading rules and strict risk control, avoiding emotional interference while providing high flexibility through parameter adjustments. However, as a trend following strategy, its performance may be poor in ranging markets, requiring users to understand its applicable scenarios and perform appropriate parameter optimization.

By introducing optimization directions such as multi-timeframe confirmation, volatility filtering, and signal confirmation mechanisms, this strategy has the potential to further improve signal quality and stability, adapting to more diverse market environments. Ultimately, the Multi-Indicator Breakout Trend Following Strategy provides traders with a reliable, systematic method to capture market trends while controlling risk, achieving long-term stable trading performance.

Strategy source code

/*backtest
start: 2024-07-03 00:00:00
end: 2025-07-01 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"DOGE_USDT"}]
*/

//@version=5
strategy("Turtle Trading Strategy (Simplified)", overlay=true, initial_capital=10000, default_qty_type=strategy.cash, default_qty_value=1000, commission_type=strategy.commission.cash_per_order, commission_value=1)

// --- Strategy Inputs ---
n1_entry_period = input.int(20, title="Entry Lookback Period (N1)", minval=1)
n2_exit_period = input.int(10, title="Exit Lookback Period (N2)", minval=1)
atr_period = input.int(20, title="ATR Period", minval=1)
atr_multiplier = input.float(2.0, title="ATR Stop Multiplier", minval=0.1)
risk_per_trade_percent = input.float(1.0, title="Risk Per Trade (%)", minval=0.1, maxval=10.0)

// --- Calculate Channels ---
highest_high_n1 = ta.highest(high, n1_entry_period)
lowest_low_n1 = ta.lowest(low, n1_entry_period)

highest_high_n2 = ta.highest(high, n2_exit_period)
lowest_low_n2 = ta.lowest(low, n2_exit_period)

// --- Calculate ATR (Average True Range) ---
atr_value = ta.atr(atr_period)

// --- Position Sizing (Simplified) ---
// This aims to calculate units based on a fixed percentage risk per trade.
// 1 Unit = 1 ATR worth of movement. Risk 1% of equity per trade.
risk_amount = strategy.initial_capital * (risk_per_trade_percent / 100)
dollar_per_point = syminfo.mintick // Or your instrument's specific dollar per point value
unit_size = atr_value * dollar_per_point > 0 ? math.round(risk_amount / (atr_value * dollar_per_point)) : 0

// Ensure unit_size is at least 1 if risk allows, and cap it for realism
if unit_size == 0 and risk_amount > 0
    unit_size := 1 // Minimum 1 unit if risk allows any trade
if unit_size > 10000 // Cap unit size to prevent excessively large positions in backtesting
    unit_size := 10000

// --- Entry Logic ---
long_condition = ta.crossover(close, highest_high_n1[1]) // Break above previous N1 high
short_condition = ta.crossunder(close, lowest_low_n1[1]) // Break below previous N1 low

// Variables to store entry information only for the *current* bar
var float current_entry_price = na
var int current_entry_type = 0 // 1 for long, -1 for short, 0 for no entry

if long_condition and strategy.opentrades == 0 // Only enter if no open positions
    strategy.entry("Long", strategy.long, qty=unit_size, comment="Turtle Long Entry")
    // Store entry details for the current bar
    current_entry_price := close // Or strategy.opentrades[0].entry_price if you prefer but close on entry bar is often same
    current_entry_type := 1

if short_condition and strategy.opentrades == 0 // Only enter if no open positions
    strategy.entry("Short", strategy.short, qty=unit_size, comment="Turtle Short Entry")
    // Store entry details for the current bar
    current_entry_price := close // Or strategy.opentrades[0].entry_price
    current_entry_type := -1

// --- Exit Logic ---

// Declare persistent variables to store stop prices
var float long_stop_price = na
var float short_stop_price = na

// Calculate and store stop price on the bar *after* an entry
if current_entry_type[1] == 1 // If a long entry occurred on the previous bar
    long_stop_price := current_entry_price[1] - (atr_value[1] * atr_multiplier) // Use values from previous bar
    short_stop_price := na // Reset short stop

if current_entry_type[1] == -1 // If a short entry occurred on the previous bar
    short_stop_price := current_entry_price[1] + (atr_value[1] * atr_multiplier) // Use values from previous bar
    long_stop_price := na // Reset long stop

// Stop Loss for Long Positions
if strategy.position_size > 0 // We have a long position
    strategy.exit("Long Exit SL", from_entry="Long", stop=long_stop_price, comment="Long Stop Loss")

// Stop Loss for Short Positions
if strategy.position_size < 0 // We have a short position
    strategy.exit("Short Exit SL", from_entry="Short", stop=short_stop_price, comment="Short Stop Loss")

// N2 Exit for Long Positions
if strategy.position_size > 0 and ta.crossunder(close, lowest_low_n2[1])
    strategy.close("Long", comment="Turtle Long N2 Exit")

// N2 Exit for Short Positions
if strategy.position_size < 0 and ta.crossover(close, highest_high_n2[1])
    strategy.close("Short", comment="Turtle Short N2 Exit")

// --- Plotting for Visualization ---
plot(highest_high_n1, "N1 High", color=color.green, linewidth=2, style=plot.style_linebr)
plot(lowest_low_n1, "N1 Low", color=color.red, linewidth=2, style=plot.style_linebr)
plot(highest_high_n2, "N2 High (Exit)", color=color.blue, linewidth=1, style=plot.style_linebr)
plot(lowest_low_n2, "N2 Low (Exit)", color=color.orange, linewidth=1, style=plot.style_linebr)

Strategy parameters

The original address: Multi-Indicator Breakout Trend Following Strategy

1. Overview

The RAHA Quantitative Dynamic Weight Moving Average Short-Term Trend Strategy is a short-term trading system based on the Roni’s Adjusted Hybrid Average (RAHA) indicator. Developed by Aharon Roni Pesach, this strategy’s core is a special moving average calculation method that assigns different weights to outliers, giving extreme values (particularly high or low) a lower weight. RAHA calculation is based on the standard deviation and average of the data, resulting in a more sensitive yet stable moving average that doesn’t ignore outliers but considers them proportionally. The strategy identifies negative trends and enters when clear technical conditions are met, such as a downward slope of RAHA 40, RAHA 10 crossing below RAHA 20, and the absence of a sequence of 3 red candles. Entry is also made in the exceptional case of a red candle above the Bollinger Band. Position size is determined by 1% of capital divided by the stop loss distance, and exits are triggered by a stop above the high or additional conditions below the profit target (TP).

2. Strategy Principles

The core of the RAHA Quantitative Dynamic Weight Moving Average Short-Term Trend Strategy lies in its unique moving average calculation method. While traditional moving averages give each price point the same weight, RAHA dynamically adjusts weights based on how much price points deviate from the mean. The implementation follows these steps:

1. First, calculate standard SMA and standard deviation
2. For each price point, calculate weight based on its deviation from the mean: weight = 1 / (1 + sensitivity * |price-mean| / standard deviation)
3. Use these weights to calculate the weighted average

The strategy uses RAHA moving averages of different periods (5, 10, 20, and 40) to capture market trends. Entry signals are based on the following conditions:

• RAHA 40 sloping downward (current value less than previous)
• RAHA 10 crossing under or positioned below RAHA 20
• RAHA 5 sloping downward
• No sequence of 3 consecutive red candles
• Or the special case: price completely above the Bollinger Band with a bearish candle

After entry, the strategy manages positions using these rules:

• Stop loss set at the highest price at entry
• Profit target (TP) set at entry price minus 3 times the stop loss distance
• Position size calculated as 1% of capital divided by stop loss percentage
• If 3 consecutive red candles appear, stop loss is adjusted to the high of the previous candle
• Exit conditions include: price crossing above RAHA 10, RAHA 10 crossing above RAHA 20, or price breaking through stop loss

3. Strategy Advantages

The RAHA Quantitative Dynamic Weight Moving Average Short-Term Trend Strategy offers several advantages:

1. Dynamic Weight Balance: The RAHA indicator creates a more sensitive yet stable moving average system by giving extreme values lower weights. This helps reduce false signals while maintaining sensitivity to genuine market changes.
2. Multi-level Trend Confirmation: The strategy uses RAHA indicators of multiple periods (5, 10, 20, and 40) for trend confirmation, and this multi-verification mechanism helps lower the false signal rate.
3. Risk Management Adaptation: Position size automatically adjusts based on stop loss distance, ensuring each trade controls risk at 1% of capital. This mechanism allows the strategy to adapt to different volatility environments.
4. Dynamic Stop Loss Adjustment: The strategy adjusts stop loss based on market conditions during trading, such as raising the stop loss position when 3 consecutive red candles appear, helping to lock in profits and reduce drawdowns.
5. Flexible Exit Mechanism: The strategy combines multiple exit mechanisms including technical indicator reversals and stop loss triggers, providing flexibility that helps optimize exit timing under different market conditions.
6. Exceptional Situation Capture: The strategy pays special attention to sell signals above the Bollinger Band, helping to capture retracement opportunities after excessive market expansion, which often bring significant returns.
7. Clear Visualization: The strategy marks entry and exit points on charts, allowing traders to intuitively understand trading logic, facilitating subsequent analysis and improvement.

4. Strategy Risks

Despite its many advantages, the RAHA Quantitative Dynamic Weight Moving Average Short-Term Trend Strategy faces several risks:

1. Sudden Trend Reversal Risk: The strategy primarily relies on trend continuation and may lead to significant losses in cases of sudden trend reversals. The solution is to consider adding more sensitive reversal indicators or market sentiment indicators as supplements.
2. Parameter Sensitivity: The sensitivity parameter in RAHA calculation (currently set at 1.5) significantly impacts strategy performance. Different markets or periods may require different parameter settings. Parameter optimization and sensitivity analysis are recommended.
3. Consecutive Stop Loss Risk: In high-volatility or sideways markets, the strategy may trigger consecutive stop losses, causing capital curve decline. Consider adding market environment filters to pause trading under unfavorable market conditions.
4. Calculation Complexity: RAHA indicator calculation is relatively complex and requires loop processing of data, which may cause slight delays in real-time trading. Calculation efficiency should be evaluated in high-frequency trading environments.
5. Position Risk: Although the strategy limits risk per trade, it doesn’t consider overall position risk. Total risk may exceed expectations when multiple trades are open simultaneously. Adding overall risk control mechanisms is recommended.
6. Bollinger Band Anomaly Entry Risk: Entries based on positions above the Bollinger Band may enter too early in extreme market conditions. Consider adding additional filtering conditions, such as volume confirmation or auxiliary judgment from other technical indicators.
7. Fixed Multiple Take Profit Risk: The strategy uses a fixed 3x stop loss distance as profit target, which may not be flexible enough in different market environments. Consider dynamically adjusting profit targets based on market volatility or support/resistance levels.

5. Strategy Optimization Directions

Based on in-depth analysis of the strategy, here are possible optimization directions:

1. Adaptive Sensitivity Parameter: The strategy currently uses a fixed sensitivity parameter (1.5). Consider automatically adjusting sensitivity based on market volatility, using higher values in low-volatility markets to increase sensitivity, and lower values in high-volatility markets to improve stability.
2. Add Market Environment Filter: Introduce market environment judgment mechanisms, such as trend strength indicators (ADX) or volatility indicators (ATR), to reduce or avoid trading in market environments unsuitable for short-term strategies.
3. Optimize Exit Mechanism: Current strategy exits mainly based on technical indicator reversals and stop losses. Consider adding more flexible partial profit-locking mechanisms, such as moving stop loss to breakeven when reaching 1:1 risk-reward ratio, or setting multiple profit targets based on support/resistance levels.
4. Incorporate Volume Confirmation: Adding volume confirmation when entry signals generate can reduce false breakouts and signals. Volume confirmation is particularly important for special entry conditions above the Bollinger Band.
5. Time Filter: Analyzing strategy performance during different time periods may reveal that the strategy performs better during certain sessions (such as market opening or before closing). Adding time filters can improve overall strategy efficiency.
6. Add Fundamental Filters: For applications to stocks or certain commodities, consider adding fundamental filtering conditions, such as excluding periods before important data releases or periods affected by specific seasonal factors.
7. Machine Learning Optimization: Use machine learning methods to optimize strategy parameter combinations or enhance entry and exit decisions through historical pattern recognition. This can be achieved through deep analysis of historical data to discover patterns that traditional technical analysis might overlook.
8. Risk Balancing Mechanism: Add dynamic risk adjustment mechanisms based on account equity and open positions to ensure total risk doesn’t exceed preset limits, especially in cases of consecutive entries.

6. Conclusion

The RAHA Quantitative Dynamic Weight Moving Average Short-Term Trend Strategy is an innovative quantitative trading system. Its core lies in using a unique moving average calculation method to process price data, assigning different weights to outliers, thereby creating a more sensitive yet stable moving average indicator. The strategy forms a complete trading decision system through collaborative judgment of multi-period RAHA indicators combined with auxiliary indicators like Bollinger Bands.

The strategy’s greatest advantage lies in its adaptive risk management and dynamic stop loss adjustment mechanisms, allowing it to maintain stable risk control in different market environments. Meanwhile, multi-level trend confirmation and flexible exit mechanisms also enhance the strategy’s robustness.

However, the strategy also faces challenges such as parameter sensitivity, trend reversal risk, and consecutive stop loss risk. Performance can be further improved through introducing adaptive parameters, market environment filters, optimizing exit mechanisms, and adding volume confirmation.

Overall, the RAHA Quantitative Dynamic Weight Moving Average Short-Term Trend Strategy demonstrates the potential of combining innovative technical indicators with traditional trading concepts. Through continuous optimization and adaptation to different market environments, this strategy has the potential to become a powerful tool for short-term traders, helping them achieve more stable returns in the market.

Strategy source code

/*backtest
start: 2015-02-22 00:00:00
end: 2025-07-02 10:18:36
period: 1d
basePeriod: 1d
*/

//@version=5
strategy("RAHA Strategy - Short", overlay=true, default_qty_type=strategy.fixed, default_qty_value=0)

// === RAHA Weighted Average Function ===
raha_weighted(src, len, sensitivity) =>
    mean = ta.sma(src, len)
    dev = ta.stdev(src, len)
    sumWeighted = 0.0
    sumWeights = 0.0
    for i = 0 to len - 1
        val = nz(src[i])
        weight = 1 / (1 + sensitivity * math.abs(val - mean) / dev)
        sumWeighted += val * weight
        sumWeights += weight
    sumWeights > 0 ? sumWeighted / sumWeights : na

// === RAHA Calculations ===
sensitivity = 1.5
raha5 = raha_weighted(close, 5, sensitivity)
raha10 = raha_weighted(close, 10, sensitivity)
raha20 = raha_weighted(close, 20, sensitivity)
raha40 = raha_weighted(close, 40, sensitivity)

// === Upper Bollinger Band on RAHA 20 ===
bbDev = ta.stdev(raha20, 20)
bbUpper = raha20 + 2.0 * bbDev

// === Short Entry Conditions ===
raha40SlopeDown = raha40 < raha40[1]
crossoverDownRAHA = ta.crossunder(raha10, raha20) or raha10 < raha20
raha5SlopeDown = raha5 < raha5[1]
threeRedBars = close < open and close[1] < open[1] and close[2] < open[2]
bearishOutsideBollinger = high > bbUpper and low > bbUpper and close < open

// === Position Management Variables ===
var float entryHigh = na
var float entryPrice = na
var float stop = na
var float tp = na
var int redCount = 0
var int lastEntryBar = na

// === Enter Only When No Open Trade ===
canEnter = strategy.position_size == 0 and ((raha40SlopeDown and crossoverDownRAHA and raha5SlopeDown) or bearishOutsideBollinger)
canEnterFiltered = canEnter and (na(lastEntryBar) or strategy.opentrades == 0 or bar_index > lastEntryBar)

// === Enter Position ===
if canEnterFiltered
    entryHigh := high
    entryPrice := close
    stop := entryHigh
    if stop > entryPrice
        tp := entryPrice - 3 * (stop - entryPrice)
        capital = strategy.equity
        stopPct = math.max(0.0001, (stop - entryPrice) / entryPrice)
        positionValue = 0.01 * capital / stopPct
        qty = positionValue / entryPrice
        if qty > 0 and qty < 1e12
            strategy.entry("RAHA Short", strategy.short, qty=qty)
            redCount := 0
            lastEntryBar := bar_index

// === Manage Open Position ===
if strategy.position_size < 0
    redCount := close < open ? redCount + 1 : 0
    if redCount >= 3
        stop := high[1]
        redCount := 0

// === Exit Conditions ===
exit1 = close > raha10 and open < raha10
exit2 = ta.crossover(raha10, raha20)
exit3 = close > stop

if low <= tp and (exit1 or exit2)
    strategy.close("RAHA Short")

if exit3
    strategy.close("RAHA Short")

// === Plot Entry and Exit Arrows ===
inPosition = strategy.position_size < 0
exitCondition = inPosition and ((low <= tp and (exit1 or exit2)) or exit3)

plotshape(canEnterFiltered, title="Short Entry", location=location.abovebar, style=shape.labeldown, text="Short", color=color.red, textcolor=color.white)
plotshape(exitCondition, title="Close Position", location=location.belowbar, style=shape.labelup, text="Close", color=color.green, textcolor=color.white)

The original address: RAHA Quantitative Dynamic Weight Moving Average Short-Term Trend Strategy

Overview

The OBV Oscillator Crossover Strategy with No Same-Bar Exit Mechanism is a quantitative trading system based on the On Balance Volume (OBV) indicator. This strategy monitors the difference between the OBV indicator and its EMA to capture key moments of market momentum shifts. The core of the strategy lies in identifying crossover signals between the OBV oscillator and the zero line, while implementing a mechanism to prevent same-bar exits, avoiding premature exits caused by rapid price fluctuations and effectively improving trade execution quality. The strategy also integrates comprehensive risk management mechanisms, including fixed percentage stop-loss, target profit, and trailing stops, enabling effective risk control while maintaining profit potential.

Strategy Principles

This strategy generates trading signals based on the oscillator formed by the difference between the On Balance Volume (OBV) indicator and its Exponential Moving Average (EMA). The core calculation process is as follows:

1. First, calculate the standard OBV indicator: when price rises, add the day’s volume to the cumulative value; when price falls, subtract the day’s volume from the cumulative value; when price remains unchanged, the cumulative value stays the same.
2. Calculate the Exponential Moving Average (EMA) of OBV, with a default period of 20.
3. Calculate the OBV Oscillator, which is the difference between OBV and its EMA (obv_osc = obv — obv_ema).
4. Generate trading signals:

• Long signal: when the OBV oscillator crosses above the zero line from below and there is currently no position
• Short signal: when the OBV oscillator crosses below the zero line from above and there is currently no position

A key innovation of the strategy is the implementation of a “No Same-Bar Exit Mechanism,” which records the bar index of entry and ensures that exits are only allowed after subsequent new bars are formed. This mechanism effectively prevents premature triggering of stop-loss or take-profit due to rapid price fluctuations within the same time unit, improving the strategy’s stability.

In terms of risk management, the strategy sets up a triple protection mechanism:

• Fixed percentage stop-loss (default 1%)
• Target profit take-profit (default 2%)
• Trailing stop (default 0.5%), which provides dynamic protection of profits

Strategy Advantages

1. Precise Momentum Capture: By identifying crossovers between the OBV oscillator and the zero line, the strategy can detect inflection points in market momentum, allowing entry during the early stages of trends and capturing most of the trend movements.
2. Volume Confirmation: The OBV indicator itself integrates price changes and volume information, providing volume confirmation for trading signals and reducing the risk of false breakouts.
3. No Same-Bar Exit Protection: The mechanism that records entry bar indices and prohibits same-bar exits effectively avoids premature stops caused by short-term fluctuations, improving trading stability and completion rates.
4. Comprehensive Risk Management System: The strategy integrates triple protection mechanisms of fixed stop-loss, target profit, and trailing stops, effectively controlling risk exposure while securing profits.
5. High Adaptability: Through parameterized design (OBV EMA period, stop-loss percentage, target profit percentage, trailing stop percentage), the strategy can be flexibly adjusted according to different market environments and trading instruments.
6. Automated Execution and Alerts: The strategy has built-in JSON format alert strings, which can seamlessly connect to automated trading systems for fully automated trading.
7. Visualization Aids: The strategy plots the OBV oscillator and trade labels on the chart, providing intuitive visual feedback for strategy backtesting and real-time monitoring.

Strategy Risks

1. Overtrading in Ranging Markets: In sideways markets, the OBV oscillator may frequently cross the zero line, resulting in excessive trading signals and unnecessary transaction costs. The solution is to add additional filtering conditions, such as only enabling the strategy in clear trend environments or adding signal confirmation mechanisms.
2. Parameter Sensitivity: The period setting of OBV EMA has a significant impact on strategy performance, and different market environments may require different parameter settings. It is recommended to find optimal parameter combinations for specific market environments through backtest optimization.
3. Slippage and Execution Risk: The strategy uses market orders to execute trades, which may face significant slippage in markets with insufficient liquidity. The solution is to consider using limit orders or trading during periods of sufficient liquidity.
4. Balance of Stop-Loss Settings: Fixed percentage stop-losses may be too tight in high-volatility markets or too loose in low-volatility markets. It is recommended to dynamically adjust the stop-loss percentage based on the historical volatility of the underlying asset.
5. Signal Dependency: The strategy relies entirely on crossover signals from the OBV oscillator, which may lag in certain market conditions. Consider adding other technical indicators as confirmation to improve signal quality.
6. Disregard for Fundamental Factors: As a pure technical analysis strategy, it does not consider fundamental factors that may affect the market, such as economic data or policy changes. Consider reducing positions or pausing the strategy before major fundamental events.

Strategy Optimization Directions

1. Add Trend Filters: Introduce ADX or other trend strength indicators to execute trades only in confirmed trend environments, avoiding frequent trading in oscillating markets. This can significantly improve the strategy’s win rate and risk-reward ratio.
2. Dynamic Parameter Adjustment: Automatically adjust OBV EMA periods, stop-loss, and target profit percentages based on market volatility. For example, use longer EMA periods and wider stop-loss ranges in high-volatility environments, and opposite settings in low-volatility environments.
3. Multi-Timeframe Confirmation: Add analysis of higher timeframes and execute trades only when signals across multiple timeframes are consistent, improving signal quality and reliability.
4. Volume Quality Filtering: Add quality assessment of volume, for example, confirming signals only when volume is higher than the N-day average volume, avoiding false breakouts in low-volume environments.
5. Optimize Entry Timing: After the OBV oscillator crosses the zero line, wait for price pullbacks to key support/resistance levels before entering, improving entry price advantage.
6. Incorporate Machine Learning Algorithms: Use machine learning techniques to automatically identify optimal trading parameters for the OBV oscillator in different market environments, achieving adaptive optimization of the strategy.
7. Add Time Filters: Avoid trading during high-volatility periods at market open and close, or pause the strategy before and after important economic data releases to reduce unpredictable risks.

Conclusion

The OBV Oscillator Crossover Strategy is a quantitative trading system that combines classic technical analysis indicators with modern risk management techniques. By capturing crossover signals between the OBV oscillator and the zero line, while implementing a no same-bar exit protection mechanism, the strategy can identify changes in market momentum while effectively controlling trading risks.

The core advantage of the strategy lies in incorporating volume factors into the trading decision process, ensuring signals are effectively confirmed by volume, while improving trade execution quality through the no same-bar exit mechanism. The comprehensive risk management system and parameterized design give the strategy high adaptability and stability.

Although there are potential risks such as overtrading in ranging markets and parameter sensitivity, there is still significant room for performance improvement through optimization directions such as adding trend filters, dynamic parameter adjustment, and multi-timeframe confirmation. Particularly, introducing machine learning techniques for adaptive parameter optimization is expected to further improve the strategy’s performance in different market environments.

Overall, the OBV Oscillator Crossover Strategy provides an effective framework for quantitative trading based on volume analysis. With reasonable parameter settings and continuous optimization, it has the potential to achieve stable risk-adjusted returns in various market environments.

Strategy source code

/*backtest
start: 2024-07-04 00:00:00
end: 2025-07-02 08:00:00
period: 4h
basePeriod: 4h
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

//@version=5
strategy("OBV Osc (No Same-Bar Exit)", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

// === JSON ALERT STRINGS ===
callBuyJSON  = 'ANSHUL \n[{"TT":"BUY","E":"NFO","TS":"NIFTY2570326200CE","Q":"75","OT":"MARKET","P":"NRML","VL":"DAY","AT":"DHANHQ"}]'
callExtJSON  = 'ANSHUL \n[{"TT":"SELL","E":"NFO","TS":"NIFTY2570326200CE","Q":"75","OT":"MARKET","P":"NRML","VL":"DAY","AT":"DHANHQ"}]'
putBuyJSON   = 'ANSHUL \n[{"TT":"BUY","E":"NFO","TS":"NIFTY2570325000PE","Q":"75","OT":"MARKET","P":"NRML","VL":"DAY","AT":"DHANHQ"}]'
putExtJSON   = 'ANSHUL \n[{"TT":"SELL","E":"NFO","TS":"NIFTY2570325000PE","Q":"75","OT":"MARKET","P":"NRML","VL":"DAY","AT":"DHANHQ"}]'

// === INPUTS ===
length     = input.int(20, title="OBV EMA Length")
sl_pct     = input.float(1.0, title="Stop Loss %", minval=0.1)
tp_pct     = input.float(2.0, title="Take Profit %", minval=0.1)
trail_pct  = input.float(0.5, title="Trailing Stop %", minval=0.1)

// === OBV OSCILLATOR CALC ===
src = close
obv = ta.cum(ta.change(src) > 0 ? volume : ta.change(src) < 0 ? -volume : 0)
obv_ema = ta.ema(obv, length)
obv_osc = obv - obv_ema

// === SIGNALS ===
longCondition  = ta.crossover(obv_osc, 0) and strategy.position_size == 0
shortCondition = ta.crossunder(obv_osc, 0) and strategy.position_size == 0

// === RISK SETTINGS ===
longStop     = close * (1 - sl_pct / 100)
longTarget   = close * (1 + tp_pct / 100)
shortStop    = close * (1 + sl_pct / 100)
shortTarget  = close * (1 - tp_pct / 100)
trailPoints  = close * trail_pct / 100

// === ENTRY BAR TRACKING TO PREVENT SAME-BAR EXIT ===
var int entryBar = na

// === STRATEGY ENTRY ===
if longCondition
    strategy.entry("Long", strategy.long)
    entryBar := bar_index
    alert(callBuyJSON, alert.freq_all)
    label.new(bar_index, low, text="BUY CALL", style=label.style_label_up, color=color.new(color.green, 85), textcolor=color.black)

if shortCondition
    strategy.entry("Short", strategy.short)
    entryBar := bar_index
    alert(putBuyJSON, alert.freq_all)
    label.new(bar_index, high, text="BUY PUT", style=label.style_label_down, color=color.new(color.red, 85), textcolor=color.black)

// === EXIT ONLY IF BAR_INDEX > entryBar (NO SAME-BAR EXIT) ===
canExitLong  = strategy.position_size > 0  and bar_index > entryBar
canExitShort = strategy.position_size < 0  and bar_index > entryBar

if canExitLong
    strategy.exit("Exit Long", from_entry="Long", stop=longStop, limit=longTarget, trail_points=trailPoints, trail_offset=trailPoints)

if canExitShort
    strategy.exit("Exit Short", from_entry="Short", stop=shortStop, limit=shortTarget, trail_points=trailPoints, trail_offset=trailPoints)

// === TRACK ENTRY/EXIT FOR ALERTS ===
posNow  = strategy.position_size
posPrev = nz(strategy.position_size[1])

longExit  = posPrev == 1  and posNow == 0
shortExit = posPrev == -1 and posNow == 0

if longExit
    alert(callExtJSON, alert.freq_all)
    label.new(bar_index, high, text="EXIT CALL", style=label.style_label_down, color=color.new(color.blue, 85), textcolor=color.black)

if shortExit
    alert(putExtJSON, alert.freq_all)
    label.new(bar_index, low, text="EXIT PUT", style=label.style_label_up, color=color.new(color.orange, 85), textcolor=color.black)

// === PLOTS ===
plot(obv_osc, title="OBV Oscillator", color=obv_osc > 0 ? color.green : color.red, linewidth=2)
hline(0, color=color.gray)

Strategy parameters

The original address: OBV Oscillator Crossover Strategy with No Same-Bar Exit Mechanism

Overview

The Multi-Timeframe Liquidity Trap Reversal Quantitative Strategy is a lightweight, precision-focused tool designed to identify institutional and market maker liquidity manipulation tactics. This strategy leverages price action analysis to detect key liquidity sweeps and subsequent reversals, effectively capturing market turning points. The core concept revolves around identifying sweeps of prior swing highs/lows and confirming trap reversals when price closes back inside the swept range — a signature move of smart money designed to trap retail breakout traders. The strategy doesn’t rely on complex indicators but instead directly analyzes raw price action and market intent, making it particularly suitable for disciplined traders seeking to trade around liquidity events.

Strategy Principles

This strategy is built on market structure and liquidity principles, relying on several key components:

1. Liquidity Sweep Detection: Utilizes a custom lookback period (swingLookback = 10) to determine previous price highs and lows. The strategy calculates the highest high (prevHigh) and lowest low (prevLow) over the past 10 periods, then identifies liquidity sweep events (sweepHigh and sweepLow) by comparing current price action against these levels.
2. Trap Confirmation Mechanism: When price retraces back into the previous range after breaking out, the strategy considers this a market maker trap. Specifically, for a short trap (trapShort), price must first break above the previous high and then close below it; for a long trap (trapLong), price must first break below the previous low and then close above it.
3. Session Filtering: The strategy offers a New York session filter option (useSessionFilter), enabled by default. The session is defined as UTC hours 13 to 20, which typically covers the most liquid market periods, helping to avoid false signals during low liquidity times.
4. Trade Execution Logic: When long conditions (longCondition) are met, the strategy enters a long position; when short conditions (shortCondition) are met, it enters a short position. All trades use 5% of account equity as position size.

The core philosophy is to mirror market maker operational logic, avoid false breakouts, and establish trades with real conviction around liquidity events. By identifying when price breaks key levels and quickly retraces, the strategy can capture market reversals, particularly targeting price movements that are often misinterpreted by retail traders as trend confirmations.

Strategy Advantages

1. Simplicity and Clarity: The strategy doesn’t rely on complex technical indicators but is directly based on price action and market structure, making it easy to understand and implement. This simplicity reduces the risk of overfitting and enhances strategy robustness.
2. Institution-Based Approach: The strategy mimics the operational logic of institutions and market makers, focusing on liquidity traps — a proven market pattern. By understanding and identifying the behavior of large market participants, retail investors can avoid becoming victims of these traps.
3. Precise Trading Conditions: The strategy provides clear entry conditions, reducing the need for subjective judgment. Price must first break key levels and then retrace, a double confirmation mechanism that significantly reduces false signals.
4. Session Optimization: Through New York session filtering, the strategy focuses on trading during the most active and liquid market periods, improving signal quality and execution efficiency.
5. Position Management Integration: The strategy defaults to using a fixed percentage (5%) of account equity as position size, incorporating a basic risk management mechanism that prevents excessive leverage-induced losses.
6. Adaptability: Through adjustable parameters such as swing lookback period (swingLookback) and trap confirmation period (retestBars), the strategy can adapt to different market conditions and trading instruments.
7. Visualization Support: The strategy includes clear graphical indications, plotting key price levels and trade signals, helping traders better understand market dynamics and strategy logic.

Strategy Risks

1. False Breakout Risk: While the strategy is designed to identify false breakouts, the market may experience genuine breakouts after multiple false ones, in which case the strategy might incorrectly enter counter positions. The solution is to incorporate additional confirmation indicators or implement stricter confirmation conditions.
2. Parameter Sensitivity: Strategy performance heavily depends on parameter settings such as swingLookback and retestBars. Inappropriate parameters may result in excessive trading signals or missed opportunities. It's recommended to optimize these parameters through backtesting under different market conditions.
3. Market Environment Dependency: In strong trending markets, liquidity traps may be less frequent or effective. This strategy performs best in ranging or transitional markets and may underperform in one-directional trending markets. Consider adding trend filters to avoid counter-trend trading in strong trends.
4. Timeframe Limitation: The strategy, in its current implementation, applies to a single timeframe and may miss important liquidity levels from larger timeframes. Integrating multi-timeframe analysis can enhance strategy robustness.
5. Stop Loss Absence: The current strategy lacks explicit stop loss mechanisms, which could lead to excessive losses on incorrect signals. Appropriate stop loss and take profit logic should be added to protect capital.
6. Execution Slippage: In highly volatile markets, actual execution prices may differ significantly from expected prices at signal triggering. Slippage factors should be considered in live trading and strategy adjustments made accordingly.

Strategy Optimization Directions

1. Multi-Timeframe Integration: The strategy can be enhanced by analyzing liquidity levels across multiple timeframes, ensuring trades align with larger market structure. For example, adding checks for the dominant trend in larger timeframes and only accepting trap signals in the trend direction.
2. Volume Confirmation: Adding volume analysis can significantly improve strategy quality. Liquidity sweeps are often accompanied by sudden volume increases, while genuine reversals typically have sustained volume support. Adding volume filters can reduce false signals.
3. Dynamic Parameter Adjustment: Implement adaptive parameter mechanisms that automatically adjust swingLookback and other key parameters based on market volatility. Longer lookback periods may be needed in high-volatility markets, while shorter ones work better in low-volatility environments.
4. Stop Loss/Take Profit Mechanisms: Add intelligent stop loss strategies, such as setting stops beyond sweep highs/lows, or using ATR (Average True Range) to dynamically determine stop levels. Similarly, implement structure-based take profit targets, such as the next significant support/resistance level.
5. Market State Filtering: Develop a market state classifier to distinguish between trending, ranging, and transitional market environments, and adjust strategy parameters or pause trading based on the current market state. This can be achieved by adding trend indicators like moving averages or ADX.
6. Signal Quality Scoring: Implement a signal quality scoring system considering factors such as price retracement degree, candle pattern strength, and price momentum. Execute trades only on high-quality signals or adjust position sizing based on signal quality.
7. Correlated Asset Synergy: Look for confirmation signals across correlated assets. For example, in forex trading, correlations between currency pairs can provide additional layers of confirmation, enhancing strategy reliability.

Conclusion

The Multi-Timeframe Liquidity Trap Reversal Quantitative Strategy offers a concise yet powerful approach to identifying institutional market maker liquidity manipulation behaviors and profiting from them. By focusing on price patterns that break key support/resistance levels and then retrace, the strategy can capture significant market reversals. Its core strength lies in being directly based on raw price action and market structure without complex indicators, while improving trading quality through session filtering.

However, the strategy also faces challenges such as false breakout risks, parameter sensitivity, and lack of comprehensive risk management. By integrating multi-timeframe analysis, adding volume confirmation, implementing dynamic parameter adjustment, and establishing robust stop loss/take profit mechanisms, strategy performance and robustness can be significantly enhanced.

Ultimately, this strategy represents an effective approach to understanding market microstructure, offering traders a framework to align with “smart money” in the market by understanding and identifying the intentions of large market participants. With the suggested optimizations implemented, the strategy has the potential to become a powerful weapon in a trader’s toolkit, especially for those focusing on market structure and liquidity events.

Strategy source code

/*backtest
start: 2025-06-03 00:00:00
end: 2025-07-03 00:00:00
period: 5m
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

//@version=5
strategy("Market Maker Trap Reversal V1", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=5)

// === INPUTS === //
swingLookback = input.int(10, "Swing High/Low Lookback")
retestBars = input.int(5, "Bars to Confirm Trap After Sweep")
sessionStart = input.int(13, "Session Start Hour (UTC)")
sessionEnd = input.int(20, "Session End Hour (UTC)")
useSessionFilter = input.bool(true, "Use NY Session Only")

// === SESSION LOGIC === //
inSession = (hour >= sessionStart and hour < sessionEnd)

// === SWEEP LOGIC === //
prevHigh = ta.highest(high[1], swingLookback)
prevLow = ta.lowest(low[1], swingLookback)

sweepHigh = high > prevHigh
sweepLow = low < prevLow

// === TRAP CONFIRMATION === //
// After sweep, price must close back inside the range (fakeout)
trapShort = sweepHigh and close < prevHigh
trapLong = sweepLow and close > prevLow

// === TRIGGER LOGIC === //
longCondition = trapLong and (not useSessionFilter or inSession)
shortCondition = trapShort and (not useSessionFilter or inSession)

// === EXECUTE TRADES === //
if longCondition
    strategy.entry("Trap Long", strategy.long)

if shortCondition
    strategy.entry("Trap Short", strategy.short)

// === PLOT ZONES === //
plotshape(trapLong, title="Trap Long", location=location.belowbar, style=shape.triangleup, color=color.green, size=size.small)
plotshape(trapShort, title="Trap Short", location=location.abovebar, style=shape.triangledown, color=color.red, size=size.small)

plot(prevHigh, "Swing High", color=color.red, linewidth=1, style=plot.style_linebr)
plot(prevLow, "Swing Low", color=color.green, linewidth=1, style=plot.style_linebr)

Strategy parameters

The original address: Multi-Timeframe Liquidity Trap Reversal Quantitative Strategy

Overview

The VWAP-Enhanced Bollinger Bands Momentum Reversal Strategy is a quantitative trading system designed specifically for short-term cryptocurrency trading, primarily applied to 1-hour to 4-hour timeframes. This strategy cleverly combines three major technical indicators: Relative Strength Index (RSI), Bollinger Bands (BB), and Volume Weighted Average Price (VWAP) to form a comprehensive trading signal system. The core of the strategy is to capture potential reversal points during market overbought and oversold conditions, using VWAP as a trend confirmation tool, while incorporating precise risk control mechanisms to achieve efficient short-term trading.

Strategy Principles

The trading logic of this strategy is based on a multi-indicator confirmation mechanism, with specific principles as follows:

1. Buy Signal Conditions:

• Price crosses above the lower Bollinger Band (ta.crossover(close, bb_lower)) or RSI below 25 (oversold level)
• Current closing price is above VWAP, confirming effective uptrend

2. Sell Signal Conditions:

• Price crosses above the upper Bollinger Band (ta.crossover(close, bb_upper)) or RSI above 75 (overbought level)
• Current closing price is below VWAP, confirming effective downtrend

3. Position Management:

• Risk control for each trade is limited to 1% of total account funds
• Position size is dynamically calculated based on the preset 1.5% stop-loss rate

4. Money Management:

• Stop-loss is set at 1.5% of the entry price
• Take-profit target is set at 2.25% of the entry price (1.5 times the stop-loss), maintaining a favorable risk-reward ratio

The strategy uses precise parameter settings internally: RSI period of 14, Bollinger Bands period of 20, standard deviation multiplier of 2.0, overbought threshold of 75, and oversold threshold of 25. This parameter combination ensures that the strategy can capture important turning points in short-term price fluctuations.

Strategy Advantages

1. Multiple Confirmation Mechanism: The strategy combines RSI, Bollinger Bands, and VWAP indicators to form a multiple confirmation mechanism, effectively reducing false signals and improving trading success rates. When multiple indicators point to the same trading direction simultaneously, the reliability of the signal is significantly enhanced.
2. Flexible Market Adaptability: Through adjustable parameter settings (such as RSI overbought/oversold levels, Bollinger Bands length and multiplier), the strategy can adapt to different market environments and volatility characteristics, making it perform well across different cryptocurrencies and timeframes.
3. Strict Risk Control: Each trade risk is limited to 1% of the total account funds, coupled with a precise 1.5% stop-loss setting, effectively controlling the maximum loss per trade and protecting trading capital.
4. Optimized Risk-Reward Ratio: The strategy sets the take-profit target at 1.5 times the stop-loss (2.25%), ensuring a positive risk-reward ratio and increasing the probability of long-term profitability.
5. Quantified Position Management: The dynamic position calculation method based on risk percentage ensures that risk exposure remains consistent regardless of account size, achieving effective fund management.
6. Trend Confirmation Mechanism: Using VWAP as a trend confirmation tool helps avoid entering positions against the main trend, reducing the risk of counter-trend trading.

Strategy Risks

1. Short-term Volatility Risk: As an active short-term trading strategy, it may trigger frequent trades in highly volatile markets, increasing transaction costs and potentially facing more false breakout signals. Consider adding additional filtering conditions or extending confirmation time.
2. Parameter Sensitivity: Strategy performance is highly dependent on the parameter settings of RSI, Bollinger Bands, and VWAP. Inappropriate parameters may lead to overtrading or missing important signals. It is recommended to optimize parameter settings for different market environments through historical backtesting.
3. Market Sudden Change Risk: During major news events or black swan events, cryptocurrency markets may experience gaps or extreme volatility, and fixed stop-losses may not execute effectively, resulting in actual losses exceeding expectations. Consider implementing dynamic stop-losses or market volatility filters.
4. Liquidity Risk: When trading small-cap cryptocurrencies or during low liquidity periods, slippage issues may arise, affecting actual execution prices. It is recommended to prioritize testing and applying this strategy on mainstream cryptocurrencies with high liquidity (such as BTC/ETH).
5. Technical Indicator Lag: Both RSI and Bollinger Bands have certain lag, which may cause signal delays in rapidly changing markets. Consider introducing more sensitive indicators or reducing calculation periods to improve response speed.

Strategy Optimization Directions

1. Add Market Environment Filters: Introduce trend strength indicators (such as ADX) or volatility indicators (such as ATR) to dynamically adjust strategy parameters or selectively execute trading signals in different market environments. This will help the strategy better adapt to the different characteristics of ranging and trending markets.
2. Optimize Indicator Parameters: Based on historical data from different timeframes and different cryptocurrencies, optimize RSI periods and Bollinger Bands parameters to find the best parameter combinations for various market environments. Consider implementing an adaptive parameter adjustment mechanism.
3. Enhanced Stop-Loss Mechanism: Implement trailing stop-loss functionality to protect realized profits in profitable trades while allowing trends to continue developing. Dynamic stop-loss levels can be designed based on ATR or volatility percentages.
4. Integrate Volume Analysis: Add volume confirmation conditions to ensure sufficient market participation when signals occur, reducing low-quality signals. Volume expansion, especially when breaking through Bollinger Band boundaries, can increase signal reliability.
5. Add Time Filters: Analyze market performance during different time periods, avoid unfavorable trading sessions with low activity or high volatility, and focus on time windows where the strategy has historically performed best.
6. Develop Signal Quality Scoring System: Score the quality of each signal based on multiple factors (such as indicator divergence degree, market structure, volume support, etc.), only execute high-quality signals or dynamically adjust position size according to signal quality.
7. Implement Machine Learning Enhancement: Use machine learning algorithms to analyze historical trading data, identify characteristic patterns of the most successful signals, and dynamically optimize the trading decision process.

Summary

The VWAP-Enhanced Bollinger Bands Momentum Reversal Strategy is a well-structured, logically clear short-term cryptocurrency trading system. By capturing potential reversal points through RSI and Bollinger Bands, and using VWAP as a trend confirmation tool, it forms a multi-layered trading signal system. The built-in risk control mechanisms ensure capital safety, while the dynamic position calculation method guarantees consistency in risk exposure.

Although this strategy demonstrates good capture ability in short-term price fluctuations, users still need to be aware of potential risks such as market environment changes, parameter sensitivity, and liquidity issues. Performance can be further improved by adding market environment filters, optimizing indicator parameters, and enhancing stop-loss mechanisms.

For traders, it is recommended to first conduct thorough testing in high-liquidity markets such as BTC/ETH, and consider applying it to other crypto assets after becoming familiar with the strategy characteristics. Meanwhile, maintaining continuous observation of the market and regular optimization of the strategy will help maintain a competitive edge in the ever-changing cryptocurrency market.

Strategy source code

/*backtest
start: 2024-07-04 00:00:00
end: 2025-07-02 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

// @version=5
// @title Crypto Pulse Strategy Active
// @description A more active short-term trading strategy for cryptocurrencies using RSI, Bollinger Bands, and VWAP on 1h to 4h timeframes.

strategy("Crypto Pulse Strategy Active", overlay=true)

// === INPUTS ===
overbought = input.int(75, title="RSI Overbought Level", minval=60, maxval=90)
oversold = input.int(25, title="RSI Oversold Level", minval=10, maxval=40)
length_rsi = input.int(14, title="RSI Length", minval=5, maxval=30)
length_bb = input.int(20, title="Bollinger Bands Length", minval=10, maxval=50)
mult_bb = input.float(2.0, title="Bollinger Bands Multiplier", minval=1.0, maxval=5.0, step=0.1)
vwap_source = input.source(close, title="VWAP Source")
risk_per_trade = input.float(1.0, title="Risk Per Trade (%)", minval=0.1, maxval=5.0, step=0.1)
stop_loss = input.float(0.015, title="Stop Loss (%)", minval=0.001, maxval=0.05, step=0.001)

// === INDICATORS ===
rsi = ta.rsi(close, length_rsi)
[bb_middle, bb_upper, bb_lower] = ta.bb(close, length_bb, mult_bb)
vwap = ta.vwap(vwap_source)

// === CONDITIONS ===
buy_signal = (ta.crossover(close, bb_lower) or rsi < oversold) and close > vwap  // Buy with VWAP confirmation
sell_signal = (ta.crossover(close, bb_upper) or rsi > overbought) and close < vwap  // Sell with VWAP confirmation

// === POSITION SIZING ===
account_balance = strategy.equity
risk_amount = account_balance * (risk_per_trade / 100)
position_size = risk_amount / (stop_loss * close)

// === ENTRY LOGIC ===
if (buy_signal)
    strategy.entry("Long", strategy.long, qty=position_size)
    strategy.exit("Exit Long", "Long", stop=close * (1 - stop_loss), limit=close * (1 + stop_loss * 1.5))

if (sell_signal)
    strategy.entry("Short", strategy.short, qty=position_size)
    strategy.exit("Exit Short", "Short", stop=close * (1 + stop_loss), limit=close * (1 - stop_loss * 1.5))

// === PLOTTING ===
plot(rsi, title="RSI", color=color.blue)
plot(bb_upper, title="BB Upper", color=color.red)
plot(bb_middle, title="BB Middle", color=color.gray)
plot(bb_lower, title="BB Lower", color=color.green)
plot(vwap, title="VWAP", color=color.purple)
hline(overbought, "Overbought", color=color.red, linestyle=hline.style_dashed)
hline(oversold, "Oversold", color=color.green, linestyle=hline.style_dashed)
plotshape(buy_signal, title="Buy Signal", location=location.belowbar, color=color.green, style=shape.triangleup, size=size.small)
plotshape(sell_signal, title="Sell Signal", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small)

Strategy parameters

The original address: VWAP-Enhanced Bollinger Bands Momentum Reversal Strategy

I’ll analyze the provided trading strategy code and create a comprehensive article in both Chinese and English according to your requirements.

Strategy Overview

The Enhanced Cloud Momentum Trend Following Strategy is a powerful trend-following system that combines the Ichimoku Kinko Hyo system with a 171-period Exponential Moving Average (EMA) filter. This strategy is designed for traders looking to capture strong momentum moves while utilizing the cloud structure to identify optimal entry and exit points. It is a patient, low-frequency trading system that prioritizes quality over quantity. The strategy employs non-standard Ichimoku parameters (Conversion Line: 7 periods, Base Line: 211 periods, Lagging Span 2: 120 periods, Displacement: 41 periods) and combines them with a 171-period EMA as an additional trend confirmation layer, enabling precise capture of strong trends.

Strategy Principles

The core of this strategy lies in the synergistic action of carefully adjusted Ichimoku Cloud components and a long-term EMA filter:

1. Ichimoku Cloud Core Components:

• Conversion Line (Tenkan-sen): 7-period Donchian channel midpoint, more sensitive than the traditional 9-period
• Base Line (Kijun-sen): 211-period Donchian channel midpoint, providing stronger trend confirmation
• Span A (Senkou Span A): Average of Conversion and Base lines, projected 41 periods ahead
• Span B (Senkou Span B): 120-period Donchian channel midpoint, projected 41 periods ahead
• Lagging Span (Chikou Span): Current close plotted 41 periods back

2. Entry Logic (Default “Ichi” Mode):
A long position is triggered when ALL of the following conditions are met:

• Cloud Bullish: Span A > Span B (41 periods ago)
• Breakout Confirmation: Current close > 25-period high
• Ichimoku Bullish: Conversion Line > Base Line
• Trend Alignment: Current close > 171-period EMA
• State Memory: No previous buy signal is still active

3. Exit Logic:
Positions are closed when Ichimoku turns bearish: Conversion Line < Base Line

4. Alternative “Cloud” Mode:

• Entry: Span A crosses above Span B with additional cloud and EMA confirmations
• Exit: Span A crosses below Span B with cloud and EMA confirmations

5. State Memory System:
The strategy implements a sophisticated memory system to track buy/sell states and prevent false signals.

Strategy Advantages

1. High-Quality Signal Filtering:
   The strategy’s strict entry conditions ensure that it only enters the market when high-probability trends are forming, avoiding market noise and the cost losses associated with frequent trading. By requiring a bullish cloud, price breakout above the 25-period high, bullish Ichimoku, and price above the long-term EMA, the strategy effectively filters out weak signals.
2. Multi-Layer Confirmation Mechanism:
   Combining the Ichimoku Cloud system with the 171-period EMA provides multiple layers of trend confirmation, significantly reducing the risk of false breakouts and signals. This multi-filter mechanism is particularly suitable for capturing major trend movements.
3. Flexible Trading Modes:
   The strategy offers two trading modes (“Ichi” and “Cloud”), catering to different trader preferences and market condition requirements. This flexibility allows traders to adapt the strategy based on market characteristics.
4. Robust State Memory System:
   The implemented state memory system effectively prevents repeated triggering of consecutive signals, improving trading efficiency and reducing unnecessary trading costs.
5. Optimized Parameter Settings:
   The non-standard Ichimoku parameters (Conversion: 7, Base: 211, Lagging Span 2: 120, Displacement: 41) are optimized to better adapt to modern market conditions and specific asset price characteristics.

Strategy Risks

1. Lag Risk:
   Like all Ichimoku strategies, signals may lag significant price moves. Especially in rapidly changing market environments, the strategy may miss optimal entry points or delay exits, resulting in reduced gains or increased losses.
2. Choppy Market Risk:
   While the strategy is designed for trending markets, it may generate false signals in sideways or choppy markets. Extended periods of price consolidation may lead to multiple entries and exits, causing “whipsaw” losses.
3. Parameter Sensitivity:
   The custom parameters used in the strategy may not be equally effective across all market conditions. Different market environments and assets may require different parameter settings, which necessitates continuous monitoring and adjustment by traders.
4. Entry Delay:
   The 25-period high breakout confirmation requirement may delay entries in fast-moving markets, causing the strategy to miss a portion of the initial price movement.
5. Money Management Risk:
   The strategy uses a default 100% equity allocation, which may be too aggressive for actual trading. The lack of proper position sizing control may lead to excessive risk exposure.

Optimization Directions

1. Dynamic Parameter Adjustment:
   Implement an adaptive parameter system that automatically adjusts Ichimoku periods and EMA length based on market volatility and current trend strength. For example, shortening the Conversion Line period in high volatility markets and extending it in low volatility markets. This would improve the strategy’s adaptability across different market conditions.
2. Improved Money Management:
   Introduce a more sophisticated money management system that dynamically adjusts position size based on market volatility, current trend strength, and risk metrics. For instance, position size could be adjusted according to ATR (Average True Range) or cloud thickness, increasing positions in strong trends and reducing them in weak trends.
3. Add Risk Control Mechanisms:
   Implement stop-loss and profit target settings that can be automatically set based on cloud structure, key support/resistance levels, or volatility indicators. For example, using the bottom of the cloud as a stop-loss point for long positions, or using multiples of ATR to set trailing stops.
4. Optimize Short-Term Trading Capability:
   The current strategy is primarily aimed at long-term trends. Adding short-term indicators (such as RSI or stochastic) could improve performance in short-term market conditions. This would enable the strategy to profit even when trends are not obvious.
5. Add Market State Classification:
   Add a market state recognition system that automatically distinguishes between trending and ranging markets, and applies different trading rules based on different market states. For example, raising entry thresholds or avoiding trading altogether when a ranging market is identified.

Summary

The Enhanced Cloud Momentum Trend Following Strategy is a meticulously designed trend-following system that combines customized Ichimoku Cloud parameters with a long-term EMA filter, providing traders with a powerful tool for capturing major trend movements. Through its multi-layer confirmation mechanism, state memory system, and strict entry conditions, the strategy effectively filters out market noise and identifies high-probability trading opportunities.

While the strategy excels in trending markets, traders should be aware of its potential limitations in choppy markets and its lagging signal characteristics. By introducing dynamic parameter adjustment, improved money management, enhanced risk control mechanisms, optimized short-term trading capability, and market state classification, the strategy can further enhance its adaptability and robustness across different market environments.

Most importantly, traders should optimize parameters and control position sizing according to their risk tolerance and specific asset characteristics when applying this strategy in practice, and combine it with other technical and fundamental analyses for comprehensive decision-making. The strategy provides a solid trend-following framework, but successful trading still requires discipline, patience, and continuous market observation.

Strategy source code

/*backtest
start: 2024-07-07 00:00:00
end: 2025-07-04 08:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BNB_USDT"}]
*/

//@version=6
//Quant Trading
strategy("Enhanced Ichimoku Cloud Strategy V1 [Quant Trading]", overlay=true,
     default_qty_type=strategy.percent_of_equity,
     default_qty_value=100,
     commission_type=strategy.commission.percent,
     commission_value=0.1,
     slippage=3,
     initial_capital=1000,
     margin_long=0,
     margin_short=0)

// === DESCRIPTION ===
// Enhanced Ichimoku Cloud Strategy with 171-Day EMA
// Original logic preserved with proper formatting and structure

// === INPUT PARAMETERS ===

// Ichimoku Settings
conversionPeriods = input.int(7, minval=1, title="Conversion Line Periods", group="Ichimoku Settings")
basePeriods = input.int(211, minval=1, title="Base Line Periods", group="Ichimoku Settings")
laggingSpan2Periods = input.int(120, minval=1, title="Lagging Span 2 Periods", group="Ichimoku Settings")
displacement = input.int(41, minval=1, title="Displacement", group="Ichimoku Settings")

// EMA Settings
emaPeriod = input.int(171, minval=1, title="EMA Period", group="EMA Settings")

// Trade Settings
tradeModeOptions = input.string(defval="Ichi", title="Trade Setup", options=["Ichi", "Cloud"], group="Trade Settings")
allowShortTrades = input.bool(false, "Allow Short Trades?", group="Trade Settings")

// === 1️⃣ CALCULATIONS ===


// EMA Calculation
ema171 = ta.ema(close, emaPeriod)

// Donchian Channel Function
f_donchian(len) =>
    l = ta.lowest(low, len)
    h = ta.highest(high, len)
    (l + h) / 2

// Ichimoku Components
conversionLine = f_donchian(conversionPeriods)
baseLine = f_donchian(basePeriods)
spanA = (conversionLine + baseLine) / 2
spanB = f_donchian(laggingSpan2Periods)

// === 2️⃣ ENTRY & EXIT LOGIC ===

// Original Ichimoku Conditions (preserved exactly)
idealbuy = (spanA[displacement - 1] > spanB[displacement - 1]) and 
           (close > high[25]) and 
           (conversionLine > baseLine) and 
           (close > ema171)

idealsell = (conversionLine < baseLine)

// State Tracking (preserved exactly)
var bool buymem = false
var bool sellmem = false

if idealbuy
    buymem := true
else if idealsell
    buymem := false
else
    buymem := buymem[1]

if idealsell
    sellmem := true
else if idealbuy
    sellmem := false
else
    sellmem := sellmem[1]

// Signal Generation (preserved exactly)
longCond = idealbuy and not buymem[1]
shortCond = idealsell and not sellmem[1]

// Determine Buy and Sell Signals (preserved exactly)
buySignal = (tradeModeOptions == "Ichi") ? longCond : ta.crossover(spanA, spanB) and (low > spanA[25]) and (low > spanB[25]) and (close > ema171)
sellSignal = (tradeModeOptions == "Ichi") ? shortCond : ta.crossunder(spanA, spanB) and (high < spanA[25]) and (high < spanB[25]) and (close < ema171)

// === 3️⃣ TRADE EXECUTIONS ===

// Original Trade Logic (preserved exactly)
forced_slippage = close + (3 * syminfo.mintick)


if strategy.position_size == 0 and buySignal
    strategy.entry("Long", strategy.long, limit=forced_slippage)

if sellSignal
    strategy.close("Long")

// === 4️⃣ VISUALIZATIONS ===

// Ichimoku Cloud Components
plot(conversionLine, color=color.yellow, title="Conversion Line")
plot(baseLine, color=color.blue, title="Base Line")

p1 = plot(spanA, offset=displacement - 1, color=color.green, title="Span A")
p2 = plot(spanB, offset=displacement - 1, color=color.red, title="Span B")
plot(close, offset=-displacement + 1, color=color.gray, title="Lagging Span")

// Cloud Fill
fill(p1, p2, color=spanA > spanB ? color.new(color.green, 80) : color.new(color.red, 80))

// EMA
plot(ema171, color=color.orange, title="171-Day EMA")

// Entry and Exit Signals (commented out as in original)
// plotshape(series=buySignal, title="Buy Entry", location=location.belowbar, style=shape.labelup, color=color.lime, text="BUY", size=size.small)
// plotshape(series=sellSignal, title="Sell Exit", location=location.abovebar, style=shape.labeldown, color=color.red, text="SELL", size=size.small)

Strategy parameters

The original address: Enhanced Cloud Momentum Trend Following Strategy

Strategy Overview

The Adaptive Renko Momentum Trend Following Strategy is a trading system based on Renko charts and the UT Bot method, combining an adaptive ATR (Average True Range) trailing stop with an ADX (Average Directional Index) momentum filter. The strategy primarily triggers trading signals when price and EMA (Exponential Moving Average) cross the adaptive trailing stop line and ADX/DI+/DI- conditions are met. This combination is designed to help traders operate in strong trending markets while avoiding choppy, low-momentum market environments, thereby improving trading success rates.

The core logic revolves around a dynamically adjusting trailing stop line that automatically adapts to market volatility, providing clear entry signals for both long and short positions. Meanwhile, the ADX filter ensures trading only occurs when the market has sufficient directionality and momentum, significantly reducing the possibility of false signals in ranging markets.

Strategy Principles

The core principles of this strategy are based on several key components:

1. ATR Trailing Stop Line: Uses the ATR indicator to calculate volatility and applies a multiplier factor to create a dynamic stop line. This line can adaptively adjust according to market conditions, widening the stop distance when volatility increases and narrowing it when volatility decreases.
2. EMA and Stop Line Crossovers: When price and EMA cross the trailing stop line, potential trading signals are generated. Specifically, a buy signal is produced when the EMA crosses above the stop line, and a sell signal is produced when the stop line crosses above the EMA.
3. ADX Momentum Filter: Calculates ADX and its related indicators DI+ and DI- to evaluate market trend strength and direction. Trade signals are only confirmed when the ADX value exceeds a set threshold, and the corresponding directional indicator (DI+ for long trades, DI- for short trades) meets its condition.
4. Renko Chart Application: The strategy is specifically designed for Renko charts, leveraging their ability to filter market noise and provide clearer trend signals.

In its implementation, the strategy first calculates the ATR value, determining whether to use smoothing and adaptive multipliers based on settings. It then constructs the UT Bot trailing stop line, which dynamically adjusts according to price movement. Next, it calculates the EMA and detects crossovers with the stop line. Simultaneously, the strategy manually calculates ADX, DI+, and DI- indicators and sets filter conditions. Ultimately, actual trading signals are only triggered when price/EMA crossovers with the stop line occur and ADX filter conditions are satisfied.

Strategy Advantages

This strategy offers the following significant advantages:

1. Strong Adaptability: The stop line calculated through ATR can dynamically adjust according to market volatility, allowing the strategy to operate effectively in different market environments. The adaptive ATR multiplier option, in particular, enables automatic adjustment of stop distances based on changes in short-term volatility relative to long-term volatility.
2. Dual Trend Confirmation Mechanism: The combination of EMA crossovers and ADX filtering provides a dual verification mechanism for trend confirmation, significantly reducing the possibility of false breakouts and erroneous signals.
3. Avoids Low-Quality Markets: The ADX and directional indicator filters effectively avoid choppy, directionless market environments, allowing the strategy to focus on high-momentum, clearly directional trading opportunities.
4. Clear Visual Feedback: The strategy provides intuitive stop line displays and trade labels, allowing traders to clearly see entry points and stop loss positions, facilitating real-time decision-making and risk management.
5. Highly Customizable: The strategy offers multiple parameter setting options, including ATR period, multiplier, EMA period, ADX thresholds, etc., allowing traders to optimize and adjust according to personal preferences and different market characteristics.
6. Optimized for Renko Charts: The strategy is specifically designed for Renko charts, fully utilizing their characteristics of reducing noise and highlighting trends, which highly aligns with the strategy’s trend-following nature.

Strategy Risks

Despite its sophisticated design, this strategy still presents the following potential risks:

1. Parameter Sensitivity: Strategy performance is highly dependent on parameter settings such as ATR period, multiplier, ADX threshold, etc. Inappropriate parameters may lead to excessive false signals or missed important trading opportunities. The solution is comprehensive backtesting and parameter optimization under different market conditions.
2. Trend Reversal Risk: Despite the ADX filter, the strategy may still incur losses when strong trends suddenly reverse. This risk can be mitigated by setting additional stop loss conditions or incorporating other reversal indicators.
3. Low Liquidity Market Risk: In low liquidity markets, price movements may be irregular, leading to inaccurate ATR calculations and trailing stop lines. It is recommended to apply this strategy in markets with adequate liquidity.
4. Market Intermittency: Markets frequently switch between trending and oscillating phases, and even with the ADX filter, false signals may occur during these transitions. Consider adding market structure analysis or time filters to optimize strategy performance.
5. Over-Optimization Risk: With multiple adjustable parameters, there is a risk of over-optimization, which may lead to poor strategy performance in actual trading. Walk-forward testing and out-of-sample testing are recommended to verify the robustness of the strategy.

Strategy Optimization Directions

Based on code analysis, this strategy can be optimized in the following directions:

1. Integrate Multi-Timeframe Analysis: Introducing trend confirmation from higher timeframes and only trading in the direction of larger trends can improve win rates. This can be implemented by adding long-period moving averages or other trend indicators.
2. Dynamically Adjust ADX Thresholds: The current ADX threshold is fixed; consider dynamically adjusting thresholds based on market volatility or cyclical characteristics to adapt to different market environments. For example, raise the ADX threshold in high volatility markets and lower it in low volatility markets.
3. Add Profit Targets and Stop Loss Management: The current strategy focuses on entry signals; consider adding ATR-based dynamic profit targets and more refined stop loss management, such as trailing stops or partial profit-taking strategies.
4. Integrate Volume-Price Relationship Analysis: Include volume analysis in signal confirmation, only trading when volume confirms the trend, which can further improve signal quality.
5. Seasonality and Time Filters: Add seasonality filters based on historical statistics or specific time period filters to avoid known inefficient trading periods.
6. Machine Learning Optimization: Use machine learning techniques to optimize parameter selection and signal confirmation processes, which can improve strategy adaptability and performance. This involves training models using historical data to predict optimal parameter combinations or directly predict signal reliability.
7. Improve Renko Settings: Explore different Renko brick sizes and construction methods to find the most suitable settings for specific markets. Consider using adaptive Renko brick sizes that dynamically adjust based on market volatility.

Summary

The Adaptive Renko Momentum Trend Following Strategy is a well-designed trading system combining various technical analysis tools and filtering methods. Through the combination of adaptive ATR trailing stops, EMA crossover signals, and ADX momentum filters, the strategy can effectively identify trading opportunities in strong trending markets while avoiding low-quality oscillating markets.

The strategy’s main advantages lie in its adaptability and dual confirmation mechanism, allowing it to maintain relatively stable performance across different market environments. Additionally, through clear visual feedback and highly customizable parameter settings, traders can optimize and adjust according to personal preferences and specific market characteristics.

However, when using this strategy, attention must be paid to parameter sensitivity, trend reversal risks, and over-optimization issues. The strategy’s performance can be further improved by adding multi-timeframe analysis, dynamically adjusting parameters, improving stop loss management, and integrating other analytical tools.

Overall, this is a trend-following strategy with solid theoretical foundations and reasonable design, particularly suitable for traders interested in Renko charts and momentum trading. Through a thorough understanding of the strategy principles and appropriate parameter optimization, it has the potential to become an effective tool in trading systems.

Strategy source code

/*backtest
start: 2025-06-06 00:00:00
end: 2025-07-05 10:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BNB_USDT"}]
*/

//@version=6
strategy("Renko UT Bot Strategy v6 - ADX Filter", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=1)

// === Inputs ===
atrPeriod       = input.int(5,    "ATR Period",               minval=1)
atrMult         = input.float(3.5, "ATR Multiplier",           step=0.1)
useAtrSmooth    = input.bool(false,"Use Wilder ATR Smooth")
adaptiveAtr     = input.bool(false,"Adaptive ATR Multiplier")
adaptiveFactor  = input.float(1.0, "Adaptive Mult Factor",    step=0.1)
emaPeriod       = input.int(1,    "EMA Period for Crossover", minval=1)
showStopLine    = input.bool(true, "Show Trailing Stop")
showStopLabel   = input.bool(true, "Show Stop Label")
labelOffset     = input.int(2,    "Label Horizontal Offset",  minval=-10, maxval=10)
labelSizeOpt    = input.string("small","Label Text Size",     options=["tiny","small","normal","large"])
arrowOffset     = input.int(0,    "Arrow Offset",             minval=-10, maxval=10)

// === ADX Filter Inputs ===
adxLen      = input.int(14, "ADX Length", minval=1)
adxThresh   = input.float(20, "ADX Threshold", step=0.1)
diplusThresh= input.float(20, "DI+ Threshold", step=0.1)
diminusThresh=input.float(20, "DI- Threshold", step=0.1)

// === Price & ATR ===
src      = close
atrRaw   = useAtrSmooth ? ta.rma(ta.tr, atrPeriod) : ta.atr(atrPeriod)
mult     = adaptiveAtr    ? atrMult * (atrRaw / ta.atr(atrPeriod)) * adaptiveFactor : atrMult
loss     = atrRaw * mult

// === UT Bot Trailing Stop ===
var float stopLine = na
prevStop        = nz(stopLine[1], src)
stp1            = src > prevStop ? src - loss : src + loss
stp2            = (src < prevStop and src[1] < prevStop) ? math.min(prevStop, src + loss) : stp1
stopLine        := (src > prevStop and src[1] > prevStop) ? math.max(prevStop, src - loss) : stp2

plot(showStopLine ? stopLine : na, title="Trailing Stop", color=color.orange)

// === Signals ===
ema1    = ta.ema(src, emaPeriod)
buyX    = ta.crossover(ema1, stopLine)
sellX   = ta.crossover(stopLine, ema1)

// === Manual ADX and DI Calculation ===
upMove   = high - high[1]
downMove = low[1] - low
plusDM   = (upMove > downMove and upMove > 0) ? upMove : 0
minusDM  = (downMove > upMove and downMove > 0) ? downMove : 0
trur     = ta.rma(ta.tr, adxLen)
plusDI   = 100 * ta.rma(plusDM, adxLen) / trur
minusDI  = 100 * ta.rma(minusDM, adxLen) / trur
dx       = 100 * math.abs(plusDI - minusDI) / (plusDI + minusDI)
adx      = ta.rma(dx, adxLen)

// === ADX Filter ===
adxFilterLong  = adx > adxThresh and plusDI > diplusThresh
adxFilterShort = adx > adxThresh and minusDI > diminusThresh

// === Filtered Entry Signals ===
signalLongEntry  = buyX and src > stopLine and adxFilterLong
signalShortEntry = sellX and src < stopLine and adxFilterShort

// === Entries & Labels ===
if signalLongEntry
    strategy.entry("Long", strategy.long)
    if showStopLabel
        label.new(bar_index + labelOffset, stopLine,
           text="Stop: " + str.tostring(stopLine, "#.#####"), xloc=xloc.bar_index,
           style=label.style_label_left, color=color.orange, textcolor=color.white,
           size = labelSizeOpt == "tiny"  ? size.tiny  :
                  labelSizeOpt == "small" ? size.small :
                  labelSizeOpt == "normal"? size.normal : size.large)

if signalShortEntry
    strategy.entry("Short", strategy.short)
    if showStopLabel
        label.new(bar_index + labelOffset, stopLine,
           text="Stop: " + str.tostring(stopLine, "#.#####"), xloc=xloc.bar_index,
           style=label.style_label_left, color=color.orange, textcolor=color.white,
           size = labelSizeOpt == "tiny"  ? size.tiny  :
                  labelSizeOpt == "small" ? size.small :
                  labelSizeOpt == "normal"? size.normal : size.large)

plotshape(signalLongEntry,  title="Buy",  style=shape.triangleup,   location=location.belowbar, color=color.green,  offset=arrowOffset)
plotshape(signalShortEntry, title="Sell", style=shape.triangledown, location=location.abovebar, color=color.red,    offset=arrowOffset)

// === Alerts ===
alertcondition(signalLongEntry,  title="UT Bot Long",  message="UT Bot Long Signal")
alertcondition(signalShortEntry, title="UT Bot Short", message="UT Bot Short Signal")
if signalLongEntry
    alert("Long @" + str.tostring(close), alert.freq_once_per_bar_close)
if signalShortEntry
    alert("Short @" + str.tostring(close), alert.freq_once_per_bar_close)

Strategy parameters

The original address: Adaptive Renko Momentum Trend Following Strategy with ADX Filter