Liquidity Stress Exhaustion

indicator("Liquidity Stress Exhaustion", overlay = true, max_lines_count = 100, max_labels_count = 500, max_bars_back = 5000)

var string GRP_CORE = "⚙️ Core Settings"
int   IN_LEN_TREND    = input.int(50, "Trend Length", minval=10, group=GRP_CORE)
int   IN_LEN_STATS    = input.int(20, "Stats Lookback", minval=5, group=GRP_CORE)
float IN_THRESH_SIGMA = input.float(2.0, "Stress Threshold (σ)", step=0.1, group=GRP_CORE)
bool  IN_USE_DYN_LEN  = input.bool(false, "Dynamic Pivot Mode", group=GRP_CORE, tooltip="Adjusts regression length based on recent pivots.")
int   IN_FIX_LEN      = input.int(50, "Fixed Length", minval=5, group=GRP_CORE)
int   IN_PIV_LEFT     = input.int(20, "Pivot Left", minval=2, group=GRP_CORE)
int   IN_PIV_RIGHT    = input.int(20, "Pivot Right", minval=1, group=GRP_CORE)
int   IN_MAX_LOOKBACK = input.int(300, "Max Lookback Cap", minval=50, group=GRP_CORE)
float IN_DEV_IN       = input.float(1.0, "Inner Deviation", step=0.1, group=GRP_CORE)
float IN_DEV_OUT      = input.float(2.0, "Outer Deviation", step=0.1, group=GRP_CORE)

var string GRP_FILT = "🕯️ Filters"
bool  IN_USE_R_FILT   = input.bool(true, "Filter Weak Correlations", group=GRP_FILT)
float IN_R_THRESH     = input.float(0.5, "Pearson R Threshold", step=0.05, group=GRP_FILT)
bool  i_useAdxFilter  = input.bool(false, "📈 Use ADX Filter", group=GRP_FILT)
float i_adxThresh     = input.float(20.0, "ADX Threshold", group=GRP_FILT, minval=0, step=0.5)
int   i_adxLen        = input.int(14, "ADX Length", group=GRP_FILT, minval=1)
string i_adaptFilterType = input.string("None", "🧠 Adaptive Filter", options=["None", "Kalman Filter", "LLAMA"], group=GRP_FILT)
int   i_adaptFilterLen   = input.int(20, "Adaptive Filter Length", group=GRP_FILT, minval=1)

var string GRP_TRADE = "📐 Trade Tools"
bool  i_lockSignal    = input.bool(false, "🔒 Lock Signal", group=GRP_TRADE, tooltip="Freeze current signal · block new ones")
float i_atrMult       = input.float(1.5, "ATR SL Multiplier", minval=0.1, step=0.1, group=GRP_TRADE)
int   i_atrLen        = input.int(14, "ATR Length", minval=1, group=GRP_TRADE)
float i_tp1R          = input.float(1.0, "TP1 (R Multiple)", minval=0.1, step=0.1, group=GRP_TRADE)
float i_tp2R          = input.float(2.0, "TP2 (R Multiple)", minval=0.1, step=0.1, group=GRP_TRADE)
float i_tp3R          = input.float(3.0, "TP3 (R Multiple)", minval=0.1, step=0.1, group=GRP_TRADE)

var string GRP_VIS = "🎨 Visuals"
bool  IN_SHOW_METRICS = input.bool(true, "Show Metrics Label", group=GRP_VIS)
float IN_WIDTH_HIGH   = input.float(3.0, "High Volatility Width %", minval=0.1, step=0.1, group=GRP_VIS)
float IN_WIDTH_LOW    = input.float(1.0, "Low Volatility Width %", minval=0.1, step=0.1, group=GRP_VIS)
string IN_EXT_MODE    = input.string("None", "Line Extension", options=["None", "Left", "Right", "Both"], group=GRP_VIS)

var string GRP_DASH = "📊 Dashboard"
string i_dashPos = input.string("Top Right", "Dashboard Position", options=["Top Right", "Top Left", "Bottom Right", "Bottom Left"], group=GRP_DASH)

var string GRP_WH = "🔔 Alerts"
string i_actionSellerExh = input.string("seller_exhaustion", "Seller Exhaustion Action", group=GRP_WH)
string i_actionBuyerExh  = input.string("buyer_exhaustion",  "Buyer Exhaustion Action",  group=GRP_WH)
string i_actionTp1       = input.string("tp1_hit", "TP1 Hit Action", group=GRP_WH)
string i_actionTp2       = input.string("tp2_hit", "TP2 Hit Action", group=GRP_WH)
string i_actionTp3       = input.string("tp3_hit", "TP3 Hit Action", group=GRP_WH)
string i_actionSlHit     = input.string("sl_hit",  "SL Hit Action",  group=GRP_WH)

var string GRP_STYLE = "🌈 Colors"
color IN_C_BULL   = input.color(#00e5ff, "Bullish / Seller Exhaustion", group=GRP_STYLE)
color IN_C_BEAR   = input.color(#ff2ee6, "Bearish / Buyer Exhaustion", group=GRP_STYLE)
color IN_C_NEUT   = input.color(#7a7fa3, "Neutral / Weak Correlation", group=GRP_STYLE)
color IN_C_TXT    = input.color(#FFFFFF, "Text Color", group=GRP_STYLE)
color IN_C_BG     = input.color(#131722, "Label Background", group=GRP_STYLE)
color C_DASH_HDR  = input.color(color.new(#3a2a6d, 55), "Dashboard Header", group=GRP_STYLE)
color C_DASH_BG   = input.color(color.new(#0a0f1a, 10), "Dashboard Background", group=GRP_STYLE)
color C_DASH_TXT  = input.color(#ffffff, "Dashboard Text", group=GRP_STYLE)
color C_SL        = input.color(#ef5350, "SL Line", group=GRP_STYLE)
color C_ENTRY     = input.color(#2196f3, "Entry Line", group=GRP_STYLE)
color C_TP1       = input.color(color.new(#26a69a, 40), "TP1 Line", group=GRP_STYLE)
color C_TP2       = input.color(color.new(#26a69a, 20), "TP2 Line", group=GRP_STYLE)
color C_TP3       = input.color(color.new(#26a69a, 0), "TP3 Line", group=GRP_STYLE)
color C_RISK_FILL = input.color(color.new(#ef5350, 80), "Risk Zone Fill", group=GRP_STYLE)
color C_REWARD_FILL = input.color(color.new(#26a69a, 85), "Reward Zone Fill", group=GRP_STYLE)

type StressEngine
    float raw_illiquidity
    float z_score
    bool  is_high_stress

type RegMetrics
    float startPrice
    float endPrice
    float stdDev
    float pearsonR
    bool  isValid
    int   length

type ChannelDrawings
    line     mid
    line     topOut
    line     botOut
    line     topIn
    line     botIn
    linefill fill
    label    stats

type TradeLevels
    line     slLine
    line     entryLine
    line     tp1Line
    line     tp2Line
    line     tp3Line
    label    slLbl
    label    entryLbl
    label    tp1Lbl
    label    tp2Lbl
    label    tp3Lbl
    linefill riskFill
    linefill rewardFill

method update(StressEngine self, int len, float threshold) =>
    float vol_safe = (na(volume) or volume == 0) ? 1.0 : volume
    float impact = ta.tr(true) / vol_safe
    self.raw_illiquidity := math.log(impact + 1)
    float mean = ta.sma(self.raw_illiquidity, len)
    float std  = ta.stdev(self.raw_illiquidity, len)
    self.z_score := (std == 0 or na(std)) ? 0.0 : (self.raw_illiquidity - mean) / std
    self.is_high_stress := (self.z_score > threshold)

get_ext_mode(string s) =>
    switch s
        "Left"  => extend.left
        "Right" => extend.right
        "Both"  => extend.both
        => extend.none

f_pivotHigh(float src, int leftLen, int rightLen) =>
    float pivVal = src[rightLen]
    bool isPivot = true
    if bar_index >= leftLen + rightLen
        for i = 0 to leftLen + rightLen
            if i != leftLen and src[i] > pivVal
                isPivot := false
                break
    else
        isPivot := false
    isPivot ? pivVal : na

f_pivotLow(float src, int leftLen, int rightLen) =>
    float pivVal = src[rightLen]
    bool isPivot = true
    if bar_index >= leftLen + rightLen
        for i = 0 to leftLen + rightLen
            if i != leftLen and src[i] < pivVal
                isPivot := false
                break
    else
        isPivot := false
    isPivot ? pivVal : na

f_kalman(float src, int len) =>
    var float _est = na
    var float _err = 1.0
    float _q = 1.0 / len
    float _r = 1.0
    _est := na(_est) ? src : _est
    float _predErr = _err + _q
    float _gain = _predErr / (_predErr + _r)
    _est := _est + _gain * (src - _est)
    _err := (1 - _gain) * _predErr
    _est

f_llama(float src, int len) =>
    float _mean = ta.sma(src, len)
    float _slope = (src - src[len]) / len
    _mean + _slope * (len / 2)

calc_regression_metrics(int length) =>
    if length < 2
        RegMetrics.new(na, na, na, na, false, length)
    else
        int actual_len = 0
        for i = 0 to length - 1
            if not na(hlc3[i])
                actual_len := i + 1
            else
                break
        if actual_len < 2
            RegMetrics.new(na, na, na, na, false, 0)
        else
            float n       = float(actual_len)
            float n_minus = n - 1.0
            float sum_x   = (n * n_minus) / 2.0
            float sum_x2  = (n * n_minus * (2.0 * n - 1.0)) / 6.0
            float sum_y   = 0.0
            float sum_xy  = 0.0
            float sum_y2  = 0.0
            for i = 0 to actual_len - 1
                float val   = hlc3[i]
                float x_val = n_minus - float(i)
                if not na(val)
                    sum_y  += val
                    sum_xy += x_val * val
                    sum_y2 += val * val
            float denom = n * sum_x2 - sum_x * sum_x
            float slope = denom != 0 ? (n * sum_xy - sum_x * sum_y) / denom : 0.0
            float inter = (sum_y - slope * sum_x) / n
            float var_val = (sum_y2 - (sum_y * sum_y) / n) / n
            float std_dev = math.sqrt(math.max(0.0, var_val))
            float r_num   = n * sum_xy - sum_x * sum_y
            float r_den_y = n * sum_y2 - sum_y * sum_y
            float r_den   = math.sqrt(math.max(0.0, denom * r_den_y))
            float r_coef  = r_den != 0 ? r_num / r_den : 0.0
            float y_start = inter
            float y_end   = inter + slope * n_minus
            RegMetrics.new(y_start, y_end, std_dev, r_coef, true, actual_len)

var StressEngine stress_eng = StressEngine.new(0.0, 0.0, false)
stress_eng.update(IN_LEN_STATS, IN_THRESH_SIGMA)

float _adaptedClose = i_adaptFilterType == "Kalman Filter" ? f_kalman(close, i_adaptFilterLen) : i_adaptFilterType == "LLAMA" ? f_llama(close, i_adaptFilterLen) : close

float trend_ema = ta.ema(_adaptedClose, IN_LEN_TREND)
bool is_downtrend = _adaptedClose < trend_ema
bool is_uptrend   = _adaptedClose > trend_ema

[_diPlus, _diMinus, _adxVal] = ta.dmi(i_adxLen, i_adxLen)
bool _adxPass = not i_useAdxFilter or _adxVal >= i_adxThresh

StressEngine stressPrev = na(stress_eng[1]) ? StressEngine.new(0.0, 0.0, false) : stress_eng[1]
bool _rawSellerExhaustion = stressPrev.is_high_stress and is_downtrend[1] and (close[1] < open[1])
bool _rawBuyerExhaustion  = stressPrev.is_high_stress and is_uptrend[1] and (close[1] > open[1])

bool seller_exhaustion = _rawSellerExhaustion and _adxPass[1]
bool buyer_exhaustion  = _rawBuyerExhaustion  and _adxPass[1]

float _atr = ta.atr(i_atrLen)

var float slPriceLong    = na
var float entryPriceLong = na
var float tp1PriceLong   = na
var float tp2PriceLong   = na
var float tp3PriceLong   = na
var float slPriceShort    = na
var float entryPriceShort = na
var float tp1PriceShort   = na
var float tp2PriceShort   = na
var float tp3PriceShort   = na

bool _locked = i_lockSignal and barstate.islast
bool _commit = barstate.isconfirmed

if seller_exhaustion and not _locked and _commit
    entryPriceLong := close
    slPriceLong    := entryPriceLong - _atr * i_atrMult
    float _rLong   = entryPriceLong - slPriceLong
    tp1PriceLong   := entryPriceLong + _rLong * i_tp1R
    tp2PriceLong   := entryPriceLong + _rLong * i_tp2R
    tp3PriceLong   := entryPriceLong + _rLong * i_tp3R

if buyer_exhaustion and not _locked and _commit
    entryPriceShort := close
    slPriceShort    := entryPriceShort + _atr * i_atrMult
    float _rShort   = slPriceShort - entryPriceShort
    tp1PriceShort   := entryPriceShort - _rShort * i_tp1R
    tp2PriceShort   := entryPriceShort - _rShort * i_tp2R
    tp3PriceShort   := entryPriceShort - _rShort * i_tp3R

bool _slHitLong    = not na(slPriceLong)  and low  <= slPriceLong
bool _slHitShort   = not na(slPriceShort) and high >= slPriceShort
bool tp1HitLong    = not na(tp1PriceLong)  and high >= tp1PriceLong
bool tp2HitLong    = not na(tp2PriceLong)  and high >= tp2PriceLong
bool tp3HitLong    = not na(tp3PriceLong)  and high >= tp3PriceLong
bool tp1HitShort   = not na(tp1PriceShort) and low  <= tp1PriceShort
bool tp2HitShort   = not na(tp2PriceShort) and low  <= tp2PriceShort
bool tp3HitShort   = not na(tp3PriceShort) and low  <= tp3PriceShort

var string activeDir = na
var float  activeSl   = na
var float  activeEn   = na
var float  activeTp1  = na

if seller_exhaustion and not _locked and _commit
    activeDir := "long"
    activeSl  := slPriceLong
    activeEn  := entryPriceLong
    activeTp1 := tp1PriceLong
if buyer_exhaustion and not _locked and _commit
    activeDir := "short"
    activeSl  := slPriceShort
    activeEn  := entryPriceShort
    activeTp1 := tp1PriceShort

bool _positionClosed = (activeDir == "long"  and (_slHitLong  or tp3HitLong))  or  (activeDir == "short" and (_slHitShort or tp3HitShort))
if _positionClosed
    activeDir := na
    activeSl  := na
    activeEn  := na
    activeTp1 := na

var int piv_idx = na
float ph = f_pivotHigh(high, IN_PIV_LEFT, IN_PIV_RIGHT)
float pl = f_pivotLow(low, IN_PIV_LEFT, IN_PIV_RIGHT)

if not na(ph) or not na(pl)
    piv_idx := bar_index[IN_PIV_RIGHT]

if seller_exhaustion and _commit
    label.new(bar_index, low, text="SE", style=label.style_label_up, color=IN_C_BULL, textcolor=IN_C_TXT, size=size.normal, yloc=yloc.belowbar)
if buyer_exhaustion and _commit
    label.new(bar_index, high, text="BE", style=label.style_label_down, color=IN_C_BEAR, textcolor=IN_C_TXT, size=size.normal, yloc=yloc.abovebar)
var table wm = table.new(position.bottom_right, 1, 1)
if barstate.isfirst
    table.cell(wm, 0, 0, "Telegram @SimpleForexTools", text_color = color.new(color.gray, 70), text_size = size.large)

string _sellerInner = str.format(
 '"action":"{0}","ticker":"{1}","tf":"{2}","direction":"long","entry":"{3}","sl":"{4}","tp1":"{5}","tp2":"{6}","tp3":"{7}","zscore":"{8}"',
 i_actionSellerExh, syminfo.tickerid, timeframe.period,
 str.tostring(entryPriceLong, format.mintick),
 str.tostring(slPriceLong,    format.mintick),
 str.tostring(tp1PriceLong,   format.mintick),
 str.tostring(tp2PriceLong,   format.mintick),
 str.tostring(tp3PriceLong,   format.mintick),
 str.tostring(stress_eng.z_score, "#.##"))
string sellerPayload = "{" + _sellerInner + "}"

string _buyerInner = str.format(
 '"action":"{0}","ticker":"{1}","tf":"{2}","direction":"short","entry":"{

Показано первые 50% кода (символов: 22409)