Rastreador de Baleias
ianzeng123
VS, ATR, MA200, HTF
Não é uma estratégia de invasão comum, é um rastreador de tubarões especializado em caçar grandes capitais.
Os dados de retrospectiva mostram que, quando o mercado apresenta um sinal de Volume Spike (VS), o sucesso é claramente superior à estratégia de ruptura tradicional, com a ajuda de múltiplos filtros de MA. A lógica central é simples e grosseira.
Detecção VS de 21 ciclos + 2,3 vezes o coeficiente de amplificação para capturar o sinal isotérmico real
A estratégia tradicional olha para o preço, e este sistema olha para a variação de volume de transação. O fluxo médio é calculado após a eliminação de dois extremos em 21 ciclos, e o sinal é acionado quando a linha K atual oscila mais de 2,3 vezes a média e representa mais de 0,7% do preço de fechamento. Mais importante, o preço de fechamento deve estar em 65% acima da linha K atual, garantindo que seja uma emissão dominada por múltiplos.
Os dados falam.O sistema de detecção VS filtra mais de 90% das falsas descobertas, capturando apenas as que realmente envolvem grandes investimentos.
O MA200, um sistema de filtragem quadruplo, recusou-se a fazer mais em um mercado de baixa.
Nem todos os lançamentos valem a pena, as tendências do mercado determinam tudo. A estratégia estabelece quatro linhas de defesa do MA200:
- O preço atual deve ser superior a MA200
- A MA200 deve estar em alta ((a inclinação de 20 ciclos é positiva))
- Nível de 4 horas MA200 também confirmou a multiplicação
- A distância entre o ponto de entrada e o MA200 não deve exceder 6%
O que isso significa?Você nunca será pego em uma clara tendência de queda, porque o sistema não dá sinais.
2.7x ATR Stop Loss + Dynamic Tracking, com mais controle de risco do que você imagina
O risco de cada transação é fixado em US $ 100 (disponível para ajuste) e o tamanho da posição é calculado dinamicamente através do ATR. O ATR de 14 ciclos é multiplicado por 2,7 vezes o stop inicial, um parâmetro que foi amplamente otimizado com o retrospectivo, evitando o stop de flutuação normal e saindo do mercado a tempo de uma verdadeira reversão.
Inovação chaveCada vez que um novo sinal VS aparece, o preço de stop-loss move-se automaticamente para o último mínimo, bloqueando o que já é lucrativo e deixando espaço para a tendência.
A pirâmide da lógica do acúmulo, que faz com que os lucros corram mais longe
O primeiro sinal de VS abriu a posição, o segundo sinal de VS aumentou a posição, o terceiro sinal de VS moveu o stop loss para o preço de custo. Isso não é um aumento de posição cego, mas sim baseado na lógica de julgamento de que o fluxo de capital contínuo e contínuo geralmente significa maior mercado.
Com base em dadosA retrospectiva histórica mostra que, em casos de mais de três sinais de VS consecutivos, o aumento médio é de 2,8 vezes o sinal de VS único.
O mecanismo de batch-stop, o equilíbrio perfeito entre os sacos para seguir a tendência de Anvs
Quando o 4o sinal de VS é disparado, o paramento automático é de 33% da posição; quando o 5o sinal de VS é disparado, o paramento é de 50% da posição restante. A lógica desse design é: o sinal de VS anterior confirma a tendência, o sinal de VS posterior tende a se aproximar da região superior.
Efeitos reaisO que é que o filme tem a ver com o que está acontecendo no mundo dos negócios?
Mecanismo Pay-Self, proteção automática de 0,15% de lucro após flutuação de 2%
Esta é a essência do gerenciamento de risco. Quando a flutuação atinge 2%, o preço de parada de perda é automaticamente elevado para 0,15% acima do preço de custo. Aparentemente conservador, na verdade, há espaço suficiente para a grande tendência sob a premissa de garantir a estabilidade da estratégia a longo prazo.
Por que 2% de desencadeamento?Os dados de retrospectiva mostram que a probabilidade de lucro final é de mais de 78%, com uma taxa de flutuação de 2%.
Mercado aplicável: nível de 1 hora do BTC, melhor desempenho em um ambiente de bull market
A estratégia foi desenvolvida especificamente para otimizar o gráfico de 1 hora do BTC, destacando-se em situações de tendência. Note-se que os sinais VS são frequentes, mas de amplitude limitada, em mercados de turbulência, e podem ocorrer pequenas paradas consecutivas.
Alerta de riscoA retrospectiva histórica não representa o lucro futuro e a estratégia apresenta um risco de perdas contínuas. Recomenda-se um controle rigoroso do risco individual, não superior a 1-2% da conta. O desempenho da estratégia pode ser significativamente diferente quando o ambiente do mercado muda.
Bottom line: um sistema completo de acompanhamento de tendências, não uma ferramenta de especulação de curta distância
Se você espera sinais todos os dias, esta estratégia não é para você. Se você quer capturar a verdadeira tendência e está disposto a esperar por uma oportunidade de entrada de alta qualidade, então este rastreador de bacalhau vale a pena um estudo aprofundado.
/*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))