Protocolo do Motor de Ondas
ATR volatility ACCUMULATION DCA
Data de criação:
2025-11-26 18:13:25
última modificação:
2025-11-26 18:13:25
cópia:
0
Cliques:
53
ianzeng123
2
focar em
319
Seguidores
Não é um DCA normal, é um motor de oscilação com cérebro.
Os dados de retrospectiva enfrentam diretamente o que se costuma chamar de investimento convencional: uma queda de 5% desencadeou a compra e uma alta de 3,9% desencadeou a venda, mas a chave é que o mercado está em alta.O motor de oscilação compra os valores baixos de acordo com a dinâmica ATRQuanto maior for a flutuação do mercado, maior será o limiar de compra, com um máximo de 40% de ajuste. Isso significa que, durante a alta flutuação, a estratégia espera por maiores quedas para entrar.
O problema com as estratégias tradicionais de DCA é que são compras sem cérebro, e a lógica central do protocolo é que o DCA não é um protocolo de compra sem cérebro.Só disparar quando há uma janela de oportunidade real.❚ Calcula a taxa de flutuação atual através do ATR ❚ 14) e ajusta dinamicamente o parâmetro longThreshPct ❚ Por exemplo, compra com uma queda normal de 5%, mas se a taxa de flutuação atual atingir 20%, a depreciação da compra real será de 6%.
8 configurações predefinidas, cada uma com uma expectativa de receita clara
Modelo de acumulação do ciclo do BTC: 5% de compra a baixa, 6% de posição, US \( 500 em valor fixo, adequado para detentores de longo prazo. A arbitragem de curto prazo da BTC: 3,1% de queda para compra, 10% de posições, US \) 6.000 de valor fixo, 75% de margem de lucro para venda. ETH fluctuar colheita: compras de queda de 4,5%, 15% de posições, permitindo compras abaixo da linha de custo, 30% de margem de lucro.
Cada configuração foi testada e verificada, não é um parâmetro de cabeça batida.As diferenças entre o Sol e o XRP, com um limite de lucro de 35% e 10% respectivamente, refletem as variações de volatilidade e de liquidez entre os diferentes ativos.
Bloqueio em grupo: solução para o maior problema da estratégia DCA
O maior problema do DCA tradicional é não saber quando parar de comprar. Este protocolo resolve o problema com o “selado de cluster”: ou o preço aumenta 3,9% em relação ao custo médio, ou os 10 ciclos consecutivos de oportunidades de compra não qualificadas são selados no cluster acumulado atual.
A linha de custo médio após o selo é a referência para a venda。 só o preço quebra a linha de custo de vedação + o limiar de lucro (variando de 30% a 75%) para desencadear a venda。 Isso evita compras intermináveis e lucros prematuros。
O mecanismo do pilar de quietude é ainda melhor: se os 10 ciclos consecutivos não desencadearem condições de compra, o mercado está estabilizado e deve estar preparado para a colheita e não para o acúmulo.
Efeito volante: deixe os lucros comprar serviços para a próxima vez
Depois de ativar o modo de rotação, os lucros de cada venda são reinvestidos no pool de dinheiro, aumentando a munição para a próxima compra.A estratégia ganha força no mercado de touros。
Por exemplo: inicial de US\(100.000, primeira rodada acumula um lucro de 20% e, após a venda, o pool de dinheiro se transforma em US\)120.000. Na próxima compra, a posição de 6% é de US\(7.200 em vez de US\)6.000. Com o tempo, esse efeito de bola de neve aumenta significativamente os lucros.
Mas o volante também tem um custo: no final do mercado de touros, as pessoas compram demais por causa do grande estoque de dinheiro, o que exige um controle rigoroso do limite máximo de compra de um único volante.
Controle de riscos: o mecanismo de seguro triplo
Primeiro: controle de compra acima da linha de custo. Pode ser configurado apenas para comprar abaixo do custo médio, evitando a busca de alta. Segundo: Limitação de quantidade mínima. Cada compra/venda exige uma quantidade mínima de dólares, evitando transações insignificantes e pequenas. Terceiro: Ajuste do motor de oscilação. Aumente automaticamente o limiar de compra durante oscilações elevadas e reduza o limiar durante oscilações baixas.
Mas esta estratégia funciona em mercados de baixa volatilidade.Se o mercado estiver de lado por um longo período, sem provocar uma queda acentuada nas compras e sem atingir o limiar de lucro nas vendas, os fundos serão bloqueados por um longo período.
Sugestão de combate: a chave para o mercado
Este protocolo é mais adequado para mercados com uma clara tendência, especialmente para o comportamento cíclico das criptomoedas. Começa a se acumular no final do período de baixa e começa a ser colhido no meio do período de alta.
Não use em situações de: 1) mercado de ações com alta frequência de volatilidade 2) mercado de câmbio sem uma tendência clara 3) moedas pequenas com pouca liquidez.
A retrospectiva histórica mostra que os ganhos ajustados ao risco são superiores ao investimento simples, mas isso não significa que os lucros futuros sejam necessáriosQualquer estratégia de quantificação corre o risco de falhar e precisa ser constantemente monitorada e ajustada.
Código-fonte da estratégia
//@version=6
// ============================================================================
// ORACLE PROTOCOL — ARCH PUBLIC clone (Standalone) — CLEAN-PUB STYLE (derived)
// Variant: v1.9v-standalone (publish-ready) 25/11/2025
// Notes:
// - Keeps your v1.9v canonical script intact (this is a separate modified copy).
// - Single exit mode: ProfitGate + Candle (per-candle) — no selector.
// - Live ACB plot toggle only (sealed ACB still operates internally but is not shown).
// - No freeze-point markers plotted.
// - Sizing: flywheel dynamic sizing remains the primary source but fixed-dollar entry
// and min-$ overrides remain available (as in Arch public PDFs/screenshots).
// - Volatility Engine (VE) applies ONLY to entries; exit-side VE removed.
// - Manual equity top-up removed (flywheel auto-updates cash).
// - VE ATR length and max-vol fields are fixed (not exposed in UI).
// ============================================================================
strategy("Oracle Protocol — Arch Public (Clone) • v1.9v-standalone (publish)",
overlay=true,
initial_capital=100000,
commission_type=strategy.commission.percent,
commission_value=0.1,
pyramiding=9999,
calc_on_every_tick=true,
process_orders_on_close=true)
// ============================================================================
// 1) PRESETS (Arch PDFs)
// ============================================================================
grp_oracle = "Oracle — Core"
oraclePreset = input.string(
"BTC • Cycle Accumulation",
"Recipe Preset",
options = [
"BTC • Cycle Accumulation",
"BTC • Cycle Swing Arbitrage",
"BTC • Short Target Accumulation",
"BTC • Short Target Arbitrage",
"ETH • Volatility Harvesting",
"SOL • Volatility Harvesting",
"XRP • Volatility Harvesting",
"SUI • Volatility Harvesting"
],
group = grp_oracle)
var float longThreshPct = 0.0
var float exitThreshPct = 0.0
var bool onlySellAboveCost = true
var bool recipe_buyBelowACB = false
var float sellProfitGatePct = 0.0
var float entryPct = 0.0
var float exitPct = 0.0
var float fixedEntryUsd = 0.0
var float fixedExitUsd = 0.0
if oraclePreset == "BTC • Cycle Accumulation"
longThreshPct := 5.0
exitThreshPct := 3.9
onlySellAboveCost := true
recipe_buyBelowACB := false
sellProfitGatePct := 50.0
entryPct := 6.0
exitPct := 1.0
fixedEntryUsd := 500
fixedExitUsd := 500
else if oraclePreset == "BTC • Cycle Swing Arbitrage"
longThreshPct := 5.9
exitThreshPct := 3.5
onlySellAboveCost := true
recipe_buyBelowACB := false
sellProfitGatePct := 49.0
entryPct := 10.0
exitPct := 50.0
fixedEntryUsd := 10000
fixedExitUsd := 15000
else if oraclePreset == "BTC • Short Target Accumulation"
longThreshPct := 3.1
exitThreshPct := 2.5
onlySellAboveCost := true
recipe_buyBelowACB := false
sellProfitGatePct := 30.0
entryPct := 10.0
exitPct := 10.0
fixedEntryUsd := 6000
fixedExitUsd := 5000
else if oraclePreset == "BTC • Short Target Arbitrage"
longThreshPct := 3.1
exitThreshPct := 2.5
onlySellAboveCost := true
recipe_buyBelowACB := true
sellProfitGatePct := 75.0
entryPct := 10.0
exitPct := 100.0
fixedEntryUsd := 10000
fixedExitUsd := 5000
else if oraclePreset == "ETH • Volatility Harvesting"
longThreshPct := 4.5
exitThreshPct := 5.0
onlySellAboveCost := true
recipe_buyBelowACB := true
sellProfitGatePct := 30.0
entryPct := 15.0
exitPct := 40.0
fixedEntryUsd := 6000
fixedExitUsd := 20000
else if oraclePreset == "SOL • Volatility Harvesting"
longThreshPct := 5.0
exitThreshPct := 5.0
onlySellAboveCost := true
recipe_buyBelowACB := false
sellProfitGatePct := 35.0
entryPct := 7.0
exitPct := 5.0
fixedEntryUsd := 5000
fixedExitUsd := 5000
else if oraclePreset == "XRP • Volatility Harvesting"
longThreshPct := 4.5
exitThreshPct := 10.0
onlySellAboveCost := true
recipe_buyBelowACB := false
sellProfitGatePct := 10.0
entryPct := 17.0
exitPct := 50.0
fixedEntryUsd := 8000
fixedExitUsd := 5000
else if oraclePreset == "SUI • Volatility Harvesting"
longThreshPct := 5.0
exitThreshPct := 5.0
onlySellAboveCost := true
recipe_buyBelowACB := false
sellProfitGatePct := 10.0
entryPct := 5.0
exitPct := 10.0
fixedEntryUsd := 5000
fixedExitUsd := 15000
// ============================================================================
// 2) EXTRAS & VOLATILITY SPLITS (CLEAN PUBLIC VARIANTS)
// - Volatility engine inputs are fixed and not exposed in the UI
// ============================================================================
// UI group for extras (keeps flywheel toggle visible)
grp_extras = "Oracle — Extras"
useFlywheel = input.bool(true, "Reinvest Realized Profits (Flywheel)", group = grp_extras)
// Volatility engine: ENTRY only (VE params fixed, not shown)
useVolEngineEntry = input.bool(true, "Enable Volatility Engine (Entries only)", group = grp_extras)
// Fixed/hidden VE parameters (not exposed in UI per your request)
atrLen_fixed = 14
maxVolAdjPct_fixed = 40.0
// NOTE: manual_equity_topup removed for publish variant — flywheel handles auto top-up
buyBelowMode = input.string(
"Use Recipe Setting",
"Buy Below ACB Mode",
options = ["Use Recipe Setting", "Force Buy Below ACB", "Allow Buys Above ACB"],
group = grp_extras)
// ============================================================================
// 3) QUIET BARS (cluster seal) — unchanged behavior, UI visible
// ============================================================================
grp_qb = "Oracle — Quiet Bars (Cluster Seal)"
useQuietBars = input.bool(true, "Enable Quiet-Bars Seal", group=grp_qb)
quietBars = input.int(10, "Quiet Bars (no eligible buys)", minval=1, group=grp_qb)
// ============================================================================
// 4) SELL MODE — SINGLE ARCH EXIT (ProfitGate + Candle) ONLY
// (no selector; fixed behavior to match Arch public)
// ============================================================================
grp_sell = "Oracle — Sell Behaviour"
// no sellMode selector in this publish variant — fixed logic below
// ============================================================================
// 5) DISPLAY & PLOTS (simplified)
// - only Live ACB toggle remains visible.
// - sealed ACB and freeze points are intentionally not plotted.
// ============================================================================
grp_display = "Oracle — Display"
showLiveACB = input.bool(true, "Show Live ACB", group = grp_display)
acbColor = input.color(color.new(color.yellow, 0), "ACB Line Color", group = grp_display)
showExitGuides = input.bool(false, "Show Exit Guide Lines", group = grp_display)
// ============================================================================
// 6) 3C SIZING & MINIMUMS / OVERRIDES
// - primary sizing source is flywheel (cash ledger).
// - but fixed-entry USD and min-$ overrides remain (per Arch public).
// ============================================================================
grp_3c_sz = "Oracle — Sizing"
use3C = input.bool(true, "Enable 3Commas JSON Alerts", group = grp_3c_sz)
botTag = input.string("ORACLE", "Bot Tag / Pair Hint", group = grp_3c_sz)
// Keep min$/fixed entry & exit overrides visible (Arch style)
useMinEntry = input.bool(true, "Use Min $ on Entry", group = grp_oracle)
useMinExit = input.bool(true, "Use Min $ on Exit", group = grp_oracle)
manualMinEntry = input.float(0.0, "Manual Min $ Entry (0 = use recipe)", group = grp_oracle, step = 10)
manualMinExit = input.float(0.0, "Manual Min $ Exit (0 = use recipe)", group = grp_oracle, step = 10)
grp_override = "Oracle — Amount Override"
entryUsd_override = input.float(0.0, "Entry USD Override (0 = none)", group = grp_override, step = 10)
exitUsd_override = input.float(0.0, "Exit USD Override (0 = none)", group = grp_override, step = 10)
// ============================================================================
// 7) VOLATILITY ENGINE VALUES (ENTRY only)
// - VE uses fixed internal params (atrLen_fixed, maxVolAdjPct_fixed).
// - VE not applied to exits in this publish variant.
// ============================================================================
atrVal = ta.atr(atrLen_fixed)
volPct = atrVal / close * 100.0
volAdj = math.min(volPct, maxVolAdjPct_fixed)
longThreshEff = longThreshPct * (useVolEngineEntry ? (1 + volAdj/100.0) : 1)
// exit threshold is NOT adjusted by VE in this variant:
exitThreshEff = exitThreshPct
// ============================================================================
// 8) POSITION STATE & HELPERS
// ============================================================================
var float q = 0.0 // live coin quantity
var float cost = 0.0 // live position cost ($)
var float live_acb = 0.0 // live average cost (cost / q)
var float realized = 0.0
// Flywheel cash ledger (realised cash available for reinvest) — auto only
var float cash = na
if na(cash)
cash := strategy.initial_capital
// Cluster / gating state (sealed base) — sealed_acb still used internally but not shown
var bool clusterOpen = false
var float sealed_acb = na // frozen when a cluster seals (sealed accumulation base)
var int lastEntryBar = na
var int lastEligibleBuyBar = na // for quiet-bars seal
var int sell_steps_done = 0 // number of incremental exits already taken since gate armed
var float last_sell_ref = na // last sell price used for pullback re-arm (not used here)
var bool mode_single_sold = false // lock for Single per Rally (internal use)
// Helpers (array returns)
f_add_fill(_qty, _px, _q, _cost) =>
// returns newQty, newCost, newACB
_newCost = _cost + _qty * _px
_newQty = _q + _qty
_newACB = _newQty > 0 ? _newCost / _newQty : 0.0
array.from(_newQty, _newCost, _newACB)
f_reduce_fill(_qty, _px, _q, _cost) =>
// returns newQty, newCost, newACB, sellVal, costReduced, proportion
_sellVal = _qty * _px
_prop = _q > 0 ? _qty / _q : 0.0
_costReduced = _cost * _prop
_newCost = _cost - _costReduced
_newQty = _q - _qty
_newACB = _newQty > 0 ? _newCost / _newQty : 0.0
array.from(_newQty, _newCost, _newACB, _sellVal, _costReduced, _prop)
// ============================================================================
// 9) BUY SIGNALS & BUY-BELOW MODE
// ============================================================================
dropFromPrev = close[1] != 0 ? (close - close[1]) / close[1] * 100.0 : 0.0
wantBuy = dropFromPrev <= -longThreshEff
needBuyBelow = recipe_buyBelowACB
if buyBelowMode == "Force Buy Below ACB"
needBuyBelow := true
else if buyBelowMode == "Allow Buys Above ACB"
needBuyBelow := false
canBuyBelow = not needBuyBelow or (needBuyBelow and (live_acb == 0 or close < live_acb))
// Track “eligible” buys (quiet-bars gate references opportunity, not just fills)
if wantBuy and canBuyBelow
lastEligibleBuyBar := bar_index
// ============================================================================
// 10) SIZING (flywheel-driven; keep fixed/min-dollar options for entry & exit)
// ============================================================================
baseAcct = cash // flywheel only in this variant
// entry as percentage of baseAcct (dynamic) with fixed/min-dollar fallback (Arch-style)
entryUsd = baseAcct * (entryPct / 100.0)
// Entry min floor (keep manual/fixed options per Arch)
if useMinEntry
entryFloor = manualMinEntry > 0 ? manualMinEntry : fixedEntryUsd
entryUsd := math.max(entryUsd, entryFloor)
// override priority
entryUsd := entryUsd_override > 0 ? entryUsd_override : entryUsd
// entry qty
eQty = close > 0 ? entryUsd / close : 0.0
// Exit sizing: percentage of HOLDINGS (Arch) with min-$ fallback (unchanged)
exitQty_pct = q * (exitPct / 100.0)
exitFloorQty = close > 0 ? ( (manualMinExit > 0 ? manualMinExit : fixedExitUsd) / close ) : 0.0
xQty_base = math.max(exitQty_pct, exitFloorQty)
xQty = math.min(xQty_base, q)
xQty := exitUsd_override > 0 and close > 0 ? math.min(exitUsd_override / close, q) : xQty
// ============================================================================
// 11) ENTRY — opens/extends accumulation cluster; resets SELL steps
// Cash gate: only execute buy if cash >= entryUsd and on confirmed bar close
// ============================================================================
newEntry = false
entryCost = eQty * close
hasCash = entryCost > 0 and cash >= entryCost
if barstate.isconfirmed and wantBuy and canBuyBelow and eQty > 0 and hasCash
strategy.entry("ORACLE-LONG", strategy.long, qty=eQty, comment="ORACLE-BUY")
_fill = f_add_fill(eQty, close, q, cost)
q := array.get(_fill, 0)
cost := array.get(_fill, 1)
live_acb := array.get(_fill, 2)
cash -= entryCost
lastEntryBar := bar_index
lastEligibleBuyBar := bar_index
if not clusterOpen
clusterOpen := true
sealed_acb := na
sell_steps_done := 0
mode_single_sold := false
last_sell_ref := na
// set sealed_acb initial for cluster if na
if na(sealed_acb)
sealed_acb := live_acb
newEntry := true
// ============================================================================
// 12) CLUSTER SEAL — Exit-Threshold OR Quiet-Bars
// - On sealing, we freeze sealed_acb internally (not plotted).
// ============================================================================
riseFromLiveACB = live_acb > 0 ? (close - live_acb ) / live_acb * 100.0 : 0.0
sealByThresh = riseFromLiveACB >= exitThreshEff
barsSinceElig = na(lastEligibleBuyBar) ? 10000 : (bar_index - lastEligibleBuyBar)
sealByQuiet = useQuietBars and (barsSinceElig >= quietBars)
sealed_changed = false
if clusterOpen and (sealByThresh or sealByQuiet)
clusterOpen := false
// freeze sealed base as the last live_acb at seal time (preserve cycle anchor)
sealed_acb := live_acb
sell_steps_done := 0
mode_single_sold := false
last_sell_ref := na
sealed_changed := true
// ============================================================================
// 13) SELL LOGIC — SINGLE ARCH EXIT: ProfitGate + Candle (Per-Candle)
// - Profit gate base: use sealed refBase if present, otherwise live_acb (no toggle).
// - VE not applied to exits in this variant.
// ============================================================================
refBase = na(sealed_acb) ? live_acb : sealed_acb
riseFromRef = refBase > 0 ? (close - refBase) / refBase * 100.0 : 0.0
sellAboveOK = not onlySellAboveCost or close > live_acb
profitRefBase = refBase // sealed if available, else live_acb (no UI toggle in this variant)
// Basic profit gate price/boolean (uses profitRefBase)
profitGateLevelPrice = profitRefBase * (1 + sellProfitGatePct / 100.0)
profitGateCrossed = profitRefBase > 0 ? (close >= profitGateLevelPrice) : false
// Candle-based rise (percent move relative to previous close)
riseFromPrev = close[1] != 0 ? (close - close[1]) / close[1] * 100.0 : 0.0
candleRiseOK = riseFromPrev >= exitThreshEff
// Final allow-sell boolean for this publish variant (ProfitGate + Candle)
var bool allowSellThisBar = false
allowSellThisBar := false
allowSellThisBar := profitGateCrossed and candleRiseOK and xQty > 0 and q > 0 and sellAboveOK and barstate.isconfirmed
// Perform sell if allowed
actualExitQty = 0.0
if allowSellThisBar
actualExitQty := xQty
if actualExitQty > 0
strategy.close("ORACLE-LONG", qty = actualExitQty, comment = "ORACLE-SELL")
_r = f_reduce_fill(actualExitQty, close, q, cost)
q := array.get(_r, 0)
cost := array.get(_r, 1)
live_acb := array.get(_r, 2)
sellVal = array.get(_r, 3)
cRed = array.get(_r, 4)
tradePnL = sellVal - cRed
realized += tradePnL
cash += sellVal
sell_steps_done += 1
last_sell_ref := close
mode_single_sold := true
if q <= 0
// fully sold - reset sealed base and steps (internal)
sealed_acb := na
sell_steps_done := 0
mode_single_sold := false
last_sell_ref := na
// Re-arm logic (simplified): allow new sells only after retrace below refBase by exitThreshEff or if fully sold
if barstate.isconfirmed
if mode_single_sold
retrace_condition = not na(refBase) ? (close < refBase * (1 - exitThreshEff/100.0)) : false
if retrace_condition or q == 0
mode_single_sold := false
sell_steps_done := 0
last_sell_ref := na
// ============================================================================
// 14) BALANCES & 3C JSON (flywheel-based sizing)
// ============================================================================
cash_on_hand = math.max(cash, 0)
coin_value = q * close
total_equity = cash_on_hand + coin_value
base_for_3c = cash_on_hand // flywheel only in this publish variant
entryUsd_3c = base_for_3c * (entryPct / 100.0)
if useMinEntry
entryUsd_3c := math.max(entryUsd_3c, (manualMinEntry > 0 ? manualMinEntry : fixedEntryUsd))
entryUsd_3c := entryUsd_override > 0 ? entryUsd_override : entryUsd_3c
// ============================================================================
// 15) PLOTS (Data Window + Live ACB only + optional guides)
// - Sealed ACB and freeze markers intentionally NOT plotted in this variant.
// ============================================================================
plot(strategy.initial_capital, title="Initial Capital", color=color.white)
plot(q, title="Oracle Coin Qty", precision = 6)
plot(cost, title="Oracle Position Cost")
plot(coin_value, title="Oracle Coin Value")
plot(cash_on_hand, title="Oracle Cash On Hand")
plot(total_equity, title="Oracle Total Equity")
plot(live_acb > 0 and showLiveACB ? live_acb : na, title="Live ACB", color=color.new(color.orange,0), linewidth=2, style=plot.style_line)
// Exit guide lines reference refBase but are optional (kept for debugging/visual confirmation)
guide_exit_line = showExitGuides and not na(refBase) ? refBase * (1 + exitThreshEff/100.0) : na
guide_gate_line = showExitGuides and not na(refBase) ? refBase * (1 + sellProfitGatePct/100.0) : na
plot(guide_exit_line, title="Exit Threshold Line", display=showExitGuides ? display.all : display.none, linewidth=1, style=plot.style_linebr)
plot(guide_gate_line, title="Profit Gate Line (ref base)", display=showExitGuides ? display.all : display.none, linewidth=1, style=plot.style_linebr)
// Also plot the profit gate price computed from profitRefBase (if guides enabled)
plot(not na(profitRefBase) and showExitGuides ? profitRefBase * (1 + sellProfitGatePct/100.0) : na, title="Profit Gate (ref base)", display=showExitGuides ? display.all : display.none, linewidth=1, style=plot.style_line)