//+------------------------------------------------------------------+ //| Smart Liquidity Hunter v1.11 - standalone MT4 / MT5 source | //| MIT License - Smart Liquidity Hunter contributors | //| OHLC-based liquidity proxy. Does not read actual orders/stops. | //| Confirmed signals use closed bars only; no automatic trading. | //+------------------------------------------------------------------+ #property strict #property copyright "Smart Liquidity Hunter contributors" #property link "https://www.mql5.com/en/code" #property version "1.11" #property description "Closed-bar swing sweeps with rejection, volatility and freshness filters." #property indicator_chart_window #property indicator_buffers 4 #ifdef __MQL5__ #property indicator_plots 4 #property indicator_label1 "Bullish liquidity sweep" #property indicator_type1 DRAW_ARROW #property indicator_width1 2 #property indicator_label2 "Bearish liquidity sweep" #property indicator_type2 DRAW_ARROW #property indicator_width2 2 #property indicator_label3 "Buy-side liquidity (swing high)" #property indicator_type3 DRAW_LINE #property indicator_style3 STYLE_DOT #property indicator_width3 1 #property indicator_label4 "Sell-side liquidity (swing low)" #property indicator_type4 DRAW_LINE #property indicator_style4 STYLE_DOT #property indicator_width4 1 #endif #property indicator_color1 clrLimeGreen #property indicator_color2 clrTomato #property indicator_color3 clrOrangeRed #property indicator_color4 clrDeepSkyBlue //==================================================================== // Shared signal rules in the MT4 and MT5 standalone editions. // Index 0 is the unfinished candle. All signals are calculated on // index >= 1 using only information confirmed before that candle. //==================================================================== input int SwingStrength = 3; // Pivot bars on EACH side input int MaxSwingAge = 100; // Maximum age of a pivot (bars) input int MaxBarsToScan = 1000; // Historical bars to calculate input int MinSweepPoints = 12; // Minimum penetration in points input int VolatilityPeriod = 14; // Mean true range lookback input double MinSweepVolRatio = 0.10; // Sweep >= ratio * mean TR input double MinWickPercent = 25.0; // Minimum rejection wick / range input double MinCloseLocationPct = 60.0; // Close in top/bottom % of candle input bool RequireFreshLevel = true; // Ignore previously pierced level input bool RequireCandleColor = false; // Bull close>open; bear close= 1 && SwingStrength <= 20 && MaxSwingAge >= SwingStrength + 1 && MaxSwingAge <= 2000 && MaxBarsToScan >= 50 && MaxBarsToScan <= 10000 && MinSweepPoints >= 0 && VolatilityPeriod >= 2 && VolatilityPeriod <= 500 && MinSweepVolRatio >= 0.0 && MinWickPercent >= 0.0 && MinWickPercent <= 100.0 && MinCloseLocationPct >= 0.0 && MinCloseLocationPct <= 100.0 && ArrowPaddingPoints >= 0 && ArrowOffsetVolRatio >= 0.0 && DashboardX >= 0 && DashboardY >= 0 && StringLen(DashboardInstanceId) >= 1 && StringLen(DashboardInstanceId) <= 40 && MathIsValidNumber(MinSweepVolRatio) && MathIsValidNumber(MinWickPercent) && MathIsValidNumber(MinCloseLocationPct) && MathIsValidNumber(ArrowOffsetVolRatio)); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool IsSwingHigh(const int j, const int bars, const double &h[]) { if(j - SwingStrength < 0 || j + SwingStrength >= bars) return(false); for(int n=1; n<=SwingStrength; n++) { // Equal older highs are permitted, equal newer highs are not. if(h[j] <= h[j-n] || h[j] < h[j+n]) return(false); } return(true); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool IsSwingLow(const int j, const int bars, const double &l[]) { if(j - SwingStrength < 0 || j + SwingStrength >= bars) return(false); for(int n=1; n<=SwingStrength; n++) { // Equal older lows are permitted, equal newer lows are not. if(l[j] >= l[j-n] || l[j] > l[j+n]) return(false); } return(true); } // Find the nearest ALREADY CONFIRMED pivot, optionally rejecting // a level if ANY intermediary candle pierced it before bar i. int FindLevel(const bool highSide, const int i, const int bars, const double &h[], const double &l[]) { const int first = i + SwingStrength + 1; const int last = (int)MathMin(i + MaxSwingAge, bars-SwingStrength-1); if(first > last) return(-1); // Extremes of bars between i and candidate j. Excludes i and j. // One forward pass replaces the previous per-candidate nested scan. double priorHigh = -DBL_MAX, priorLow = DBL_MAX; if(RequireFreshLevel) for(int k=i+1; k= l[j]-0.01*_Point); if(fresh) return(j); } if(RequireFreshLevel) {priorHigh=MathMax(priorHigh,h[j]); priorLow=MathMin(priorLow,l[j]);} } return(-1); } // Simple mean of historical true ranges. No future candles and no // broker-specific iATR handle: same algorithm on both platforms. // Returns -1 when the complete preceding window is unavailable. double MeanTRBefore(const int i, const int bars, const double &h[], const double &l[], const double &c[]) { if(i + VolatilityPeriod + 1 >= bars) return(-1.0); double totalTR = 0.0; for(int k=i+1; k<=i+VolatilityPeriod; k++) { const double tr1 = h[k] - l[k]; const double tr2 = MathAbs(h[k] - c[k+1]); const double tr3 = MathAbs(l[k] - c[k+1]); totalTR += MathMax(tr1,MathMax(tr2,tr3)); } return(totalTR / (double)VolatilityPeriod); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool RejectionPass(const bool bullish, const int i, const double &o[],const double &h[], const double &l[],const double &c[]) { const double range = h[i] - l[i]; if(range <= 0.0) return(false); const double wick = bullish ? (MathMin(o[i],c[i]) - l[i]) : (h[i] - MathMax(o[i],c[i])); const double location = bullish ? ((c[i]-l[i])/range)*100.0 : ((h[i]-c[i])/range)*100.0; if(100.0*wick/range + 1e-9 < MinWickPercent) return(false); if(location + 1e-9 < MinCloseLocationPct) return(false); if(RequireCandleColor && bullish && c[i] <= o[i]) return(false); if(RequireCandleColor && !bullish && c[i] >= o[i]) return(false); return(true); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CalculateBar(const int i,const int bars, const double &o[],const double &h[], const double &l[],const double &c[]) { BullSignal[i] = EMPTY_VALUE; BearSignal[i] = EMPTY_VALUE; BuySideLevel[i] = EMPTY_VALUE; SellSideLevel[i] = EMPTY_VALUE; const int sh = FindLevel(true,i,bars,h,l); const int sl = FindLevel(false,i,bars,h,l); if(sh >= 0) BuySideLevel[i] = h[sh]; if(sl >= 0) SellSideLevel[i] = l[sl]; // The unfinished bar (0) is shown only as a level extension. if(i == 0) return; const double meanTR = MeanTRBefore(i,bars,h,l,c); if(meanTR < 0.0) return; const double requiredSweep = MathMax(MinSweepPoints*_Point, MinSweepVolRatio*meanTR); bool bull = (sl >= 0 && l[i] < l[sl]-requiredSweep && c[i] > l[sl] && RejectionPass(true,i,o,h,l,c)); bool bear = (sh >= 0 && h[i] > h[sh]+requiredSweep && c[i] < h[sh] && RejectionPass(false,i,o,h,l,c)); // An outside bar that sweeps both sides is ambiguous, not two trades. if(bull && bear) return; const double padding = MathMax(ArrowPaddingPoints*_Point, ArrowOffsetVolRatio*meanTR); if(bull) BullSignal[i] = l[i] - padding; if(bear) BearSignal[i] = h[i] + padding; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ string PriceOrDash(const double price) { return(price == EMPTY_VALUE ? "--" : DoubleToString(price,_Digits)); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ string PeriodLabel() { string label=EnumToString((ENUM_TIMEFRAMES)_Period); StringReplace(label,"PERIOD_",""); return(label); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void SetPanelLine(const string key,const string words, const int row,const int fontSize,const color textColor) { const string name = g_panel_prefix + key; if(ObjectFind(0,name)<0) if(!ObjectCreate(0,name,OBJ_LABEL,0,0,0)) return; ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_UPPER); ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_LEFT_UPPER); ObjectSetInteger(0,name,OBJPROP_XDISTANCE,DashboardX); ObjectSetInteger(0,name,OBJPROP_YDISTANCE,DashboardY + row*19); ObjectSetInteger(0,name,OBJPROP_FONTSIZE,fontSize); ObjectSetInteger(0,name,OBJPROP_COLOR,textColor); ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false); ObjectSetInteger(0,name,OBJPROP_HIDDEN,true); ObjectSetString(0,name,OBJPROP_FONT,"Consolas"); ObjectSetString(0,name,OBJPROP_TEXT,words); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void UpdateDashboard(const int bars,const datetime &time[]) { if(!ShowDashboard) return; SetPanelLine("Header","SLH v1.11 | "+_Symbol+" "+PeriodLabel(), 0,10,DashboardTextColor); SetPanelLine("Levels","Buy-side: "+PriceOrDash(BuySideLevel[0])+ " | Sell-side: "+PriceOrDash(SellSideLevel[0]), 1,9,DashboardTextColor); string last = "Last signal: none in scanned history"; const int cap = (int)MathMin(MaxBarsToScan,bars-1); for(int i=1; i<=cap; i++) { if(BullSignal[i]!=EMPTY_VALUE) {last="Last signal: BULLISH "+TimeToString(time[i],TIME_DATE|TIME_MINUTES); break;} if(BearSignal[i]!=EMPTY_VALUE) {last="Last signal: BEARISH "+TimeToString(time[i],TIME_DATE|TIME_MINUTES); break;} } SetPanelLine("Last",last,2,9,DashboardTextColor); SetPanelLine("Note","OHLC proxy | confirmed closed candles only",3,8,DashboardTextColor); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void FireClosedBarNotice(const datetime &time[]) { if(!AlertPopup && !AlertSound && !AlertPush) return; if(time[1] == g_last_alert_time) return; string kind = ""; if(BullSignal[1]!=EMPTY_VALUE) kind="BULLISH sweep"; if(BearSignal[1]!=EMPTY_VALUE) kind="BEARISH sweep"; if(kind=="") return; g_last_alert_time=time[1]; const string message = "SLH | "+_Symbol+" "+PeriodLabel()+" | "+kind+ " | "+TimeToString(time[1],TIME_DATE|TIME_MINUTES); if(AlertPopup) Alert(message); if(AlertSound) PlaySound("alert.wav"); if(AlertPush) { ResetLastError(); if(!SendNotification(message)) Print("SLH: push notification failed, error ",GetLastError()); } } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void RemoveDashboard() { if(g_panel_prefix=="") return; ObjectDelete(0,g_panel_prefix+"Header"); ObjectDelete(0,g_panel_prefix+"Levels"); ObjectDelete(0,g_panel_prefix+"Last"); ObjectDelete(0,g_panel_prefix+"Note"); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void ClearAllBuffers() { ArrayInitialize(BullSignal,EMPTY_VALUE); ArrayInitialize(BearSignal,EMPTY_VALUE); ArrayInitialize(BuySideLevel,EMPTY_VALUE); ArrayInitialize(SellSideLevel,EMPTY_VALUE); } // Locate the former open candle by timestamp, including when chart // history is capped and rates_total does not grow on each new bar. int NewlyClosedBars(const int bars,const datetime &time[]) { const int cap=(int)MathMin(bars-1,MaxBarsToScan); for(int i=1; i<=cap; i++) if(time[i]==g_last_open_time) return(i); return(-1); // Large gap, changed time series, or old marker unavailable. } // Called by the platform-specific OnCalculate wrapper. int SLHCalculate(const int rates_total,const int prev_calculated, const datetime &time[],const double &open[], const double &high[],const double &low[], const double &close[]) { ArraySetAsSeries(time,true); ArraySetAsSeries(open,true); ArraySetAsSeries(high,true); ArraySetAsSeries(low,true); ArraySetAsSeries(close,true); const int minimumBars=(int)MathMax(2*SwingStrength+3,VolatilityPeriod+3); if(rates_total < minimumBars) { ClearAllBuffers(); g_last_open_time=0; RemoveDashboard(); if(ShowDashboard) SetPanelLine("Header","SLH v1.11 | waiting for more price history",0,10,DashboardTextColor); return(0); } bool full=(prev_calculated<=0 || prev_calculated>rates_total || g_last_open_time==0); const bool newbar=(g_last_open_time!=time[0]); // Unexpected size change without a new candle needs a clean rebuild. if(!full && !newbar && rates_total!=prev_calculated) full=true; if(!full && !newbar) return(rates_total); int added=0; if(!full && newbar) { added=NewlyClosedBars(rates_total,time); if(added<1) full=true; } if(full) ClearAllBuffers(); const int maximum=(int)MathMin(MaxBarsToScan,rates_total-2*SwingStrength-2); const int start=full ? maximum : (int)MathMin(added,maximum); for(int i=start; i>=1; i--) { if(IsStopped()) return(0); CalculateBar(i,rates_total,open,high,low,close); } // Old output shifts right with every candle. Keep the display bounded // so a refresh and incremental updates use the same historical window. if(!full) { const int clearTo=(int)MathMin(rates_total-1,maximum+added); for(int i=maximum+1; i<=clearTo; i++) { BullSignal[i]=EMPTY_VALUE; BearSignal[i]=EMPTY_VALUE; BuySideLevel[i]=EMPTY_VALUE; SellSideLevel[i]=EMPTY_VALUE; } } CalculateBar(0,rates_total,open,high,low,close); UpdateDashboard(rates_total,time); // No alerts on attachment, history resets, or catch-up batches. if(!full && newbar && added==1) FireClosedBarNotice(time); g_last_open_time=time[0]; return(rates_total); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int OnInit() { if(!ValidInputs()) {Print("SLH: invalid input parameters"); return(INIT_FAILED);} if(!SetIndexBuffer(0,BullSignal,INDICATOR_DATA) || !SetIndexBuffer(1,BearSignal,INDICATOR_DATA) || !SetIndexBuffer(2,BuySideLevel,INDICATOR_DATA) || !SetIndexBuffer(3,SellSideLevel,INDICATOR_DATA)) {Print("SLH: cannot bind indicator buffers"); return(INIT_FAILED);} ArraySetAsSeries(BullSignal,true); ArraySetAsSeries(BearSignal,true); ArraySetAsSeries(BuySideLevel,true); ArraySetAsSeries(SellSideLevel,true); #ifdef __MQL5__ PlotIndexSetInteger(0,PLOT_ARROW,233); // Up triangle PlotIndexSetInteger(1,PLOT_ARROW,234); // Down triangle if(!ShowLiquidityLevels) { PlotIndexSetInteger(2,PLOT_DRAW_TYPE,DRAW_NONE); PlotIndexSetInteger(3,PLOT_DRAW_TYPE,DRAW_NONE); } for(int j=0; j<4; j++) PlotIndexSetDouble(j,PLOT_EMPTY_VALUE,EMPTY_VALUE); IndicatorSetInteger(INDICATOR_DIGITS,_Digits); IndicatorSetString(INDICATOR_SHORTNAME,"Smart Liquidity Hunter v1.11"); #else SetIndexStyle(0,DRAW_ARROW,STYLE_SOLID,2,clrLimeGreen); SetIndexArrow(0,233); SetIndexLabel(0,"Bullish liquidity sweep"); SetIndexStyle(1,DRAW_ARROW,STYLE_SOLID,2,clrTomato); SetIndexArrow(1,234); SetIndexLabel(1,"Bearish liquidity sweep"); SetIndexStyle(2,ShowLiquidityLevels ? DRAW_LINE : DRAW_NONE, STYLE_DOT,1,clrOrangeRed); SetIndexLabel(2,"Buy-side liquidity (swing high)"); SetIndexStyle(3,ShowLiquidityLevels ? DRAW_LINE : DRAW_NONE, STYLE_DOT,1,clrDeepSkyBlue); SetIndexLabel(3,"Sell-side liquidity (swing low)"); for(int j=0; j<4; j++) SetIndexEmptyValue(j,EMPTY_VALUE); IndicatorDigits(_Digits); IndicatorShortName("Smart Liquidity Hunter v1.11"); #endif g_last_open_time=0; g_last_alert_time=0; // Object names are chart-local and stable across profile reloads. // Use a distinct DashboardInstanceId for every copy on the same chart. g_panel_prefix="SLH_Dashboard_"+DashboardInstanceId+"_"; RemoveDashboard(); // Clear this instance's saved labels before rebuilding. return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnDeinit(const int reason) {RemoveDashboard();} //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int OnCalculate(const int rates_total,const int prev_calculated, const datetime &time[],const double &open[], const double &high[],const double &low[], const double &close[],const long &tick_volume[], const long &volume[],const int &spread[]) { return(SLHCalculate(rates_total,prev_calculated, time,open,high,low,close)); } //+------------------------------------------------------------------+