Gold Fusion EA - Low Risk MQL4 Source Code for XAUUSD with Multi-Timeframe Confirmation

Summary: Gold Fusion EA is a low-risk MQL4 expert advisor for XAUUSD. It uses H4 trend filter, H1 entry signals, and adaptive ATR stop loss. Designed for gold's unique volatility. Suitable for H1 chart.




Gold Fusion EA is engineered specifically for gold (XAUUSD) to deliver low-risk, stable returns by adapting to gold's high volatility and frequent reversal characteristics. The EA employs a multi-timeframe approach: the H4 chart determines the primary trend direction (EMA50), while the H1 chart looks for pullback entry signals (RSI divergence and candlestick confirmation). An adaptive ATR-based stop loss and trailing stop mechanism locks in profits while volatility expands. The EA also includes spread protection, daily equity drawdown limits, and Friday close-out to avoid weekend gaps.

Recommended Timeframe: H1 (chart attached to H1, but uses H4 data automatically)

Trading Logic:
1. Trend Filter (H4): EMA50 on H4 defines bias. Price above = long only; below = short only.
2. Volatility Regime (H1): ATR(14) on H1 must be within 0.8x to 1.6x of 20-period average ATR. Skip if extreme.
3. Entry Signal (H1): RSI(14) divergence between price and RSI on H1 + bullish/bearish engulfing candle confirmation.
4. Risk Management: Fixed stop at 250 points (25 pips) OR 1.2x H1 ATR (whichever larger). Trailing start at 350 points profit, step 80 points. Daily loss limit 4%, max spread 35 points.

```mql4
//+------------------------------------------------------------------+
//| GoldFusionEA.mq4 |
//+------------------------------------------------------------------+
#property copyright ""
#property link ""
#property version "1.00"
#property strict

//+------------------------------------------------------------------+
//| Input parameters with detailed comments |
//+------------------------------------------------------------------+
input double LotSize = 0.01; // Fixed lot size (0.01 recommended)
input int H4TrendMAPeriod = 50; // EMA period on H4 for trend filter
input int H1RSIPeriod = 14; // RSI period on H1 for divergence
input int H1ATRPeriod = 14; // ATR period on H1 for volatility filter
input double VolatilityMinRatio = 0.8; // Min ATR ratio (current/avg) to trade
input double VolatilityMaxRatio = 1.6; // Max ATR ratio (current/avg) to trade
input int StopLossPips = 250; // Fixed stop loss in points (250 = 25 pips)
input double StopLossATRMultiplier = 1.2; // Dynamic stop = ATR * this (takes larger of fixed/dynamic)
input int TakeProfitPips = 500; // Take profit in points (50 pips)
input int TrailingStartPips = 350; // Trailing activates after profit (points)
input int TrailingStepPips = 80; // Trailing step distance (points)
input double DailyLossLimit = 4.0; // Daily loss limit as % of balance
input int MaxSpread = 35; // Maximum allowed spread in points
input bool CloseOnFriday = true; // Close all trades before Friday 20:00 GMT
input int MagicNumber = 202419; // Unique EA identifier

//+------------------------------------------------------------------+
//| Global variables |
//+------------------------------------------------------------------+
double dailyStartBalance = 0;
datetime lastH1BarTime = 0;
bool fridayCloseDone = false;
double avgATR_H1 = 0;

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
dailyStartBalance = AccountBalance();
lastH1BarTime = 0;
fridayCloseDone = false;
avgATR_H1 = iATR(Symbol(), PERIOD_H1, H1ATRPeriod, 1);
if(avgATR_H1 <= 0) avgATR_H1 = 200 * Point;
return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
Comment("");
}

//+------------------------------------------------------------------+
//| Calculate ATR moving average (rolling) |
//+------------------------------------------------------------------+
double UpdateAvgATR()
{
double currentATR = iATR(Symbol(), PERIOD_H1, H1ATRPeriod, 1);
if(currentATR > 0)
avgATR_H1 = (avgATR_H1 * 0.95) + (currentATR * 0.05);
return currentATR;
}

//+------------------------------------------------------------------+
//| Detect RSI divergence (bullish or bearish) |
//+------------------------------------------------------------------+
int DetectRSIDivergence()
{
// Get RSI values for last 3 bars on H1
double rsi[3];
double price[3];
for(int i = 1; i <= 3; i++)
{
rsi[i-1] = iRSI(Symbol(), PERIOD_H1, H1RSIPeriod, PRICE_CLOSE, i);
price[i-1] = iClose(Symbol(), PERIOD_H1, i);
}

// Bullish divergence: price makes lower low, RSI makes higher low
if(price[0] < price[1] && price[1] < price[2] && rsi[0] > rsi[1] && rsi[1] > rsi[2])
return 1; // Bullish divergence

// Bearish divergence: price makes higher high, RSI makes lower high
if(price[0] > price[1] && price[1] > price[2] && rsi[0] < rsi[1] && rsi[1] < rsi[2])
return -1; // Bearish divergence

return 0; // No divergence
}

//+------------------------------------------------------------------+
//| Check engulfing candlestick pattern on H1 |
//+------------------------------------------------------------------+
bool IsEngulfing(int direction)
{
double open1 = iOpen(Symbol(), PERIOD_H1, 1);
double close1 = iClose(Symbol(), PERIOD_H1, 1);
double open2 = iOpen(Symbol(), PERIOD_H1, 2);
double close2 = iClose(Symbol(), PERIOD_H1, 2);

if(direction == 1) // Bullish engulfing
{
return (close2 < open2) && (close1 > open1) && (close1 > open2) && (open1 < close2);
}
else if(direction == -1) // Bearish engulfing
{
return (close2 > open2) && (close1 < open1) && (close1 < open2) && (open1 > close2);
}
return false;
}

//+------------------------------------------------------------------+
//| H4 trend direction (1 = up, -1 = down, 0 = neutral) |
//+------------------------------------------------------------------+
int GetH4Trend()
{
double ema50 = iMA(Symbol(), PERIOD_H4, H4TrendMAPeriod, 0, MODE_EMA, PRICE_CLOSE, 1);
double close1 = iClose(Symbol(), PERIOD_H4, 1);
if(close1 > ema50) return 1;
if(close1 < ema50) return -1;
return 0;
}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
// Daily drawdown protection
double equity = AccountEquity();
double lossPct = (dailyStartBalance - equity) / dailyStartBalance * 100;
if(lossPct >= DailyLossLimit)
{
Comment("Daily loss limit ", DailyLossLimit, "% reached. Trading paused.");
return;
}

// Friday close-out (avoid weekend gap)
if(CloseOnFriday && !fridayCloseDone)
{
datetime now = TimeCurrent();
if(TimeDayOfWeek(now) == 5 && TimeHour(now) >= 20)
{
CloseAllOrders();
fridayCloseDone = true;
Comment("All positions closed for weekend.");
return;
}
if(TimeDayOfWeek(now) != 5)
fridayCloseDone = false;
}

// Spread protection
int spread = (int)MarketInfo(Symbol(), MODE_SPREAD);
if(spread > MaxSpread)
{
Comment("Spread too high: ", spread);
return;
}

// New H1 bar check
if(Time[0] == lastH1BarTime)
return;
lastH1BarTime = Time[0];

// Manage existing positions (trailing stop)
if(CountPositions() > 0)
{
ManageTrailingStop();
return;
}

// Update ATR and volatility filter
double currentATR = UpdateAvgATR();
double atrRatio = currentATR / avgATR_H1;
if(atrRatio < VolatilityMinRatio || atrRatio > VolatilityMaxRatio)
{
Comment("Volatility filter: ATR ratio = ", DoubleToString(atrRatio,2), " out of range [",VolatilityMinRatio,",",VolatilityMaxRatio,"]");
return;
}

// Get H4 trend direction
int trendDir = GetH4Trend();
if(trendDir == 0)
{
Comment("No clear trend on H4. Waiting.");
return;
}

// Detect RSI divergence
int divDir = DetectRSIDivergence();
if(divDir == 0)
{
Comment("No RSI divergence detected.");
return;
}

// Check if divergence aligns with trend
if((trendDir == 1 && divDir == -1) || (trendDir == -1 && divDir == 1))
{
Comment("Divergence opposes H4 trend. Skip.");
return;
}

// Confirm with engulfing candle
if(!IsEngulfing(divDir))
{
Comment("No confirming engulfing candle.");
return;
}

// Calculate dynamic stop loss
int fixedStop = StopLossPips;
int dynamicStop = (int)(currentATR / Point * StopLossATRMultiplier);
int finalStop = MathMax(fixedStop, dynamicStop);
double sl = 0, tp = 0;
int cmd = -1;
double ask = Ask;
double bid = Bid;

if(divDir == 1) // Long signal
{
cmd = OP_BUY;
sl = bid - finalStop * Point;
tp = bid + TakeProfitPips * Point;
}
else if(divDir == -1) // Short signal
{
cmd = OP_SELL;
sl = ask + finalStop * Point;
tp = ask - TakeProfitPips * Point;
}

if(cmd != -1)
{
int ticket = OrderSend(Symbol(), cmd, LotSize, (cmd==OP_BUY?ask:bid), 3, sl, tp, "Gold Fusion", MagicNumber, 0, clrNONE);
if(ticket < 0)
Print("OrderSend error: ", GetLastError());
}
}

//+------------------------------------------------------------------+
//| Trailing stop management |
//+------------------------------------------------------------------+
void ManageTrailingStop()
{
for(int i = OrdersTotal()-1; i >= 0; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
{
double newSL = 0;
if(OrderType() == OP_BUY)
{
double profitPoints = (Bid - OrderOpenPrice()) / Point;
if(profitPoints >= TrailingStartPips)
{
newSL = Bid - TrailingStepPips * Point;
if(newSL > OrderStopLoss())
OrderModify(OrderTicket(), OrderOpenPrice(), newSL, OrderTakeProfit(), 0, clrNONE);
}
}
else if(OrderType() == OP_SELL)
{
double profitPoints = (OrderOpenPrice() - Ask) / Point;
if(profitPoints >= TrailingStartPips)
{
newSL = Ask + TrailingStepPips * Point;
if(newSL < OrderStopLoss() || OrderStopLoss() == 0)
OrderModify(OrderTicket(), OrderOpenPrice(), newSL, OrderTakeProfit(), 0, clrNONE);
}
}
break;
}
}
}
}

//+------------------------------------------------------------------+
//| Count open positions |
//+------------------------------------------------------------------+
int CountPositions()
{
int count = 0;
for(int i = OrdersTotal()-1; i >= 0; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
count++;
}
return count;
}

//+------------------------------------------------------------------+
//| Close all orders for this EA |
//+------------------------------------------------------------------+
void CloseAllOrders()
{
for(int i = OrdersTotal()-1; i >= 0; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
{
if(OrderType() == OP_BUY)
OrderClose(OrderTicket(), OrderLots(), Bid, 3, clrNONE);
else if(OrderType() == OP_SELL)
OrderClose(OrderTicket(), OrderLots(), Ask, 3, clrNONE);
}
}
}
}
//+------------------------------------------------------------------+
```
Reference: Original MQL4 code for educational purposes.
Disclaimer: Gold trading carries significant risk due to high volatility. This EA is provided "as is" without any guarantee of profitability. Always test on a demo account for at least 2 months before live deployment. Past performance does not guarantee future results.