Rastreador de ballenas
ianzeng123
VS, ATR, MA200, HTF
No se trata de una estrategia de ataque común, sino de un rastreador de tiburones diseñado para atacar a los grandes inversores.
Los datos de retrospectiva muestran que cuando el mercado muestra una señal de Volumen Spike ((VS), la combinación de múltiples filtros de MA es claramente mejor que la estrategia de ruptura tradicional. La lógica central es simple: la entrada de grandes capitales brutales inevitablemente dejará una huella, todo lo que tenemos que hacer es seguir los pasos de estos “piratas”.
Detección VS de 21 ciclos + Factor de aumento de 2,3 veces para capturar una señal isotérmica real
Las estrategias tradicionales miran el precio, este sistema mira la variación de la cantidad de transacción. Se calcula la media de las oscilaciones después de eliminar los dos extremos en 21 ciclos, y se activa la señal cuando la línea K actual oscila más de 2.3 veces la media y representa más del 0.7% del precio de la barra. Más importante aún, el precio de la barra debe estar ubicado en el 65% por encima de la línea K actual, asegurando que sea una emisión dominada por múltiples cabezas.
Los datos hablanEl sistema de detección VS filtra más del 90% de las brechas falsas y solo capta aquellas que realmente tienen una gran participación financiera.
El MA200, un sistema de cuatro filtros, se niega a hacer más en un mercado bajista
No todos los lanzamientos merecen la pena, las tendencias del mercado lo determinan todo. La estrategia establece cuatro líneas de defensa para el MA200:
- El precio actual debe estar por encima de MA200
- El MA200 debe estar en tendencia al alza (la inclinación de 20 ciclos es positiva)
- 4 horas de nivel MA200 también confirman más cabeza
- El punto de entrada está a menos del 6% de la MA200
¿Qué significa eso?Nunca te enganchas en una tendencia bajista evidente, porque el sistema no da ninguna señal.
2.7 veces el ATR de detención + seguimiento dinámico, control de riesgo más estricto de lo que imaginas
El riesgo de cada operación se fija en 100 dólares (adjustable), y el tamaño de la posición se calcula dinámicamente a través de ATR. El ATR de 14 ciclos se multiplica por 2.7 veces como el stop inicial, un parámetro optimizado después de una gran retroalimentación, que tanto evita el stop de fluctuación normal como la salida a tiempo en el momento de la inversión real.
La innovación claveCada vez que aparece una nueva señal VS, el precio de parada se mueve automáticamente a los últimos mínimos, bloqueando los márgenes de ganancias y dejando espacio para la tendencia.
La pirámide de la lógica de la hipoteca hace que las ganancias corran más lejos
La primera señal de VS abre la posición, la segunda señal de VS aumenta la posición, y la tercera señal de VS se mueve al precio de costo después de la pérdida. No se trata de una colocación ciega, sino de un juicio lógico basado en la inestabilidad continua del mercado. Las continuas grandes entradas de capital generalmente significan una mayor situación.
Respaldado por datosLa retrospectiva histórica muestra que en el caso de más de 3 señales de VS consecutivas, el aumento promedio es de 2.8 veces el de una señal de VS individual.
Un mecanismo de bloqueo de lotes, el equilibrio perfecto para seguir la tendencia de las bolsas de seguridad
Cuando se activa la cuarta señal VS, se detiene automáticamente el 33% de la posición; cuando se activa la quinta señal VS, se detiene el 50% de la posición restante. La lógica de este diseño es: la señal VS anterior confirma la tendencia, la señal VS posterior tiende a acercarse a la zona superior.
Efectos en el campo de batallaEn el video, el director de la película, el director de la película y el director de la película de la película de la película, Tom Hiddleston, comparten sus experiencias en el escenario de la película.
Mecanismo Pay-Self, que protege automáticamente el 0.15% de las ganancias después de un aumento del 2%
Es la esencia de la gestión de riesgos: cuando la volatilidad alcanza el 2%, el precio de parada de pérdidas se eleva automáticamente al 0.15% por encima del precio de costo. Aparentemente conservador, en realidad deja suficiente espacio para una gran tendencia, siempre que se garantice la estabilidad a largo plazo de la estrategia.
¿Por qué el 2%?Los datos de retrospectiva muestran que las operaciones con un 2% de volatilidad tienen una probabilidad de ganancias de más del 78%.
Mercado aplicable: BTC 1 hora, mejor desempeño en un entorno de mercado alcista
Las estrategias están diseñadas para optimizar el gráfico de 1 hora de BTC, y se destacan en situaciones de tendencia. Hay que tener en cuenta que las señales VS son frecuentes pero de amplitud limitada en los mercados convulsivos, y es posible que se produzcan pequeñas pérdidas continuas.
Consejos de riesgoLa retrospectiva histórica no representa ganancias futuras, la estrategia tiene un riesgo de pérdidas continuas. Se recomienda un control estricto del riesgo individual, que no exceda del 1-2% de la cuenta. El rendimiento de la estrategia puede variar significativamente cuando el entorno del mercado cambia.
Bottom Line: Es un sistema completo de seguimiento de tendencias, no una herramienta de especulación en línea corta
Si esperas señales todos los días, esta estrategia no es para ti. Si quieres capturar las tendencias reales y estás dispuesto a esperar la entrada de una oportunidad de alta calidad, este rastreador de tiburones es algo que vale la pena investigar.
/*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))