FreelanceSections

GoldTrade EA

MQL5 Experts

Spécifications

//+------------------------------------------------------------------+
//| XAUUSD Wolfe + SMC Quick Profit EA                              |
//| MT5 / MQL5                                                      |
//+------------------------------------------------------------------+
#property strict

#include <Trade/Trade.mqh>

CTrade trade;

//==================================================================
// INPUTS
//==================================================================

//--- General
input string InpSymbol              = "";       // Blank = chart symbol
input ulong  MagicNumber             = 26082301;
input double InitialLot              = 0.01;
input double AddLot                 = 0.01;
input int    MaxPositions           = 3;
input double MaxTotalLots           = 0.03;

//--- Commission / profit
input double CommissionPer001       = 0.45;     // USD per 0.01 lot
input double MinimumNetProfit       = 0.10;     // Desired net profit
input double ProfitBuffer            = 0.05;     // Safety buffer

//--- Entry
input ENUM_TIMEFRAMES BiasTF         = PERIOD_M5;
input ENUM_TIMEFRAMES EntryTF        = PERIOD_M1;

input int    FastEMA                 = 20;
input int    SlowEMA                 = 50;

input int    SwingLookback           = 80;
input int    SwingStrength           = 2;

input double WolfeTolerancePoints    = 150;
input double EntryZonePoints         = 250;

//--- Risk
input double StopLossPoints          = 1200;
input double MaxBasketLossUSD        = 25.0;
input double MaxDailyLossUSD         = 50.0;

//--- Spread
input double MaxSpreadPoints         = 120;

//--- Scaling
input double AddAfterProfitUSD       = 0.30;
input int    MinimumSecondsBetweenAdds = 60;

//--- Trading hours
input bool   UseTradingHours         = true;
input int    StartHour               = 7;
input int    EndHour                 = 22;

//--- Execution
input int    DeviationPoints         = 30;

//==================================================================
// GLOBALS
//==================================================================

string TradeSymbol;

datetime LastBarM1 = 0;
datetime LastAddTime = 0;
datetime DayStart = 0;

double DailyStartEquity = 0;

//==================================================================
// INITIALIZATION
//==================================================================

int OnInit()
{
   TradeSymbol = InpSymbol;

   if(TradeSymbol == "")
      TradeSymbol = _Symbol;

   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(DeviationPoints);

   DailyStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);

   MqlDateTime dt;
   TimeToStruct(TimeCurrent(),dt);
   dt.hour = 0;
   dt.min  = 0;
   dt.sec  = 0;

   DayStart = StructToTime(dt);

   Print("EA initialized on ", TradeSymbol);

   return(INIT_SUCCEEDED);
}

//==================================================================
// MAIN
//==================================================================

void OnTick()
{
   if(_Symbol != TradeSymbol)
      return;

   UpdateDailyReference();

   // Manage existing basket first
   ManageBasket();

   // Protect account
   if(DailyLossExceeded())
      return;

   if(!TradingTime())
      return;

   if(!SpreadOK())
      return;

   // Only make a new decision on a new M1 candle
   datetime currentBar = iTime(TradeSymbol,EntryTF,0);

   if(currentBar == LastBarM1)
      return;

   LastBarM1 = currentBar;

   // Existing basket?
   int positions = CountPositions();

   if(positions > 0)
   {
      ManageScaling();
      return;
   }

   // No open basket: search for new trade
   int signal = GetTradeSignal();

   if(signal == 1)
   {
      OpenBuy(InitialLot);
   }
   else if(signal == -1)
   {
      OpenSell(InitialLot);
   }
}

//==================================================================
// SIGNAL ENGINE
//==================================================================

int GetTradeSignal()
{
   int bias = GetMarketBias();

   if(bias == 0)
      return 0;

   bool wolfe = DetectWolfeStyleSetup(bias);

   if(!wolfe)
      return 0;

   bool confirmation = M1Confirmation(bias);

   if(!confirmation)
      return 0;

   return bias;
}

//==================================================================
// MARKET BIAS
//==================================================================

int GetMarketBias()
{
   double fast = iMAValue(TradeSymbol,BiasTF,FastEMA,1);
   double slow = iMAValue(TradeSymbol,BiasTF,SlowEMA,1);

   if(fast == 0 || slow == 0)
      return 0;

   double close = iClose(TradeSymbol,BiasTF,1);

   // Bearish
   if(fast < slow && close < fast)
      return -1;

   // Bullish
   if(fast > slow && close > fast)
      return 1;

   return 0;
}

//==================================================================
// WOLFE STYLE SETUP
//==================================================================

bool DetectWolfeStyleSetup(int direction)
{
   double highs[10];
   double lows[10];

   int highCount = GetSwingHighs(highs,10);
   int lowCount  = GetSwingLows(lows,10);

   if(highCount < 3 || lowCount < 3)
      return false;

   double price = iClose(TradeSymbol,BiasTF,1);

   //==============================================================
   // BEARISH WOLFE-STYLE SETUP
   //==============================================================

   if(direction == -1)
   {
      double h1 = highs[2];
      double h3 = highs[1];
      double h5 = highs[0];

      double l2 = lows[2];
      double l4 = lows[1];

      // Successive higher highs
      bool higherHighs = (h3 > h1 && h5 > h3);

      // Higher lows
      bool higherLows = (l4 > l2);

      if(!higherHighs || !higherLows)
         return false;

      // Estimate upper wedge boundary
      double upperSlope = (h5 - h1) / 4.0;

      double projectedResistance = h5 + upperSlope;

      // Price should be near final high / rejection zone
      double distance =
         MathAbs(price - h5) / SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      if(distance <= EntryZonePoints)
         return true;
   }

   //==============================================================
   // BULLISH WOLFE-STYLE SETUP
   //==============================================================

   if(direction == 1)
   {
      double l1 = lows[2];
      double l3 = lows[1];
      double l5 = lows[0];

      double h2 = highs[2];
      double h4 = highs[1];

      bool lowerLows = (l3 < l1 && l5 < l3);

      bool lowerHighs = (h4 < h2);

      if(!lowerLows || !lowerHighs)
         return false;

      double lowerSlope = (l5 - l1) / 4.0;

      double projectedSupport = l5 + lowerSlope;

      double distance =
         MathAbs(price - l5) / SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      if(distance <= EntryZonePoints)
         return true;
   }

   return false;
}

//==================================================================
// M1 CONFIRMATION
//==================================================================

bool M1Confirmation(int direction)
{
   double open1  = iOpen(TradeSymbol,EntryTF,1);
   double close1 = iClose(TradeSymbol,EntryTF,1);

   double high1  = iHigh(TradeSymbol,EntryTF,1);
   double low1   = iLow(TradeSymbol,EntryTF,1);

   double open2  = iOpen(TradeSymbol,EntryTF,2);
   double close2 = iClose(TradeSymbol,EntryTF,2);

   //==============================================================
   // BEARISH
   //==============================================================

   if(direction == -1)
   {
      bool bearishCandle = close1 < open1;

      bool bearishShift = close1 < low2();

      bool rejection =
         (high1 - MathMax(open1,close1)) >
         (MathMin(open1,close1) - low1);

      if(bearishCandle && (bearishShift || rejection))
         return true;
   }

   //==============================================================
   // BULLISH
   //==============================================================

   if(direction == 1)
   {
      bool bullishCandle = close1 > open1;

      bool bullishShift = close1 > high2();

      bool rejection =
         (MathMin(open1,close1) - low1) >
         (high1 - MathMax(open1,close1));

      if(bullishCandle && (bullishShift || rejection))
         return true;
   }

   return false;
}

//==================================================================
// SWING DETECTION
//==================================================================

int GetSwingHighs(double &values[],int maxValues)
{
   int found = 0;

   for(int i=SwingStrength+1;
       i<SwingLookback && found<maxValues;
       i++)
   {
      bool swing = true;

      double h = iHigh(TradeSymbol,BiasTF,i);

      for(int j=1;j<=SwingStrength;j++)
      {
         if(h <= iHigh(TradeSymbol,BiasTF,i-j) ||
            h <= iHigh(TradeSymbol,BiasTF,i+j))
         {
            swing = false;
            break;
         }
      }

      if(swing)
      {
         values[found] = h;
         found++;
      }
   }

   return found;
}

//------------------------------------------------------------------

int GetSwingLows(double &values[],int maxValues)
{
   int found = 0;

   for(int i=SwingStrength+1;
       i<SwingLookback && found<maxValues;
       i++)
   {
      bool swing = true;

      double l = iLow(TradeSymbol,BiasTF,i);

      for(int j=1;j<=SwingStrength;j++)
      {
         if(l >= iLow(TradeSymbol,BiasTF,i-j) ||
            l >= iLow(TradeSymbol,BiasTF,i+j))
         {
            swing = false;
            break;
         }
      }

      if(swing)
      {
         values[found] = l;
         found++;
      }
   }

   return found;
}

//==================================================================
// POSITION MANAGEMENT
//==================================================================

void ManageBasket()
{
   int count = CountPositions();

   if(count <= 0)
      return;

   double basketProfit = BasketProfit();

   double requiredProfit =
      BasketCommission() +
      MinimumNetProfit +
      ProfitBuffer;

   // Fast profit exit
   if(basketProfit >= requiredProfit)
   {
      CloseBasket();

      Print("Basket closed. Gross P/L: ",
            basketProfit,
            " Required: ",
            requiredProfit);

      return;
   }

   // Emergency basket stop
   if(basketProfit <= -MaxBasketLossUSD)
   {
      CloseBasket();

      Print("Emergency basket loss reached.");

      return;
   }
}

//==================================================================
// SCALING
//==================================================================

void ManageScaling()
{
   int count = CountPositions();

   if(count >= MaxPositions)
      return;

   double lots = TotalLots();

   if(lots + AddLot > MaxTotalLots)
      return;

   if(TimeCurrent() - LastAddTime <
      MinimumSecondsBetweenAdds)
      return;

   double profit = BasketProfit();

   // NEVER add to a losing basket
   if(profit < AddAfterProfitUSD)
      return;

   int direction = BasketDirection();

   if(direction == 1)
   {
      if(OpenBuy(AddLot))
         LastAddTime = TimeCurrent();
   }
   else if(direction == -1)
   {
      if(OpenSell(AddLot))
         LastAddTime = TimeCurrent();
   }
}

//==================================================================
// BUY
//==================================================================

bool OpenBuy(double lot)
{
   lot = NormalizeLot(lot);

   double ask = SymbolInfoDouble(TradeSymbol,SYMBOL_ASK);

   if(ask <= 0)
      return false;

   double sl = 0;

   if(StopLossPoints > 0)
   {
      sl = ask -
           StopLossPoints *
           SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      sl = NormalizeDouble(
         sl,
         (int)SymbolInfoInteger(TradeSymbol,SYMBOL_DIGITS)
      );
   }

   return trade.Buy(
      lot,
      TradeSymbol,
      ask,
      sl,
      0,
      "Wolfe-SMC BUY"
   );
}

//==================================================================
// SELL
//==================================================================

bool OpenSell(double lot)
{
   lot = NormalizeLot(lot);

   double bid = SymbolInfoDouble(TradeSymbol,SYMBOL_BID);

   if(bid <= 0)
      return false;

   double sl = 0;

   if(StopLossPoints > 0)
   {
      sl = bid +
           StopLossPoints *
           SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      sl = NormalizeDouble(
         sl,
         (int)SymbolInfoInteger(TradeSymbol,SYMBOL_DIGITS)
      );
   }

   return trade.Sell(
      lot,
      TradeSymbol,
      bid,
      sl,
      0,
      "Wolfe-SMC SELL"
   );
}

//==================================================================
// BASKET PROFIT
//==================================================================

double BasketProfit()
{
   double total = 0;

   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      total += PositionGetDouble(POSITION_PROFIT);
      total += PositionGetDouble(POSITION_SWAP);
   }

   return total;
}

//==================================================================
// COMMISSION ESTIMATE
//==================================================================

double BasketCommission()
{
   double lots = TotalLots();

   return (lots / 0.01) * CommissionPer001;
}

//==================================================================
// TOTAL LOTS
//==================================================================

double TotalLots()
{
   double lots = 0;

   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      lots += PositionGetDouble(POSITION_VOLUME);
   }

   return lots;
}

//==================================================================
// COUNT POSITIONS
//==================================================================

int CountPositions()
{
   int count = 0;

   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      count++;
   }

   return count;
}

//==================================================================
// BASKET DIRECTION
//==================================================================

int BasketDirection()
{
   double buyLots = 0;
   double sellLots = 0;

   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      ENUM_POSITION_TYPE type =
         (ENUM_POSITION_TYPE)
         PositionGetInteger(POSITION_TYPE);

      double lots =
         PositionGetDouble(POSITION_VOLUME);

      if(type == POSITION_TYPE_BUY)
         buyLots += lots;

      if(type == POSITION_TYPE_SELL)
         sellLots += lots;
   }

   if(buyLots > sellLots)
      return 1;

   if(sellLots > buyLots)
      return -1;

   return 0;
}

//==================================================================
// CLOSE BASKET
//==================================================================

void CloseBasket()
{
   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      trade.PositionClose(ticket);
   }
}

//==================================================================
// SPREAD FILTER
//==================================================================

bool SpreadOK()
{
   double ask =
      SymbolInfoDouble(TradeSymbol,SYMBOL_ASK);

   double bid =
      SymbolInfoDouble(TradeSymbol,SYMBOL_BID);

   double point =
      SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

   if(point <= 0)
      return false;

   double spread =
      (ask-bid)/point;

   return spread <= MaxSpreadPoints;
}

//==================================================================
// TRADING HOURS
//==================================================================

bool TradingTime()
{
   if(!UseTradingHours)
      return true;

   MqlDateTime dt;

   TimeToStruct(TimeCurrent(),dt);

   if(StartHour < EndHour)
   {
      if(dt.hour >= StartHour &&
         dt.hour < EndHour)
         return true;
   }
   else
   {
      if(dt.hour >= StartHour ||
         dt.hour < EndHour)
         return true;
   }

   return false;
}

//==================================================================
// DAILY LOSS
//==================================================================

bool DailyLossExceeded()
{
   double equity =
      AccountInfoDouble(ACCOUNT_EQUITY);

   double loss =
      DailyStartEquity - equity;

   return loss >= MaxDailyLossUSD;
}

//==================================================================
// RESET DAILY EQUITY
//==================================================================

void UpdateDailyReference()
{
   MqlDateTime dt;

   TimeToStruct(TimeCurrent(),dt);

   dt.hour = 0;
   dt.min  = 0;
   dt.sec  = 0;

   datetime today = StructToTime(dt);

   if(today != DayStart)
   {
      DayStart = today;

      DailyStartEquity =
         AccountInfoDouble(ACCOUNT_EQUITY);
   }
}

//==================================================================
// EMA VALUE
//==================================================================

double iMAValue(
   string symbol,
   ENUM_TIMEFRAMES timeframe,
   int period,
   int shift
)
{
   int handle =
      iMA(
         symbol,
         timeframe,
         period,
         0,
         MODE_EMA,
         PRICE_CLOSE
      );

   if(handle == INVALID_HANDLE)
      return 0;

   double buffer[];

   ArraySetAsSeries(buffer,true);

   if(CopyBuffer(handle,0,shift,1,buffer) <= 0)
   {
      IndicatorRelease(handle);
      return 0;
   }

   double value = buffer[0];

   IndicatorRelease(handle);

   return value;
}

//==================================================================
// BAR HELPERS
//==================================================================

double low2()
{
   return iLow(TradeSymbol,EntryTF,2);
}

double high2()
{
   return iHigh(TradeSymbol,EntryTF,2);
}

//==================================================================
// LOT NORMALIZATION
//==================================================================

double NormalizeLot(double lot)
{
   double minLot =
      SymbolInfoDouble(TradeSymbol,SYMBOL_VOLUME_MIN);

   double maxLot =
      SymbolInfoDouble(TradeSymbol,SYMBOL_VOLUME_MAX);

   double step =
      SymbolInfoDouble(TradeSymbol,SYMBOL_VOLUME_STEP);

   if(lot < minLot)
      lot = minLot;

   if(lot > maxLot)
      lot = maxLot;

   lot =
      MathFloor(lot/step)*step;

   return NormalizeDouble(lot,2);
}

//+------------------------------------------------------------------+

Répondu

1
Développeur 1
Évaluation
(3)
Projets
4
0%
Arbitrage
1
100% / 0%
En retard
1
25%
Gratuit
2
Développeur 2
Évaluation
(1)
Projets
1
0%
Arbitrage
1
0% / 0%
En retard
0
Travail
3
Développeur 3
Évaluation
(3)
Projets
3
0%
Arbitrage
0
En retard
0
Gratuit
4
Développeur 4
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
5
Développeur 5
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
6
Développeur 6
Évaluation
(5)
Projets
6
50%
Arbitrage
0
En retard
0
Chargé
Publié : 1 code
7
Développeur 7
Évaluation
Projets
1
0%
Arbitrage
0
En retard
0
Gratuit
8
Développeur 8
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
9
Développeur 9
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
10
Développeur 10
Évaluation
(2)
Projets
2
50%
Arbitrage
0
En retard
0
Gratuit
Commandes similaires
ROBOTFORX_V7 40+ USD
i have the robotforx_v7 code but am looking for an experinced developer to improve my code i want it to capture quick moves on 5mins it should be able close like ten trades in small profits
I BUY EA FOR FTMO – XAUUSD | 5+ YEAR BACKTEST | LOW DD 30+ USD
I BUY EA FOR FTMO XAUUSD I am looking to buy professional Expert Advisors (EA) suitable for FTMO and other prop trading environments. I am interested in XAUUSD . I am NOT looking for high-risk EAs with impressive but unrealistic backtests. I am looking for low drawdown, consistent returns and robust strategies that can survive real market conditions. REQUIRED RISK PROFILE Maximum preferred daily drawdown: 1% Maximum
EA REQUIREMENT — READ BEFORE ACCEPTING 30+ USD
EA REQUIREMENT — READ BEFORE ACCEPTING This is my 4th attempt to get this EA built correctly. Many developers have already failed to reproduce my TradingView results. Please read the complete requirement first. Do not accept the project if you are not confident that you can achieve the required accuracy. I do not want to waste your time or mine. I will provide my TradingView Pine Script, settings, and baseline trade
I want a scalping Ea robot based on EMA crossover 30 - 200 USD
the bot will be used for xauusd scalp trading , want the bor follow the trading indicator will SL and open another opposite order where i can customize the SL margin and risk management
MQL5 XAUUSD Scalping EA Development with Risk Management 90 - 300 USD
I am looking for an experienced MQL5 developer to build a robust XAUUSD scalping Expert Advisor for MetaTrader 5. The EA should focus on consistent risk management, controlled drawdown, high-quality trade filtering, precise entries and exits, configurable stop loss and take profit, spread and volatility protection, trading-session filters, and reliable execution. I need the strategy to be fully backtestable and
2500k to 10k for one MT5 Expert Advisor, done properly 5000 - 10000 USD
I will pay 2500 to 10000 USD (negotiable) for one MT5 Expert Advisor, built properly. One robot done right, not a batch of cheap jobs. I have a strategy I believe in and a rough draft robot I built myself. The logic is there. The execution is not. That last part is outside my expertise, which is why I am hiring instead of continuing on my own. I am open to feedback on the strategy itself. If you see something in it
Modification of an existing MQL5 EA TH-05 30 - 300 USD
I Have an existing Mql5 Expert advisor (source code), I want a professional programmer to help me Modify the EA... so that it can stop taking new trades once it Gets to a Pacific Lots Size or Floating loss
رباط 30+ USD
//+------------------------------------------------------------------+ //| AdvancedPriceAction.mq5 | //| Copyright 2026, Trading Strategy AI | //+------------------------------------------------------------------+ #property copyright "Trading Strategy AI" #property version "1.00" #property strict #include <Trade\Trade.mqh>
EA LOTS SIZE MODIFICATION !!! 30 - 300 USD
I Have an existing Mql5 Expert advisor (source code), I want a professional programmer to help me Modify the EA... so that it can stop taking new trades once it Gets to a Pacific Lots Size or Floating loss
Buying profitable EA Budget up to 10k (Serious offer) 100 - 10000 USD
I will pay 10k (negotiable) for an EA for existing MT5 that generates a minimum of 5% or higher a month consistently Please send demo version with optimal settings so I can test, if it performs in a strategy tester i will also need option to forward test it in a demo account. Developer should be willing to demonstrate how efficient the robot is, Once you send me the demo, I will test the EA on a real-time account

Informations sur le projet

Budget
30+ USD
Délais
de 1 à 30 jour(s)

Client

Commandes passées1
Nombre d'arbitrages0