ianzeng123
VS, ATR, MA200, HTF
This Isn’t Your Average Breakout Strategy—It’s a Whale Movement Tracker
Backtest data reveals: When Volume Spike (VS) signals appear with multi-MA filtering, win rates significantly outperform traditional breakout strategies. Core logic is brutally simple—big money always leaves traces, and our job is to follow these “whales.”
21-Period VS Detection + 2.3x Multiplier Catches Real Anomaly Signals
Traditional strategies watch price, this system watches volume anomalies. Calculate average volatility over 21 periods (excluding 2 outliers), trigger when current bar exceeds 2.3x average AND represents 0.7%+ of closing price. Crucially, close must be in upper 65% of the bar, ensuring bullish dominance.
Data speaks: This VS detection filters out 90%+ false breakouts, capturing only moves with genuine institutional participation.
MA200 Quad-Filter System Refuses Bull Trades in Bear Markets
Not every volume spike deserves a chase—trend determines everything. Strategy deploys four MA200 checkpoints: - Current price above MA200 - MA200 must show upward slope (20-period positive gradient) - 4-hour timeframe MA200 confirms bullish bias - Entry point within 6% of MA200
Translation? You’ll never get trapped in obvious downtrends because the system simply won’t signal.
2.7x ATR Stop Loss + Dynamic Trailing Delivers Stricter Risk Control Than Expected
Each trade risks fixed $100 (adjustable), with ATR-calculated position sizing. 14-period ATR × 2.7 sets initial stop—this parameter survived extensive backtesting, avoiding normal volatility whipsaws while catching real reversals quickly.
Key innovation: Each new VS signal automatically moves stop loss to latest low, locking profits while giving trends breathing room.
Pyramid Logic Lets Profits Run Further
First VS opens position, second VS adds size, third VS moves stop to breakeven. This isn’t blind averaging—it’s logic-based judgment on sustained anomalies. Consecutive institutional flows typically signal bigger moves ahead.
Data backing: Historical tests show 3+ consecutive VS signals produce average gains 2.8x larger than single VS events.
Staged Profit-Taking Balances Security vs Trend Following
4th VS signal triggers 33% profit-taking; 5th VS takes another 50% of remaining position. Logic: early VS signals confirm trend, later signals often mark top zones.
Real-world impact: Eliminates “elevator rides” while preserving partial exposure for potential super-trends.
Pay-Self Mechanism Auto-Protects 0.15% Profit After 2% Float
Risk management essence—when floating profit hits 2%, stop loss automatically adjusts to 0.15% above cost. Seems conservative, actually ensures long-term stability while giving major trends adequate space.
Why 2% trigger? Backtest data shows trades reaching 2% float have 78%+ final profit probability.
Target Market: BTC 1-Hour Timeframe, Peak Performance in Bull Environments
Strategy optimized specifically for BTC 1H charts, excelling in trending conditions. Note: choppy markets generate frequent VS signals with limited range, potentially causing consecutive small stop-outs.
Risk Warning: Historical backtests don’t guarantee future returns. Strategy carries consecutive loss risk. Recommend strict single-trade risk control at 1-2% of account. Performance may vary significantly with changing market conditions.
Bottom Line: Complete Trend-Following System, Not Short-Term Speculation Tool
If you expect daily signals, this strategy isn’t for you. If you want to capture genuine trending moves and can wait for high-quality setups, this whale tracker deserves serious study. Remember: market profits belong to the minority—following big money beats following emotions.
/*backtest
start: 2025-01-13 00:00:00
end: 2026-01-11 00:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_OKX","currency":"ETH_USDT","balance":500000}]
*/
//@version=5
strategy("BULL Whale Finder + BTC 1h",
overlay=true,
pyramiding=4,
calc_on_every_tick=true,
process_orders_on_close=false)
// =====================================================
// INPUTS (SOLO 1)
// =====================================================
float MLPT_USD = input.float(100, "MLPT USD (riesgo por trade)", minval=1, step=1)
// =====================================================
// HARD CODED (NO TOCAR)
// =====================================================
// Execution
string POINTER = ""
bool allowBacktestNoPointer = true
// SL (ATR)
int atrLen = 14
float atrMult = 2.7
// Pay-Self
bool usePaySelf = true
float payTriggerPct = 2.0 / 100.0
float payLockPct = 0.15 / 100.0
// MA200 Filter
bool useMA200Filter = true
bool useMA200Slope = true
int ma200Len = 200
int ma200SlopeLen = 20
// MA200 HTF
bool useMA200HTF = true
string ma200HTF_tf = "240" // 4H
// VS Params
int vsLen = 21
int vsOut = 2
float vsMult = 2.3
float vsMinPct = 0.7 / 100.0
float vsClosePct = 35.0 / 100.0
// Exchange / rounding
float SL_BUFFER = 0.01
float qtyFixed = 0.001
float stepQty = 0.001
float MIN_NOTIONAL_USD = 20.0
// TP
bool tpFromVS3 = false
float tp1Pct = 33.0
float tp2Pct = 50.0
// Visual
bool showSL = true
bool showShade = true
bool showEntryDot = true
color cSL = color.new(color.green, 0)
color cShade = color.new(color.green, 85)
color cVSentry = color.lime
color cVStp = color.orange
// Proximidad MA1/MA2 (tal cual tus valores)
bool useMA1Filter = true // exigir close > MA20
bool useEntryNearMA2 = true // VS#1 cerca MA200 desde LOW
float entryNearMA2Pct = 6.0 / 100.0 // 6%
bool useEntryNearMA1 = false // desactivado (tu screenshot)
float entryNearMA1Pct = 6.0 / 100.0 // queda fijo aunque no se use
bool useMA1MA2Near = true // MA20 y MA200 cerca
float ma1ma2NearPct = 6.0 / 100.0 // 6%
// =====================================================
// JSON (ALERTS) — hardcode pointer vacío
// =====================================================
f_json(_event, _reduce) =>
"{" + "\"ticker\":\"{{ticker}}\"," + "\"action\":\"{{strategy.order.action}}\"," + "\"quantity\":\"{{strategy.order.contracts}}\"," + "\"pointer\":\"" + POINTER + "\"," + "\"reduce_only\":" + (_reduce ? "true" : "false") + "," + "\"event\":\"" + _event + "\"}"
// =====================================================
// HELPERS
// =====================================================
f_round_step_floor(_x, _step) => _step > 0 ? math.floor(_x / _step) * _step : _x
f_round_step_ceil(_x, _step) => _step > 0 ? math.ceil(_x / _step) * _step : _x
f_qty_min_notional(_qty, _px) =>
need = (MIN_NOTIONAL_USD > 0) ? (MIN_NOTIONAL_USD / _px) : 0.0
qRaw = math.max(_qty, need)
f_round_step_ceil(qRaw, stepQty)
f_qty_mlpt_long(_entry, _sl) =>
risk = _entry - _sl
qRaw = (risk > 0) ? (MLPT_USD / risk) : 0.0
f_round_step_floor(qRaw, stepQty)
// =====================================================
// MA200 / MA20
// =====================================================
ma200 = ta.sma(close, ma200Len)
plot(ma200, "MA200", color=color.red, linewidth=2)
ma1 = ta.sma(close, 20)
plot(ma1, "MA20", color=color.blue, linewidth=2)
ma200Slope = ma200 - ma200[ma200SlopeLen]
ma200SlopeOK = (not useMA200Slope) or (not na(ma200Slope) and ma200Slope > 0)
ma200FilterOK = (not useMA200Filter) or (close > ma200 and ma200SlopeOK)
// HTF MA200
ma200HTF = request.security(syminfo.tickerid, ma200HTF_tf, ta.sma(close, ma200Len))
ma200HTFFilterOK = (not useMA200HTF) or (not na(ma200HTF) and close > ma200HTF)
// Proximidad (medido desde LOW)
ma1FilterOK = (not useMA1Filter) or (close > ma1)
distLowMA2 = (not na(ma200) and low > 0) ? math.abs(low - ma200) / low : na
entryNearMA2OK = (not useEntryNearMA2) or (not na(distLowMA2) and distLowMA2 <= entryNearMA2Pct)
distLowMA1 = (not na(ma1) and low > 0) ? math.abs(low - ma1) / low : na
entryNearMA1OK = (not useEntryNearMA1) or (not na(distLowMA1) and distLowMA1 <= entryNearMA1Pct)
distMA1MA2 = (not na(ma1) and not na(ma200) and ma1 != 0) ? math.abs(ma1 - ma200) / ma1 : na
ma1ma2NearOK = (not useMA1MA2Near) or (not na(distMA1MA2) and distMA1MA2 <= ma1ma2NearPct)
// =====================================================
// VS DETECTION — LONG
// =====================================================
rng = high - low
f_avg_no_out(_len, _k) =>
float result = na
if bar_index >= _len
arr = array.new_float(0)
for i = 0 to _len - 1
array.push(arr, high[i] - low[i])
array.sort(arr, order.ascending)
n = array.size(arr)
kk = math.min(_k, math.floor((n - 1) / 2))
start = kk
stop = n - kk - 1
sum = 0.0
count = 0
if stop >= start
for j = start to stop
sum += array.get(arr, j)
count += 1
result := count > 0 ? sum / count : na
result
avgRng = f_avg_no_out(vsLen, vsOut)
okRange = not na(avgRng) and rng >= avgRng * vsMult
okMinPct = rng >= close * vsMinPct
strongBull = rng > 0 and (high - close) / rng <= vsClosePct
isVS = okRange and okMinPct and strongBull
// =====================================================
// EXEC FLAGS (hardcoded)
// =====================================================
hasPointer = str.length(POINTER) > 0
canTrade = allowBacktestNoPointer or hasPointer
// =====================================================
// VARS
// =====================================================
var float slPrice = na
var float entryPx = na
var float initQty = na
var float mfePct = 0.0
var bool payArmed = false
var int vsCount = 0
var float vs2Low = na
var bool tp1 = false
var bool tp2 = false
// RESET
if strategy.position_size == 0
slPrice := na
entryPx := na
initQty := na
mfePct := 0.0
payArmed := false
vsCount := 0
vs2Low := na
tp1 := false
tp2 := false
// =====================================================
// ENTRY (VS #1) + SL inicial ATR
// =====================================================
enterCond = barstate.isconfirmed and isVS and ma200FilterOK and ma200HTFFilterOK and ma1FilterOK and entryNearMA2OK and entryNearMA1OK and ma1ma2NearOK and strategy.position_size == 0 and canTrade
if enterCond
atr = ta.atr(atrLen)
slInit = close - atr * atrMult
qtyRisk = f_qty_mlpt_long(close, slInit)
qtyFinal = f_qty_min_notional(qtyRisk, close)
qtyFinal := f_round_step_floor(qtyFinal, stepQty)
if qtyFinal > 0
strategy.entry("L", strategy.long, qty=qtyFinal, alert_message=(hasPointer ? f_json("ENTRY_INIT", false) : ""))
entryPx := close
initQty := qtyFinal
slPrice := slInit
vsCount := 1
plotshape(showEntryDot and enterCond, title="Entry Dot", style=shape.circle, size=size.tiny, location=location.belowbar, color=color.new(color.green, 0))
// =====================================================
// PAY-SELF (MFE % -> SL piso a profit fijo, sin cerrar size)
// =====================================================
if usePaySelf and strategy.position_size > 0 and not na(entryPx) and entryPx > 0
curMfePct = math.max(0.0, (high - entryPx) / entryPx)
mfePct := math.max(mfePct, curMfePct)
if not payArmed and mfePct >= payTriggerPct
payArmed := true
if payArmed and payLockPct > 0 and not na(initQty) and initQty > 0
paySL = entryPx * (1.0 + payLockPct)
slPrice := na(slPrice) ? paySL : math.max(slPrice, paySL)
// =====================================================
// VS SEQUENCE
// =====================================================
if barstate.isconfirmed and strategy.position_size > 0 and isVS
vsCount += 1
slTrail = low - SL_BUFFER
slPrice := na(slPrice) ? slTrail : math.max(slPrice, slTrail)
if vsCount == 2
vs2Low := low - SL_BUFFER
addQty = f_qty_mlpt_long(close, slPrice)
addQty := f_qty_min_notional(addQty, close)
addQty := f_round_step_floor(addQty, stepQty)
if addQty > 0
strategy.entry("L", strategy.long, qty=addQty, alert_message=(hasPointer ? f_json("ADD_VS2", false) : ""))
if vsCount == 3
slPrice := math.max(slPrice, entryPx)
if not na(vs2Low)
slPrice := math.max(slPrice, vs2Low)
int tp1VS = tpFromVS3 ? 3 : 4
int tp2VS = tpFromVS3 ? 4 : 5
if vsCount == tp1VS and not tp1
strategy.close("L", qty_percent=tp1Pct, alert_message=(hasPointer ? f_json("TP1_VS" + str.tostring(tp1VS), true) : ""))
tp1 := true
if vsCount == tp2VS and not tp2
strategy.close("L", qty_percent=tp2Pct, alert_message=(hasPointer ? f_json("TP2_VS" + str.tostring(tp2VS), true) : ""))
tp2 := true
// =====================================================
// EXIT (SL EVENT)
// =====================================================
if strategy.position_size > 0 and not na(slPrice)
strategy.exit("XL", from_entry="L", stop=slPrice, alert_message=(hasPointer ? f_json("SL_EVENT", true) : ""))
// =====================================================
// BAR COLORS (VS entrada vs VS de TP)
// =====================================================
int tp1VS_now = tpFromVS3 ? 3 : 4
int tp2VS_now = tpFromVS3 ? 4 : 5
isTPvs = strategy.position_size > 0 and isVS and (vsCount == tp1VS_now or vsCount == tp2VS_now)
barcolor(isTPvs ? cVStp : (isVS ? cVSentry : na))
// =====================================================
// SL PLOT + SHADE
// =====================================================
pSL = plot(showSL ? slPrice : na, "SL", color=cSL, linewidth=2, style=plot.style_linebr)
pPx = plot(showShade and strategy.position_size > 0 ? close : na, "PX (fill)", color=color.new(color.white, 100), display=display.none)
fill(pSL, pPx, color=(showShade and strategy.position_size > 0 ? cShade : na))