Protocole du moteur à vagues
ATR volatility ACCUMULATION DCA
ianzeng123
Ce n’est pas un DCA ordinaire, c’est un moteur oscillant avec un cerveau
Les données de suivi vont à l’encontre de l’investissement traditionnel: une baisse de 5% a déclenché des achats, une hausse de 3,9% a déclenché des ventes, mais la clé est que les investisseurs ne se sentent pas gênés par la baisse des prix.Le moteur de fluctuation achète des valeurs basses en fonction de la dynamique ATR◦ La plus grande volatilité du marché, plus le seuil d’achat est élevé et peut être ajusté jusqu’à 40%. Cela signifie que pendant les périodes de forte volatilité, la stratégie attend des baisses plus importantes pour entrer en jeu.
Le problème avec les stratégies traditionnelles de DCA est qu’ils sont achetés sans cerveau, et la logique centrale de ce protocole est que les DCA ne sont pas des logiciels de vente.Il n’y a pas d’occasion pour que les gens ne tirent qu’une fois qu’ils ont une chance.❚ Calculer le taux de volatilité actuel via l’ATR (14), puis ajuster dynamiquement les paramètres de longThreshPct. Par exemple, acheter avec une baisse de 5% normale, mais si le taux de volatilité actuel atteint 20%, la dépréciation de l’achat réel sera portée à 6%.
8 configurations prédéfinies, chacune avec une prévision de revenus claire
Mode d’accumulation cyclique de BTC: achat à 5% de baisse, position à 6%, montant fixe de 500 \(, adapté aux détenteurs à long terme. Le modèle d'arbitrage à court terme de BTC: achat à 3,1% de baisse, 10% de position, montant fixe de 6000 \), seuil de profit de 75% vendu. ETH fluctuation récolte: achat à la baisse de 4,5%, 15% de positions, achat autorisé en dessous de la ligne de coût, seuil de profit de 30%
Chaque configuration est vérifiée par des tests, pas par des paramètres qui ont été décidés par un coup de tête.Les différences entre SOL et XRP sont de 35% et 10% de marge de profit, ce qui reflète les caractéristiques volatiles et les différences de liquidité des différents actifs.
Le blocage collectif: le plus gros problème de la stratégie DCA
Le plus gros problème avec les DCA traditionnels est de ne pas savoir quand arrêter d’acheter. Ce protocole utilise le “cluster sealing”: soit le prix est augmenté de 3,9% par rapport au coût moyen, soit 10 cycles consécutifs d’opportunités d’achat non qualifiées, et le cluster actuel est scellé.
La ligne de coût moyen après le scellement devient une référence pour la vente❚ Les ventes sont déclenchées uniquement lorsque le prix franchit le seuil de coût de clôture + le seuil de profit (entre 30 et 75%).
Le mécanisme de la colonne de calme est un miracle: si les 10 cycles consécutifs ne déclenchent pas de conditions d’achat, cela signifie que le marché est stable et qu’il faut se préparer à la récolte plutôt qu’à l’accumulation.
L’effet volant: les bénéfices achètent des services pour la prochaine fois
Après l’activation du mode tourbillon, les bénéfices de chaque vente sont réinvestis dans le pool de trésorerie, ce qui augmente la quantité de munitions à acheter la prochaine fois.La stratégie prend de l’ampleur sur le marché haussier。
Exemple: 100 000 \( initiaux, 20% de profit accumulé au premier tour, 120 000 \) de cash pool après la vente. La prochaine fois que vous achetez, la position de 6% est de 7 200 \( au lieu de 6 000 \). Avec le temps, cet effet boule de neige augmente considérablement les gains.
Mais le volant a aussi un coût: les achats excessifs à la fin de la période du marché haussier en raison d’un pool de liquidités trop important nécessitent un contrôle strict de la limite supérieure d’achat unique.
Contrôle des risques: le triple mécanisme d’assurance
Premièrement, le contrôle des achats au-dessus de la ligne de coût. Il est possible de régler les achats au-dessous du coût moyen, afin d’éviter de les augmenter. Deuxièmement: Limitation du montant minimum. Chaque achat/vente doit avoir un montant minimum en dollars, afin d’éviter des transactions insignifiantes. Troisièmement: réglage du moteur oscillant. Augmentation automatique du seuil d’achat pendant les hautes oscillations et baisse du seuil pendant les basses oscillations.
Mais cette stratégie fonctionne généralement en cas de choc.Si le marché est à la baisse pendant une longue période, ne peut pas déclencher une forte baisse des achats et ne peut pas atteindre le seuil de profit de vente, les fonds seront bloqués pendant une longue période.
Conseils de guerre: Le choix du marché est essentiel
Ce type d’accord est le mieux adapté aux marchés qui ont une tendance claire, en particulier à la cyclicité des crypto-monnaies. Il est préférable de commencer à accumuler à la fin d’un marché baissier et de commencer à récolter à la mi-course du marché haussier.
Ne pas utiliser dans les situations suivantes: 1) un marché boursier très volatile 2) un marché de change sans tendance claire 3) des pièces de monnaie de petite taille extrêmement peu liquides.
Les retours d’expérience montrent que les gains ajustés pour le risque sont supérieurs aux investissements simples, mais cela ne signifie pas que les bénéfices à venir seront inévitables.Toutes les stratégies de quantification présentent un risque d’échec et nécessitent une surveillance et un ajustement constants.
//@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)