SmartLiquidityHunter/mt4/Smart_Liquidity_Hunter_MT4.mq4
//+------------------------------------------------------------------+
//| 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<open
input bool ShowLiquidityLevels = true; // Plot active high/low levels
input bool ShowDashboard = true; // Draw compact chart text
input int ArrowPaddingPoints = 8; // Minimum arrow offset
input double ArrowOffsetVolRatio = 0.18; // Arrow offset in mean TR units
input string DashboardInstanceId = "A"; // Unique per chart instance, 1-40 characters
input color DashboardTextColor = clrDodgerBlue;
input bool AlertPopup = false;
input bool AlertSound = false;
input bool AlertPush = false;
input int DashboardX = 15; // Panel distance from left (pixels)
input int DashboardY = 30; // Panel distance from top (pixels)
// Exposed buffers: 0 bullish, 1 bearish, 2 buy-side, 3 sell-side.
double BullSignal[], BearSignal[], BuySideLevel[], SellSideLevel[];
datetime g_last_open_time = 0;
datetime g_last_alert_time = 0;
string g_panel_prefix = "";
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool ValidInputs()
{
return(SwingStrength >= 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<first; k++)
{priorHigh=MathMax(priorHigh,h[k]); priorLow=MathMin(priorLow,l[k]);}
for(int j=first; j<=last; j++)
{
const bool pivot = highSide ? IsSwingHigh(j,bars,h) : IsSwingLow(j,bars,l);
if(pivot)
{
const bool fresh = !RequireFreshLevel ||
(highSide ? priorHigh <= h[j]+0.01*_Point :
priorLow >= 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));
}
//+------------------------------------------------------------------+