FreelanceSections

Krushan

MQL5 Experts

Specification

#property copyright "Krishh yadav"
#property link "https://krishhautomationfx.in"
#property version "1.07"
#property strict

#include <Trade\Trade.mqh>
#include <Trade\AccountInfo.mqh>
#include <Trade/PositionInfo.mqh>

CTrade trade;
CPositionInfo posinfo;
CPositionInfo pos;

enum LotMode
{
   FixedLot = 0,
   RiskLot = 1,
   EquityLot = 2,
};

enum ENUM_HOUR { h00=0, h01=1, h02=2, h03=3, h04=4, h05=5, h06=6, h07=7,
   h08=8, h09=9, h10=10, h11=11, h12=12, h13=13, h14=14, h15=15, h16=16,
   h17=17, h18=18, h19=19, h20=20, h21=21, h22=22, h23=23 };

enum ENUM_MINUTE {
   m00 = 0, m05 = 5, m10 = 10, m15 = 15, m20 = 20, m25 = 25,
   m30 = 30, m35 = 35, m40 = 40, m45 = 45, m50 = 50, m55 = 55
};

input string A_________________________________1 = "=============== Lot & Risk Settings ===============";
input LotMode lotMode = RiskLot;
input double lotValue = 1.0;
input int Stoploss = 200;
input int distance = 100;
input ulong magic_No = 12345;
input int MaxOpenOrders = 20;

// ✅ Fixed Money SL for cent/live/demo account
input bool UseHardMoneySL = true;
input double HardMoneySL = 200.0;

input string A2 = "=============== Trailing Stop Settings ===============";
input bool UseTraling_Stop = true;
input double TrailStartPips = 50;
input double TrailStepPips = 100;
input double TrailSLPips = 100;

input string A_________________________________3 = "=============== Trading Hours Settings ===============";
input bool UseTradingHours = false;
input ENUM_HOUR TradingHourStart = h15;
input ENUM_MINUTE TradingMinStart = m00;
input ENUM_HOUR TradingHourEnd = h18;
input ENUM_MINUTE TradingMinEnd = m30;

input string A4 = "=============== Indicator Settings ===============";
input int FASTMA = 3;
input int SLOWMA = 8;
input int ADX_Period = 14;
input int ADXstrenth = 25;

input string A5 = "=============== Day_Target ===============";
input double DailyProfitTarget = 200.0;

int adxHandle;
int handle1;
int handle2;
bool dailyTargetHit = false;
datetime dayStartTime = 0;
double profitClosed = 0.0;

int OnInit()
{
   trade.SetExpertMagicNumber(magic_No);

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

   adxHandle = iADX(_Symbol, PERIOD_CURRENT, ADX_Period);
   handle1 = iMA(_Symbol, PERIOD_CURRENT, FASTMA, 0, MODE_SMA, PRICE_CLOSE);
   handle2 = iMA(_Symbol, PERIOD_CURRENT, SLOWMA, 0, MODE_SMA, PRICE_CLOSE);

   profitClosed = CalcDailyClosedProfit();

   ChartSetInteger(0, CHART_SHOW_GRID, false);
   TesterHideIndicators(true);

   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
}

void OnTick()
{
   trade.SetExpertMagicNumber(magic_No);

   // ✅ Hard Money SL check first
   if(UseHardMoneySL)
      ClosePositionsAtHardMoneySL();

   CheckAndResetDailyCounters();

   if(dailyTargetHit)
   {
      Comment("🚫 Daily target reached, trading paused until tomorrow.");
      return;
   }

   if(CheckDailyTargetAndLock())
      return;

   if(UseTradingHours && !IsCurrentTimeInInterval(TradingHourStart, TradingMinStart, TradingHourEnd, TradingMinEnd))
      return;

   if(UseTraling_Stop)
   {
      StepWiseTrailingStop();
      Mirror_SL_to_OppositePending();
   }

   double adxValue = GetADX(0);

   int Buyorder = CountMarketOrders(ORDER_TYPE_BUY);
   int Sellorder = CountMarketOrders(ORDER_TYPE_SELL);
   int buystop = CountPendingOrders(ORDER_TYPE_BUY_STOP);
   int sellstop = CountPendingOrders(ORDER_TYPE_SELL_STOP);

   double buyprice = SymbolInfoDouble(_Symbol, SYMBOL_ASK) + distance * _Point;
   double sellprice = SymbolInfoDouble(_Symbol, SYMBOL_BID) - distance * _Point;

   double fastma = GetFastMA(FASTMA, 0);
   double slowma = GetSlowMA(SLOWMA, 0);

   if(Buyorder == 0 && Sellorder == 0 && buystop == 0 && sellstop == 0 && adxValue > ADXstrenth)
   {
      if(fastma > slowma)
         Open_Buystop(buyprice);
      else if(fastma < slowma)
         Open_Sellstop(sellprice);
   }

   double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   for(int i = 0; i < OrdersTotal(); i++)
   {
      ulong ticket = OrderGetTicket(i);
      if(OrderSelect(ticket))
      {
         double orderPrice = OrderGetDouble(ORDER_PRICE_OPEN);

         if(Buyorder == 0 && Sellorder == 0 && sellstop == 0 && Ask < orderPrice)
            modifybuystop();

         if(Buyorder == 0 && Sellorder == 0 && buystop == 0 && Bid > orderPrice)
            modifysellstop();
      }
   }

   double profitOpen = CalcOpenProfitByMagic();
   double profitDay = profitOpen + profitClosed;

   Comment(
      "\nMagic: ", magic_No,
      "\nOpen Profit: ", DoubleToString(profitOpen, 2), " ", AccountInfoString(ACCOUNT_CURRENCY),
      "\nClosed Profit: ", DoubleToString(profitClosed, 2), " ", AccountInfoString(ACCOUNT_CURRENCY),
      "\nDay Profit: ", DoubleToString(profitDay, 2), " ", AccountInfoString(ACCOUNT_CURRENCY),
      "\nTarget Profit: ", DoubleToString(DailyProfitTarget, 2), " ", AccountInfoString(ACCOUNT_CURRENCY),
      "\nHard Money SL: ", DoubleToString(HardMoneySL, 2)
   );
}

void Open_Buystop(double Buy_price)
{
   double sl = Buy_price - Stoploss * _Point;
   double lot = GetLotSize(lotMode, lotValue, Stoploss);

   if(!trade.BuyStop(lot, Buy_price, _Symbol, sl, 0, ORDER_TIME_DAY, 0, "buystop"))
      Print("❌ Buystop failed: ", GetLastError());
}

void Open_Sellstop(double Sell_price)
{
   double sl = Sell_price + Stoploss * _Point;
   double lot = GetLotSize(lotMode, lotValue, Stoploss);

   if(!trade.SellStop(lot, Sell_price, _Symbol, sl, 0, ORDER_TIME_DAY, 0, "sellstop"))
      Print("❌ Sellstop failed: ", GetLastError());
}

int CountMarketOrders(int type)
{
   int count = 0;

   for(int i = 0; i < PositionsTotal(); i++)
   {
      if(PositionGetSymbol(i) == _Symbol &&
         PositionGetInteger(POSITION_TYPE) == type &&
         PositionGetInteger(POSITION_MAGIC) == (long)magic_No)
      {
         count++;
      }
   }

   return count;
}

int CountPendingOrders(int type)
{
   int count = 0;

   for(int i = 0; i < OrdersTotal(); i++)
   {
      ulong ticket = OrderGetTicket(i);

      if(OrderSelect(ticket))
      {
         if(OrderGetString(ORDER_SYMBOL) == _Symbol &&
            OrderGetInteger(ORDER_TYPE) == type &&
            OrderGetInteger(ORDER_MAGIC) == (long)magic_No)
         {
            count++;
         }
      }
   }

   return count;
}

// ✅ Fixed money SL function
void ClosePositionsAtHardMoneySL()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(!pos.SelectByIndex(i))
         continue;

      if(pos.Symbol() != _Symbol)
         continue;

      if(pos.Magic() != (long)magic_No)
         continue;

      double loss = pos.Profit();

      if(loss <= -HardMoneySL)
      {
         trade.SetExpertMagicNumber(magic_No);

         if(!trade.PositionClose(pos.Ticket()))
         {
            Print("❌ Hard Money SL close failed. Ticket: ", pos.Ticket(),
                  " Loss: ", DoubleToString(loss, 2),
                  " Error: ", GetLastError());
         }
         else
         {
            Print("✅ Hard Money SL closed. Ticket: ", pos.Ticket(),
                  " Loss: ", DoubleToString(loss, 2));
         }
      }
   }
}

void StepWiseTrailingStop()
{
   int total = PositionsTotal();

   for(int i = total - 1; i >= 0; i--)
   {
      if(!posinfo.SelectByIndex(i)) continue;
      if(posinfo.Symbol() != _Symbol || posinfo.Magic() != (long)magic_No) continue;

      bool isBuy = (posinfo.PositionType() == POSITION_TYPE_BUY);
      double entryPrice = posinfo.PriceOpen();
      double currentPrice = isBuy ? SymbolInfoDouble(_Symbol, SYMBOL_BID)
                                  : SymbolInfoDouble(_Symbol, SYMBOL_ASK);

      double profitPips = isBuy ? (currentPrice - entryPrice) / _Point
                                : (entryPrice - currentPrice) / _Point;

      if(profitPips < TrailStartPips) continue;

      double desiredSL = isBuy ? currentPrice - TrailSLPips * _Point
                               : currentPrice + TrailSLPips * _Point;

      double currentSL = posinfo.StopLoss();

      if(isBuy)
      {
         if(desiredSL <= currentSL) continue;
      }
      else
      {
         if(desiredSL >= currentSL && currentSL != 0.0) continue;
      }

      double slMoveDistance = isBuy ? (desiredSL - currentSL) / _Point
                                    : (currentSL - desiredSL) / _Point;

      if(currentSL == 0.0 || slMoveDistance >= TrailStepPips)
      {
         desiredSL = NormalizeDouble(desiredSL, _Digits);

         double stopLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * _Point;

         if(isBuy && (currentPrice - desiredSL < stopLevel)) continue;
         if(!isBuy && (desiredSL - currentPrice < stopLevel)) continue;

         if(!trade.PositionModify(posinfo.Ticket(), desiredSL, posinfo.TakeProfit()))
            Print("❌ Failed to trail ticket #", posinfo.Ticket(), " Error: ", GetLastError());
         else
            Print("✅ Trailed ticket #", posinfo.Ticket(), " New SL = ", DoubleToString(desiredSL, _Digits));
      }
   }
}

void Mirror_SL_to_OppositePending()
{
   if(CountMarketOrders(ORDER_TYPE_BUY) > 0)
   {
      double buy_sl = 0;
      double lot = GetLotSize(lotMode, lotValue, Stoploss);

      for(int i = PositionsTotal() - 1; i >= 0; i--)
      {
         if(posinfo.SelectByIndex(i) &&
            posinfo.Symbol() == _Symbol &&
            posinfo.PositionType() == POSITION_TYPE_BUY &&
            posinfo.Magic() == (long)magic_No)
         {
            buy_sl = posinfo.StopLoss();
            break;
         }
      }

      if(buy_sl == 0) return;

      bool found = false;

      for(int i = OrdersTotal() - 1; i >= 0; i--)
      {
         ulong ticket = OrderGetTicket(i);

         if(OrderSelect(ticket))
         {
            if(OrderGetString(ORDER_SYMBOL) == _Symbol &&
               OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_SELL_STOP &&
               OrderGetInteger(ORDER_MAGIC) == (long)magic_No)
            {
               found = true;
               double oldPrice = OrderGetDouble(ORDER_PRICE_OPEN);

               if(MathAbs(oldPrice - buy_sl) > (_Point * 5))
               {
                  double sl = buy_sl + Stoploss * _Point;
                  ModifyPendingOrderToPrice(ticket, buy_sl, sl, 0);
               }
            }
         }
      }

      if(!found)
      {
         double sl = buy_sl + Stoploss * _Point;
         trade.SellStop(lot, buy_sl, _Symbol, sl, 0, ORDER_TIME_DAY, 0, "mirror sellstop");
      }
   }

   if(CountMarketOrders(ORDER_TYPE_SELL) > 0)
   {
      double sell_sl = 0;
      double lot = GetLotSize(lotMode, lotValue, Stoploss);

      for(int i = PositionsTotal() - 1; i >= 0; i--)
      {
         if(posinfo.SelectByIndex(i) &&
            posinfo.Symbol() == _Symbol &&
            posinfo.PositionType() == POSITION_TYPE_SELL &&
            posinfo.Magic() == (long)magic_No)
         {
            sell_sl = posinfo.StopLoss();
            break;
         }
      }

      if(sell_sl == 0) return;

      bool found = false;

      for(int i = OrdersTotal() - 1; i >= 0; i--)
      {
         ulong ticket = OrderGetTicket(i);

         if(OrderSelect(ticket))
         {
            if(OrderGetString(ORDER_SYMBOL) == _Symbol &&
               OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_STOP &&
               OrderGetInteger(ORDER_MAGIC) == (long)magic_No)
            {
               found = true;
               double oldPrice = OrderGetDouble(ORDER_PRICE_OPEN);

               if(MathAbs(oldPrice - sell_sl) > (_Point * 5))
               {
                  double sl = sell_sl - Stoploss * _Point;
                  ModifyPendingOrderToPrice(ticket, sell_sl, sl, 0);
               }
            }
         }
      }

      if(!found)
      {
         double sl = sell_sl - Stoploss * _Point;
         trade.BuyStop(lot, sell_sl, _Symbol, sl, 0, ORDER_TIME_DAY, 0, "mirror buystop");
      }
   }
}

bool ModifyPendingOrderToPrice(ulong ticket, double newPrice, double sl, double tp)
{
   MqlTradeRequest request;
   MqlTradeResult result;
   ZeroMemory(request);
   ZeroMemory(result);

   request.action = TRADE_ACTION_MODIFY;
   request.order = ticket;
   request.price = NormalizeDouble(newPrice, _Digits);
   request.sl = NormalizeDouble(sl, _Digits);
   request.tp = NormalizeDouble(tp, _Digits);
   request.symbol = _Symbol;

   if(!OrderSend(request, result) || result.retcode != TRADE_RETCODE_DONE)
   {
      Print("❌ Modify failed: ", result.retcode);
      return false;
   }

   return true;
}

double GetFastMA(int period, int shift)
{
   double value[];

   if(CopyBuffer(handle1, 0, shift, 1, value) > 0)
      return value[0];

   return 0;
}

double GetSlowMA(int period, int shift)
{
   double value[];

   if(CopyBuffer(handle2, 0, shift, 1, value) > 0)
      return value[0];

   return 0;
}

double GetADX(int shift)
{
   double adxBuffer[];

   if(CopyBuffer(adxHandle, 0, shift, 1, adxBuffer) > 0)
      return adxBuffer[0];

   Print("⚠️ Failed to get ADX value at shift ", shift);
   return 0;
}

void modifybuystop()
{
   double predefinedDistance = distance * _Point;
   double stopLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * _Point;
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   for(int i = 0; i < OrdersTotal(); i++)
   {
      ulong ticket = OrderGetTicket(i);

      if(OrderSelect(ticket))
      {
         if(OrderGetInteger(ORDER_MAGIC) == (long)magic_No &&
            OrderGetString(ORDER_SYMBOL) == _Symbol &&
            OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_STOP)
         {
            double currentPrice = OrderGetDouble(ORDER_PRICE_OPEN);
            double newPrice = ask + predefinedDistance;

            if(newPrice < currentPrice && (newPrice - ask) >= stopLevel)
            {
               double newSL = newPrice - Stoploss * _Point;

               if(!trade.OrderModify(ticket, newPrice, newSL, 0.0, ORDER_TIME_GTC, 0))
                  Print("❌ Failed to modify Buy Stop. Error: ", GetLastError());
               else
                  Print("✅ Buy Stop moved down to ", DoubleToString(newPrice, _Digits));
            }
         }
      }
   }
}

void modifysellstop()
{
   double predefinedDistance = distance * _Point;
   double stopLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * _Point;
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   for(int i = 0; i < OrdersTotal(); i++)
   {
      ulong ticket = OrderGetTicket(i);

      if(OrderSelect(ticket))
      {
         if(OrderGetInteger(ORDER_MAGIC) == (long)magic_No &&
            OrderGetString(ORDER_SYMBOL) == _Symbol &&
            OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_SELL_STOP)
         {
            double currentPrice = OrderGetDouble(ORDER_PRICE_OPEN);
            double newPrice = bid - predefinedDistance;

            if(newPrice > currentPrice && (bid - newPrice) >= stopLevel)
            {
               double newSL = newPrice + Stoploss * _Point;

               if(!trade.OrderModify(ticket, newPrice, newSL, 0.0, ORDER_TIME_GTC, 0))
                  Print("❌ Failed to modify Sell Stop. Error: ", GetLastError());
               else
                  Print("✅ Sell Stop moved up to ", DoubleToString(newPrice, _Digits));
            }
         }
      }
   }
}

double CalcDailyClosedProfit()
{
   double profit = 0.0;

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

   datetime timeDayStart = StructToTime(dt);

   HistorySelect(timeDayStart, TimeCurrent() + 100);

   for(int i = HistoryDealsTotal() - 1; i >= 0; i--)
   {
      ulong dealTicket = HistoryDealGetTicket(i);
      int entry = (int)HistoryDealGetInteger(dealTicket, DEAL_ENTRY);
      long magic = HistoryDealGetInteger(dealTicket, DEAL_MAGIC);

      if(entry == DEAL_ENTRY_OUT && magic == (long)magic_No)
      {
         double dealProfit = HistoryDealGetDouble(dealTicket, DEAL_PROFIT);
         double dealCommission = HistoryDealGetDouble(dealTicket, DEAL_COMMISSION);
         double dealSwap = HistoryDealGetDouble(dealTicket, DEAL_SWAP);

         profit += dealProfit + dealCommission + dealSwap;
      }
   }

   return profit;
}

double CalcOpenProfitByMagic()
{
   double profit = 0.0;

   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(pos.SelectByIndex(i))
      {
         if(pos.Symbol() == _Symbol && pos.Magic() == (long)magic_No)
            profit += pos.Profit();
      }
   }

   return profit;
}

void OnTradeTransaction(
   const MqlTradeTransaction &trans,
   const MqlTradeRequest &request,
   const MqlTradeResult &result
)
{
   if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
      profitClosed = CalcDailyClosedProfit();
}

void CheckAndResetDailyCounters()
{
   MqlDateTime now;
   TimeToStruct(TimeCurrent(), now);
   now.hour = 0;
   now.min = 0;
   now.sec = 0;

   datetime todayMidnight = StructToTime(now);

   if(dayStartTime != todayMidnight)
   {
      dayStartTime = todayMidnight;
      dailyTargetHit = false;
      profitClosed = CalcDailyClosedProfit();

      Print("🔄 Daily counters reset for new day: ", TimeToString(dayStartTime, TIME_DATE));
   }
}

void CloseAllOrdersByMagic(int magic)
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(pos.SelectByIndex(i) && pos.Magic() == magic && pos.Symbol() == _Symbol)
         trade.PositionClose(pos.Ticket());
   }

   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      ulong ticket = OrderGetTicket(i);

      if(OrderSelect(ticket))
      {
         if(OrderGetInteger(ORDER_MAGIC) == magic &&
            OrderGetString(ORDER_SYMBOL) == _Symbol)
         {
            trade.OrderDelete(ticket);
         }
      }
   }

   Print("✅ All positions & pending orders closed for magic: ", magic);
}

bool CheckDailyTargetAndLock()
{
   double profitOpen = CalcOpenProfitByMagic();
   double profitDay = profitOpen + profitClosed;

   if(profitDay >= DailyProfitTarget)
   {
      dailyTargetHit = true;
      CloseAllOrdersByMagic((int)magic_No);
      Comment("✅ Daily target reached — trading paused until tomorrow.");
      return true;
   }

   return false;
}

double GetLotSize(LotMode mode, double riskPercent, double slPoints)
{
   double lot = 0.01;
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   switch(mode)
   {
      case FixedLot:
         lot = riskPercent;
         break;

      case RiskLot:
         if(tickValue > 0 && tickSize > 0 && slPoints > 0)
         {
            double riskAmount = equity * riskPercent / 100.0;
            lot = riskAmount / (slPoints * (tickValue / tickSize));
         }
         break;

      case EquityLot:
         lot = equity * riskPercent / 100.0;
         break;
   }

   lot = MathMax(minLot, MathMin(maxLot, lot));

   if(lotStep > 0)
      lot = MathFloor(lot / lotStep) * lotStep;

   lot = NormalizeDouble(lot, 2);

   return lot;
}

bool IsCurrentTimeInInterval(ENUM_HOUR hStart, ENUM_MINUTE mStart, ENUM_HOUR hEnd, ENUM_MINUTE mEnd)
{
   MqlDateTime now;
   TimeToStruct(TimeCurrent(), now);

   int current = now.hour * 60 + now.min;
   int start = hStart * 60 + mStart;
   int end = hEnd * 60 + mEnd;

   if(start == end && current == start) return true;
   if(start < end && current >= start && current <= end) return true;
   if(start > end && (current >= start || current <= end)) return true;

   return false;
}

int Hour()
{
   MqlDateTime mTime;
   TimeToStruct(TimeCurrent(), mTime);
   return mTime.hour;
}                                                                                                                                                                                                                                                                      I created an MT5 bot, and I already shared the code, screenshots, and videos above.

The bot works perfectly on a demo account using the XAUUSD+ pair, but when I run the same bot on a Cent live account or on another demo account using the normal XAUUSD pair, it starts behaving incorrectly.

Let me explain the issues clearly:

1. Stop Loss issue on Cent live account

On the XAUUSD+ demo account, the Stop Loss works properly and always closes at the fixed level of 200 Dollar (40 points).

But on the Cent live account, the Stop Loss becomes irregular and does not close at the correct fixed distance.


2. Wrong trade sequence on normal XAUUSD pair

On another demo account using the normal XAUUSD pair, the bot keeps opening SELL trades after SELL trades, which is wrong.

The correct behavior should be:

After a BUY trade → the next opposite trade should be SELL.

After a SELL trade → the next opposite trade should be BUY.


This opposite-trade logic is working correctly on the XAUUSD+ demo account, but not on the normal XAUUSD pair.


I have already shared:

A video of the XAUUSD+ account where the bot is working properly.

Screenshots of the Cent live account where the Stop Loss is irregular.

Screenshots/videos showing the incorrect trade behavior on the normal XAUUSD pair.


Now I want the same properly working functionality and logic from the XAUUSD+ account to be implemented in a new version of the code, so that the bot works correctly on:

Cent accounts

Standard USD accounts

XAUUSD

XAUUSD+


The bot should behave consistently across all account types and symbol variations exactly like it does on the properly working XAUUSD+ demo account.

Responded

1
Developer 1
Rating
(168)
Projects
201
48%
Arbitration
5
20% / 60%
Overdue
2
1%
Working
2
Developer 2
Rating
(1)
Projects
2
0%
Arbitration
0
Overdue
1
50%
Working
3
Developer 3
Rating
Projects
0
0%
Arbitration
0
Overdue
0
Free
4
Developer 4
Rating
Projects
0
0%
Arbitration
0
Overdue
0
Free
5
Developer 5
Rating
(7)
Projects
8
88%
Arbitration
0
Overdue
0
Free
6
Developer 6
Rating
Projects
0
0%
Arbitration
0
Overdue
0
Free
Published: 1 code
7
Developer 7
Rating
(242)
Projects
285
77%
Arbitration
13
69% / 0%
Overdue
4
1%
Working
8
Developer 8
Rating
Projects
0
0%
Arbitration
0
Overdue
0
Free
9
Developer 9
Rating
Projects
0
0%
Arbitration
0
Overdue
0
Free
Published: 1 code
10
Developer 10
Rating
(10)
Projects
11
0%
Arbitration
3
0% / 33%
Overdue
1
9%
Working
11
Developer 11
Rating
(258)
Projects
264
30%
Arbitration
0
Overdue
3
1%
Free
Published: 2 codes
12
Developer 12
Rating
Projects
0
0%
Arbitration
0
Overdue
0
Free
13
Developer 13
Rating
Projects
0
0%
Arbitration
0
Overdue
0
Free
Similar orders
I need a Forex teacher 30+ USD
Hello! Is there any person who can teach me Forex. I prefer high time frame strategies Like H4, D1, but I am open for your propositions. Have a nice day
SNIPER X AI 30 - 200 USD
I really need a developer Who can help me to create my SNIPER X AI - Elite AI Trading System Overview SNIPER X AI BOT is an AI-assisted trading system for Forex, Crypto, Stocks, Indices, and Gold. Currency: USD,RAND,KWD, POUND,EURO Core Features AI Scalping, Sniper Entries, Auto Buy/Sell, Smart Risk Management, Telegram Alerts, Mobile Monitoring, VPS Deployment. Supported Platforms MetaTrader 4, MetaTrader 5, Exness
Emmanuel bot 30 USD
No thank you just choose for me I need to be automatically buy and sell and take a profit only that is enough for me thank you so much and my name is Emmanuel kabale
Emmanuel bot 30 USD
No thank you just choose for me I need to be automatically buy and sell and take a profit only that is enough for me thank you so much my name is Emmanuel kabale
Looking for a professional developer 50+ USD
I am looking for a professional developer to create an automated trading bot for Synthetic Derivative Indices. The bot should be designed for efficiency, precision, and stability, with the ability to execute trades automatically based on predefined strategies and market conditions. and synthetic indices trading is essential for this project
I need an EA working with 3 functions 50 - 70 USD
Existing EA needed Hi, Im looking to purchase or build an EA that can open many trades or big lot size to churn out IB commission, it doesnt have to be super profitable but will need to have the number of trades on going in order to earn IB commission. If you have any EA or strategy that are gearing towards this, let me know and i would be glad to purchase it
Limzy 30+ USD
//+------------------------------------------------------------------+ //| HighPerformanceEA.mq5 | //| Copyright 2026, AI Developer | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2026" #property link " https://www.mql5.com " #property version "1.00" #property strict //
XAUUSD-Only | SMC Trend Scalper EA with Stealth Basket Engine (MT5 – Deriv/Exness) 50 - 100 USD
I need an experienced MQL5 developer to build a professional XAUUSD scalping Expert Advisor. The trading logic is already fully defined and will be shared privately with selected developers. Requirements Fast execution suitable for scalping Dynamic lot sizing Strict risk management Clean and optimized MQL5 code Compatible with MetaTrader 5 Additional Rules No repainting logic No delayed execution Avoid duplicate
Please help me backtest strategy with volume profile 100 - 300 USD
It seems we need to convert this mql5 file into another platform like MULTICHARTS, NINJATRADER, SIERRACHART or other platform, I am open forr your sugestion, propositions, integrations etc. Anybody will help me with this project here? Source of code required
My expert needs to be implemented with candles , integrate it with present logic [Three Candles] . 30 - 50 USD
Prepare expert for xauusd live chart [ expert is not executing xauusd trades , just printing the logic on the chart ] . Deletion and cleaning code ( subject to if required ) . Integration of candles with present logic, Since expert is coming out from an arbitration subject : Before project start , review the code if it is clean and ready for the developer to continue with previous developer's technical debt -thereby

Project information

Budget
30+ USD

Customer

Placed orders1
Arbitrage count0