自由职业者部分

TrendPullbackEA.mq5

MQL5 专家 外汇 自动交易/指标调试 C++

指定


#property strict
#property version   "1.00"
#property description "EMA Trend + Pullback + Engulfing EA"

// Include the standard MT5 trade library.
#include <Trade/Trade.mqh>

CTrade trade;

//==============================================================
// INPUT SETTINGS
//==============================================================

// Trend indicators
input int FastEMA = 20;
input int SlowEMA = 50;

// Pullback settings
input int PullbackBars = 5;

// Stop-loss settings
// 0 = recent swing high/low
// 1 = ATR-based stop loss
input int    SL_Mode = 0;
input int    ATR_Period = 14;
input double ATR_Multiplier = 1.5;

// Take-profit setting
input double RiskReward = 2.0;

// Money management
input bool   UseFixedLot = true;
input double FixedlotSize = 0.10;
input double RiskPercent = 1.0;

// Trading controls
input ulong MagicNumber = 20261029;
input int   TradeStartHour = 8;
input int   TradeEndHour = 17;

// Debug messages in the Experts tab
input bool DebugMode = true;

//==============================================================
// GLOBAL VARIABLES
//==============================================================

// Indicator handles are created once and reused.
int fastEMAHandle = INVALID_HANDLE;
int slowEMAHandle = INVALID_HANDLE;
int atrHandle     = INVALID_HANDLE;

// Remember the opening time of the current candle.
// This ensures that signals are checked only once per candle.
datetime lastBarTime = 0;

//==============================================================
// DEBUGGING HELPER
//==============================================================
void DebugPrint(string message)
{
   if(DebugMode)
      Print("[TrendPullbackEA] ", message);
}

//==============================================================
// INITIALIZATION
//==============================================================
int OnInit()
{
   // Validate settings before starting.
   if(FastEMA <= 0 || SlowEMA <= 0 ||
      FastEMA >= SlowEMA ||
      PullbackBars < 1 ||
      ATR_Period <= 0 ||
      ATR_Multiplier <= 0 ||
      RiskReward <= 0 ||
      SL_Mode < 0 || SL_Mode > 1 ||
      FixedlotSize <= 0 ||
      RiskPercent <= 0 ||
      TradeStartHour < 0 || TradeStartHour > 23 ||
      TradeEndHour < 0 || TradeEndHour > 23)
   {
      Print("Invalid EA input settings. Check the Inputs tab.");
      return INIT_PARAMETERS_INCORRECT;
   }

   // Create the EMA indicator handles for the chart timeframe.
   fastEMAHandle = iMA(_Symbol, _Period, FastEMA,
                       0, MODE_EMA, PRICE_CLOSE);

   slowEMAHandle = iMA(_Symbol, _Period, SlowEMA,
                       0, MODE_EMA, PRICE_CLOSE);

   // Create the ATR handle, used when SL_Mode = 1.
   atrHandle = iATR(_Symbol, _Period, ATR_Period);

   // Stop if any indicator could not be initialized.
   if(fastEMAHandle == INVALID_HANDLE ||
      slowEMAHandle == INVALID_HANDLE ||
      atrHandle == INVALID_HANDLE)
   {
      Print("Failed to create indicator handles. Error: ",
            GetLastError());
      return INIT_FAILED;
   }

   // Configure the trade object.
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetTypeFillingBySymbol(_Symbol);
   trade.SetAsyncMode(false);

   // Initialize the current candle time.
   lastBarTime = iTime(_Symbol, _Period, 0);

   DebugPrint("EA initialized successfully.");

   return INIT_SUCCEEDED;
}

//==============================================================
// SHUTDOWN
//==============================================================
void OnDeinit(const int reason)
{
   // Release indicator resources when the EA is removed.
   if(fastEMAHandle != INVALID_HANDLE)
      IndicatorRelease(fastEMAHandle);

   if(slowEMAHandle != INVALID_HANDLE)
      IndicatorRelease(slowEMAHandle);

   if(atrHandle != INVALID_HANDLE)
      IndicatorRelease(atrHandle);

   DebugPrint("EA stopped.");
}

//==============================================================
// NEW CANDLE DETECTION
//==============================================================
bool IsNewBar()
{
   datetime currentBarTime = iTime(_Symbol, _Period, 0);

   if(currentBarTime == 0)
      return false;

   if(currentBarTime != lastBarTime)
   {
      lastBarTime = currentBarTime;
      return true;
   }

   return false;
}

//==============================================================
// TRADING HOURS
//==============================================================
bool IsTradingTime()
{
   // Uses broker/server time, not your computer's local time.
   MqlDateTime currentTime;
   TimeToStruct(TimeTradeServer(), currentTime);

   int hour = currentTime.hour;

   // Equal start and end hours means trading all day.
   if(TradeStartHour == TradeEndHour)
      return true;

   // Normal session, for example 08:00 to 17:00.
   if(TradeStartHour < TradeEndHour)
   {
      return (hour >= TradeStartHour &&
              hour < TradeEndHour);
   }

   // Overnight session, for example 22:00 to 06:00.
   return (hour >= TradeStartHour ||
           hour < TradeEndHour);
}

//==============================================================
// CHECK FOR AN EXISTING POSITION ON THIS SYMBOL
//==============================================================
bool HasOpenPosition()
{
   // Check all open positions.
   // This prevents another trade on the symbol, even if another
   // EA or a manual trade opened the existing position.
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         return true;
   }

   return false;
}

//==============================================================
// LOAD INDICATOR VALUES
//==============================================================
bool GetIndicatorValue(int handle, int shift, double &value)
{
   double buffer[1];

   // Copy one indicator value from the requested candle.
   if(CopyBuffer(handle, 0, shift, 1, buffer) != 1)
      return false;

   value = buffer[0];

   return (value != EMPTY_VALUE);
}

//==============================================================
// PULLBACK DETECTION
//==============================================================
bool HasPullback()
{
   // Search completed candles BEFORE the engulfing candle.
   // Shift 1 is the signal candle, so start from shift 2.
   for(int shift = 2; shift <= PullbackBars + 1; shift++)
   {
      double fastEMA, slowEMA;

      if(!GetIndicatorValue(fastEMAHandle, shift, fastEMA) ||
         !GetIndicatorValue(slowEMAHandle, shift, slowEMA))
      {
         return false;
      }

      double candleHigh = iHigh(_Symbol, _Period, shift);
      double candleLow  = iLow(_Symbol, _Period, shift);

      // The area between the two EMAs.
      double zoneHigh = MathMax(fastEMA, slowEMA);
      double zoneLow  = MathMin(fastEMA, slowEMA);

      // The candle range overlaps the EMA zone.
      if(candleLow <= zoneHigh && candleHigh >= zoneLow)
         return true;
   }

   return false;
}

//==============================================================
// BULLISH ENGULFING PATTERN
//==============================================================
bool IsBullishEngulfing()
{
   // Candle 1 is the most recently completed candle.
   // Candle 2 is the completed candle immediately before it.
   double open1  = iOpen(_Symbol, _Period, 1);
   double close1 = iClose(_Symbol, _Period, 1);
   double open2  = iOpen(_Symbol, _Period, 2);
   double close2 = iClose(_Symbol, _Period, 2);

   // Previous candle must be bearish.
   // Signal candle must be bullish and engulf the previous body.
   return (close2 < open2 &&
           close1 > open1 &&
           open1 <= close2 &&
           close1 >= open2);
}

//==============================================================
// BEARISH ENGULFING PATTERN
//==============================================================
bool IsBearishEngulfing()
{
   double open1  = iOpen(_Symbol, _Period, 1);
   double close1 = iClose(_Symbol, _Period, 1);
   double open2  = iOpen(_Symbol, _Period, 2);
   double close2 = iClose(_Symbol, _Period, 2);

   // Previous candle must be bullish.
   // Signal candle must be bearish and engulf the previous body.
   return (close2 > open2 &&
           close1 < open1 &&
           open1 >= close2 &&
           close1 <= open2);
}

//==============================================================
// FIND RECENT SWING STOP-LOSS PRICE
//==============================================================
double GetSwingStopLoss(bool isBuy)
{
   // Include the signal candle and recent candles before it.
   // This is a simple rolling swing approximation, not a
   // specialized market-structure swing-point detector.
   int lookback = PullbackBars + 1;

   double swingPrice = isBuy
                       ? iLow(_Symbol, _Period, 1)
                       : iHigh(_Symbol, _Period, 1);

   for(int shift = 2; shift <= lookback + 1; shift++)
   {
      if(isBuy)
      {
         double candleLow = iLow(_Symbol, _Period, shift);

         if(candleLow < swingPrice)
            swingPrice = candleLow;
      }
      else
      {
         double candleHigh = iHigh(_Symbol, _Period, shift);

         if(candleHigh > swingPrice)
            swingPrice = candleHigh;
      }
   }

   return swingPrice;
}

//==============================================================
// NORMALIZE LOT SIZE TO BROKER REQUIREMENTS
//==============================================================
double NormalizeVolume(double volume)
{
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double step   = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   if(step <= 0 || minLot <= 0 || maxLot <= 0)
      return 0.0;

   // Do not increase an undersized risk-based lot to the broker's
   // minimum, because that could exceed the intended risk.
   if(volume < minLot)
      return 0.0;

   volume = MathMin(volume, maxLot);

   // Round DOWN to a valid volume step.
   volume = MathFloor(volume / step + 1e-9) * step;

   if(volume < minLot)
      return 0.0;

   // Derive the number of decimal places from the volume step.
   int digits = 0;
   double checkStep = step;

   while(digits < 8 &&
         MathAbs(checkStep - MathRound(checkStep)) > 1e-8)
   {
      checkStep *= 10.0;
      digits++;
   }

   return NormalizeDouble(volume, digits);
}

//==============================================================
// CALCULATE LOT SIZE
//==============================================================
double CalculateLotSize(bool isBuy, double entryPrice,
                        double stopLoss)
{
   // Fixed-lot mode: use the user-defined lot size.
   if(UseFixedLot)
      return NormalizeVolume(FixedlotSize);

   // Risk-based mode: calculate risk as a percentage of equity.
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   double riskMoney = equity * RiskPercent / 100.0;

   if(equity <= 0 || riskMoney <= 0)
      return 0.0;

   // Ask MT5 to estimate the monetary result for one lot
   // if the stop-loss price is reached.
   double profitAtSL = 0.0;

   ENUM_ORDER_TYPE orderType = isBuy ? ORDER_TYPE_BUY
                                     : ORDER_TYPE_SELL;

   if(!OrderCalcProfit(orderType, _Symbol, 1.0,
                       entryPrice, stopLoss, profitAtSL))
   {
      DebugPrint("OrderCalcProfit failed. Error: " +
                 IntegerToString(GetLastError()));
      return 0.0;
   }

   double lossPerLot = MathAbs(profitAtSL);

   if(lossPerLot <= 0)
      return 0.0;

   double rawLots = riskMoney / lossPerLot;

   return NormalizeVolume(rawLots);
}

//==============================================================
// VALIDATE STOP LOSS AND TAKE PROFIT DISTANCES
//==============================================================
bool ValidateStops(bool isBuy, double entryPrice,
                   double stopLoss, double takeProfit)
{
   // Check that prices are on the correct sides of entry.
   if(isBuy && (stopLoss >= entryPrice ||
                takeProfit <= entryPrice))
      return false;

   if(!isBuy && (stopLoss <= entryPrice ||
                 takeProfit >= entryPrice))
      return false;

   // Respect the broker's minimum stop distance.
   long stopsLevel = SymbolInfoInteger(_Symbol,
                                       SYMBOL_TRADE_STOPS_LEVEL);

   double minimumDistance = stopsLevel * _Point;

   if(isBuy)
   {
      if(entryPrice - stopLoss < minimumDistance ||
         takeProfit - entryPrice < minimumDistance)
         return false;
   }
   else
   {
      if(stopLoss - entryPrice < minimumDistance ||
         entryPrice - takeProfit < minimumDistance)
         return false;
   }

   return true;
}

//==============================================================
// OPEN A TRADE
//==============================================================
void OpenTrade(bool isBuy)
{
   MqlTick tick;

   if(!SymbolInfoTick(_Symbol, tick))
   {
      DebugPrint("Unable to obtain current market prices.");
      return;
   }

   // A market order fills at the current ask for a buy
   // and at the current bid for a sell.
   double entryPrice = isBuy ? tick.ask : tick.bid;

   double stopLoss = 0.0;

   // Select the requested stop-loss method.
   if(SL_Mode == 0)
   {
      stopLoss = GetSwingStopLoss(isBuy);
   }
   else
   {
      double atrValue;

      if(!GetIndicatorValue(atrHandle, 1, atrValue) ||
         atrValue <= 0)
      {
         DebugPrint("ATR value unavailable.");
         return;
      }

      double distance = atrValue * ATR_Multiplier;

      stopLoss = isBuy ? entryPrice - distance
                       : entryPrice + distance;
   }

   // Normalize SL to the symbol's price precision.
   stopLoss = NormalizeDouble(stopLoss, _Digits);

   // Check that the stop-loss is valid before sizing the trade.
   if((isBuy && stopLoss >= entryPrice) ||
      (!isBuy && stopLoss <= entryPrice))
   {
      DebugPrint("Invalid stop-loss price.");
      return;
   }

   // The target is based on the distance from entry to SL.
   double riskDistance = MathAbs(entryPrice - stopLoss);

   double takeProfit = isBuy
                       ? entryPrice + riskDistance * RiskReward
                       : entryPrice - riskDistance * RiskReward;

   takeProfit = NormalizeDouble(takeProfit, _Digits);

   // Do not send orders that violate broker stop-distance rules.
   if(!ValidateStops(isBuy, entryPrice, stopLoss, takeProfit))
   {
      DebugPrint("Trade skipped: stop distances are invalid "
                 "or too close to market price.");
      return;
   }

   // Calculate volume only after the final stop-loss is known.
   double lots = CalculateLotSize(isBuy, entryPrice, stopLoss);

   if(lots <= 0)
   {
      DebugPrint("Trade skipped: calculated lot size is invalid "
                 "or below the broker minimum.");
      return;
   }

   // Send the market order with SL and TP attached.
   bool sent = false;

   if(isBuy)
   {
      sent = trade.Buy(lots, _Symbol, 0.0,
                       stopLoss, takeProfit,
                       "EMA Pullback Buy");
   }
   else
   {
      sent = trade.Sell(lots, _Symbol, 0.0,
                        stopLoss, takeProfit,
                        "EMA Pullback Sell");
   }

   // A successful method call does not always mean the broker
   // executed the order, so inspect the trade result retcode.
   uint retcode = trade.ResultRetcode();

   if(sent &&
      (retcode == TRADE_RETCODE_DONE ||
       retcode == TRADE_RETCODE_DONE_PARTIAL ||
       retcode == TRADE_RETCODE_PLACED))
   {
      DebugPrint(string(isBuy ? "BUY" : "SELL") +
                 " request accepted. Lots=" +
                 DoubleToString(lots, 4) +
                 ", SL=" + DoubleToString(stopLoss, _Digits) +
                 ", TP=" + DoubleToString(takeProfit, _Digits));
   }
   else
   {
      DebugPrint("Trade failed. Retcode=" +
                 IntegerToString((int)retcode) +
                 ", description=" + trade.ResultRetcodeDescription());
   }
}

//==============================================================
// MAIN EA LOGIC
//==============================================================
void OnTick()
{
   // Check signals once per new candle, not on every tick.
   if(!IsNewBar())
      return;

   // Ensure enough chart history is available.
   int requiredBars = MathMax(SlowEMA, ATR_Period)
                      + PullbackBars + 5;

   if(Bars(_Symbol, _Period) < requiredBars)
   {
      DebugPrint("Waiting for more candle history.");
      return;
   }

   // Do not open another position on this symbol.
   if(HasOpenPosition())
   {
      DebugPrint("Position already exists on this symbol.");
      return;
   }

   // Restrict new entries to the selected trading hours.
   if(!IsTradingTime())
   {
      DebugPrint("Outside trading hours.");
      return;
   }

   // Read EMA values from the most recently closed candle.
   double fastEMA, slowEMA;

   if(!GetIndicatorValue(fastEMAHandle, 1, fastEMA) ||
      !GetIndicatorValue(slowEMAHandle, 1, slowEMA))
   {
      DebugPrint("Unable to read EMA values.");
      return;
   }

   // Determine trend direction.
   bool uptrend   = (fastEMA > slowEMA);
   bool downtrend = (fastEMA < slowEMA);

   // Confirm that a pullback occurred before the signal candle.
   bool pullback = HasPullback();

   if(!pullback)
   {
      DebugPrint("No pullback into the EMA zone.");
      return;
   }

   // Evaluate the completed signal candle.
   if(uptrend && IsBullishEngulfing())
   {
      DebugPrint("Bullish engulfing after pullback. Buy signal.");
      OpenTrade(true);
   }
   else if(downtrend && IsBearishEngulfing())
   {
      DebugPrint("Bearish engulfing after pullback. Sell signal.");
      OpenTrade(false);
   }
   else
   {
      DebugPrint("No valid engulfing signal.");
   }
}

反馈

1
开发者 1
等级
(111)
项目
184
25%
仲裁
25
16% / 76%
逾期
16
9%
空闲
2
开发者 2
等级
(402)
项目
521
24%
仲裁
61
57% / 25%
逾期
60
12%
已载入
3
开发者 3
等级
(1)
项目
2
0%
仲裁
0
逾期
0
空闲
发布者： 15 代码
4
开发者 4
等级
项目
0
0%
仲裁
0
逾期
0
空闲
5
开发者 5
等级
(62)
项目
90
29%
仲裁
24
13% / 58%
逾期
7
8%
工作中
6
开发者 6
等级
项目
0
0%
仲裁
0
逾期
0
空闲
7
开发者 7
等级
项目
0
0%
仲裁
0
逾期
0
空闲
8
开发者 8
等级
项目
0
0%
仲裁
0
逾期
0
空闲
9
开发者 9
等级
(29)
项目
36
39%
仲裁
0
逾期
2
6%
空闲
10
开发者 10
等级
项目
0
0%
仲裁
0
逾期
0
空闲
发布者： 1 代码
11
开发者 11
等级
项目
0
0%
仲裁
0
逾期
0
空闲
12
开发者 12
等级
项目
0
0%
仲裁
0
逾期
0
空闲
13
开发者 13
等级
(1)
项目
1
0%
仲裁
0
逾期
0
空闲
发布者： 4 代码
14
开发者 14
等级
项目
0
0%
仲裁
0
逾期
0
空闲
15
开发者 15
等级
项目
0
0%
仲裁
0
逾期
0
空闲
16
开发者 16
等级
(2)
项目
2
0%
仲裁
1
0% / 100%
逾期
0
空闲
17
开发者 17
等级
(319)
项目
574
35%
仲裁
83
31% / 45%
逾期
207
36%
空闲
18
开发者 18
等级
项目
0
0%
仲裁
0
逾期
0
空闲
发布者： 10 代码
19
开发者 19
等级
项目
0
0%
仲裁
0
逾期
0
空闲
20
开发者 20
等级
(5)
项目
6
83%
仲裁
0
逾期
0
空闲
发布者： 2 代码
21
开发者 21
等级
(8)
项目
8
0%
仲裁
2
50% / 0%
逾期
1
13%
工作中
22
开发者 22
等级
项目
0
0%
仲裁
0
逾期
0
空闲
发布者： 4 代码
23
开发者 23
等级
项目
0
0%
仲裁
0
逾期
0
空闲
24
开发者 24
等级
项目
0
0%
仲裁
0
逾期
0
空闲
25
开发者 25
等级
项目
0
0%
仲裁
0
逾期
0
空闲
发布者： 1 代码
26
开发者 26
等级
项目
0
0%
仲裁
0
逾期
0
空闲
27
开发者 27
等级
项目
0
0%
仲裁
0
逾期
0
空闲
28
开发者 28
等级
项目
0
0%
仲裁
0
逾期
0
空闲
29
开发者 29
等级
项目
0
0%
仲裁
0
逾期
0
空闲
30
开发者 30
等级
(13)
项目
21
38%
仲裁
0
逾期
1
5%
工作中
31
开发者 31
等级
项目
0
0%
仲裁
0
逾期
0
空闲
32
开发者 32
等级
项目
0
0%
仲裁
0
逾期
0
空闲
发布者： 1 代码
33
开发者 33
等级
项目
0
0%
仲裁
0
逾期
0
空闲
34
开发者 34
等级
(6)
项目
8
38%
仲裁
1
0% / 100%
逾期
0
空闲
35
开发者 35
等级
项目
0
0%
仲裁
0
逾期
0
空闲
发布者： 1 代码
36
开发者 36
等级
项目
0
0%
仲裁
0
逾期
0
空闲
相似订单
Fast Scalper EA for multiple Pairs and Gold 30 - 100 USD
USD54 Applications The bot should open trades when the price breaks out of the band by a specified percentage, for example, 0.10%. If the price breaks above the band, the bot should open a long position. If the price breaks below the band, it should open a short position. The bot should also open trades when the price touches a band: Bullish band cross: When a bullish cross occurs between the bands, the bot should
Sviluppo EA XAUUSD M1 con Buy/Sell Stop e trailing stop 30 - 150 USD
Titolo: Cerco sviluppatore per EA su XAUUSD M1 per conto reale Cerco uno sviluppatore MQL5 per creare un Expert Advisor per MetaTrader 5 su XAUUSD M1, da utilizzare su conto reale con deposito iniziale di 100–200 €. La strategia prevede un Buy Stop a 1,00 sopra l’Ask e un Sell Stop a 1,00 sotto il Bid, entrambi con stop loss iniziale di 1,00 e senza take profit fisso. I pendenti devono restare fermi: quando uno viene
Master Scalping EA 30+ USD
// Meta Scalper EA - RSI + Breakout + Lot Management #property strict #include <Trade\Trade.mqh> CTrade trade; input int RSI_Period=14; input double RSI_Overbought=70; input double RSI_Oversold=30; input int Breakout_Period=20; input int ATR_Period=14; input double ATR_Multiplier_SL=1.5; input double ATR_Multiplier_TP=3.0; input bool UseRiskPercent=true; input double RiskPercent=2.0; input double FixedLot=0.1; input
Adaptive Multi-Signal Scalper 100-120$ - Multi Positions if Strong Signal / 1 if Weak - No Fixed SL/TP - Protect Profit on Reversal - All Markets - Source Code Included 100 - 120 USD
BUDGET: 100-120 USD - FIXED - includes source code .mq5 + .ex5 I will test demo first on 100$ demo account. If good, I pay. WHAT I WANT: 1. SIGNAL STRENGTH LOGIC: - WEAK SIGNAL = 1 position only. - STRONG SIGNAL = 2,3,4,5 positions (more positions because signal is strong). - Signal strength calculated by indicators. 2. ADAPTIVE TO CAPITAL: - Lot auto = Balance / 100 * 0.01. Example 100$ = 0.01 lot, 300$ = 0.03 lot
Need help or someone to create an expert advisor for automated trading, thanks 50 - 250 USD
Project: MT5 Expert Advisor — Dual-Sided Hedging Grid with Fibonacci Lot Progression I need a custom Expert Advisor (EA) developed in MQL5 for MetaTrader 5. 1. Trading Strategy The EA must open both Buy and Sell market positions when a new trading cycle starts, provided the broker account supports hedging. The EA must manage the Buy and Sell directions independently. When the market moves downward against the Buy
News trading made simple 30+ USD
Hello lovies, I’m reaching out because I’m working on a specialized macroeconomic intelligence service focused on major economic releases and their potential impact on gold (XAUUSD), the US dollar, and the wider financial markets. My approach goes beyond simply following the economic calendar. I focus on understanding the information behind upcoming events, market expectations, and the potential implications for
Convert tradingview pinescript to mt5 ea 30+ USD
Platform: MT5 only (no MT4 needed). Deliverable: an MT5 Expert Advisor with full source code (.mq5) that replicates the attached TradingView strategy (Pine Script v6, based on LuxAlgo's "ICT Killzones Toolkit" order blocks) as exactly as possible. Pasting the code into TradingView shows how it operates. I normally trade GBPUSD on the 5-minute chart Expected behavior: - Order block detection must match the Pine code
Fix and Optimize Forex Expert Advisor for USDJPY and GBPUSD 30 - 120 USD
Requirements Specification: Debug & Error Fixing: Review the entire source code of the MQL expert advisor. Identify and fix all logical errors, bugs, and performance issues that cause trades to close prematurely or yield extremely low profits. Strategy Restructuring & Optimization: Fully analyze and optimize the current entry and exit strategy for USDJPY and GBPUSD. Modify, upgrade, or completely rewrite the entry
Independent MQL5 Code Audit for an Existing MT5 EA 100 - 200 USD
I am looking for an MQL5 developer to independently review an existing EA’s execution and position management logic. The review should focus on duplicate orders, trade isolation by symbol and magic number, broker price and volume constraints, error handling, and recovery after a terminal restart. This order is for an audit report. Please do not modify the source or change the trading strategy. For each finding
Integrate an Existing MT5 Trading Robot with Broker FIX API 50 - 150 USD
I have an existing compiled MetaTrader 5 Expert Advisor (EX5) designed for automated XAUUSD scalping. I want an experienced developer to assess and implement a solution to execute the EA’s original trading strategy through my broker’s FIX API. Requirements: Confirm the technical feasibility of connecting an existing MT5 EA to a broker FIX API. Explain how to obtain FIX API access and credentials from the broker

项目信息

预算
30+ USD

客户

所下订单1
仲裁计数0