FreelanceSezioni

Krushan

MQL5 Esperti

Specifiche

#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.

Con risposta

1
Sviluppatore 1
Valutazioni
(168)
Progetti
201
48%
Arbitraggio
5
20% / 60%
In ritardo
2
1%
In elaborazione
2
Sviluppatore 2
Valutazioni
(1)
Progetti
2
0%
Arbitraggio
0
In ritardo
1
50%
In elaborazione
3
Sviluppatore 3
Valutazioni
Progetti
0
0%
Arbitraggio
0
In ritardo
0
Gratuito
4
Sviluppatore 4
Valutazioni
Progetti
0
0%
Arbitraggio
0
In ritardo
0
Gratuito
5
Sviluppatore 5
Valutazioni
(7)
Progetti
8
88%
Arbitraggio
0
In ritardo
0
Gratuito
6
Sviluppatore 6
Valutazioni
Progetti
0
0%
Arbitraggio
0
In ritardo
0
Gratuito
Pubblicati: 1 codice
7
Sviluppatore 7
Valutazioni
(242)
Progetti
285
77%
Arbitraggio
13
69% / 0%
In ritardo
4
1%
In elaborazione
8
Sviluppatore 8
Valutazioni
Progetti
0
0%
Arbitraggio
0
In ritardo
0
Gratuito
9
Sviluppatore 9
Valutazioni
Progetti
0
0%
Arbitraggio
0
In ritardo
0
Gratuito
Pubblicati: 1 codice
Ordini simili
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
Teach me orderflow 30+ USD
I need good teacher to teach me orderflow. Thank you in advance :) only persons who have real experience with this. Please present me strategy with clear rules that I can repeat
Dynamic Hedging EA 100 - 200 USD
Hello, I am looking for a developer capable of developing a dynamic Hedging EA. I would like an EA designed for hedging trades. It main goal is to ensure help manage other EA from extraneous drawdowns
Looking for Experienced EA Developer for Long-Term Prop Firm Trading System 100 - 2000 USD
Hello, I am looking for an experienced developer who can build a professional EA suitable for long-term prop firm account passing and account management. I am NOT interested in risky strategies such as martingale, grid, or aggressive recovery systems. My main priorities are: very low and stable drawdown, strong and consistent risk management, strict news filter, long-term sustainability, realistic and stable monthly
Looking to publish charts, CSV data to our website 150+ USD
Dear developers. We seek experienced developer in PHP, MySQL, JavaScript. we want to publish custom chart and CSV to our website Homepage. Our MQL5 Script contains custom layout we seek to publish on the website. we are looking for experienced developer in the field of website engineer. we want to broadcast our custom pairs in our website, as outlined in our MQL5 Script. we need React developers
Need a consistent profitable EA 90+%.. Best could be 99% 30+ USD
Need a Profitable with a good trading system or strategy. would test the product first Looking for a professional MT5 Expert Advisor based on smart strategies. The EA should include session filters, risk management, trailing stop, multi-pair support, and low drawdown protection. I need a consistent, high-probability automated trading system optimized for long-term profitability and funded account compliance
QA Test MT4/MT5 Trade Event Monitoring EA on Gold Demo Account 30+ USD
I need an experienced MT4/MT5 user or MQL4/MQL5 developer to test the MT4/MT5 sender EA used by Signalator Notify . The EA does not open trades, does not provide trading signals, and does not decide when to buy or sell. Its role is to run inside MT4/MT5 and report terminal status and trade-related events, so the purpose of this job is to check whether that monitoring workflow works correctly in a real terminal

Informazioni sul progetto

Budget
30+ USD

Cliente

Ordini effettuati1
Numero di arbitraggi0