FreelanceSeções

VEE STRATEGY ROBOT

MQL5 Experts Outros Depuração de robôs/indicadores

Termos de Referência

//+------------------------------------------------------------------+
//| M5 Trend Pullback EA |
//| Exness / MT5 |
//| Forex + XAUUSD |
//| Risk: 0.5% per trade |
//+------------------------------------------------------------------+
#property strict
#property version "1.00"
#property description "M5 EMA50/EMA200 + RSI + ATR Trend Pullback EA"

#include <Trade/Trade.mqh>

CTrade trade;

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

//--- General
input ulong MagicNumber = 20260922;
input ENUM_TIMEFRAMES TradingTF = PERIOD_M5;

//--- Risk
input double RiskPercent = 0.50;
input double RewardRiskRatio = 2.00;
input double ATR_SL_Multiplier = 1.50;

//--- Indicators
input int FastEMA = 50;
input int SlowEMA = 200;
input int RSIPeriod = 14;
input int ATRPeriod = 14;

//--- Entry filters
input double RSI_Buy_Level = 50.0;
input double RSI_Sell_Level = 50.0;
input double PullbackToleranceATR = 0.50;

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

//--- Daily protection
input double MaxDailyLossPercent = 2.0;
input int MaxConsecutiveLosses = 3;

//--- Break-even
input bool UseBreakEven = true;
input double BreakEvenAtR = 1.0;
input double BreakEvenOffsetPoints = 5;

//--- Trading session
input bool UseSessionFilter = true;
input int StartHour = 7;
input int EndHour = 19;

//--- Execution
input int SlippagePoints = 20;

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

int emaFastHandle = INVALID_HANDLE;
int emaSlowHandle = INVALID_HANDLE;
int rsiHandle = INVALID_HANDLE;
int atrHandle = INVALID_HANDLE;

datetime lastBarTime = 0;

double dayStartEquity = 0.0;
int consecutiveLosses = 0;
int currentDay = -1;

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

int OnInit()
{
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(SlippagePoints);

   emaFastHandle = iMA(
      _Symbol,
      TradingTF,
      FastEMA,
      0,
      MODE_EMA,
      PRICE_CLOSE
   );

   emaSlowHandle = iMA(
      _Symbol,
      TradingTF,
      SlowEMA,
      0,
      MODE_EMA,
      PRICE_CLOSE
   );

   rsiHandle = iRSI(
      _Symbol,
      TradingTF,
      RSIPeriod,
      PRICE_CLOSE
   );

   atrHandle = iATR(
      _Symbol,
      TradingTF,
      ATRPeriod
   );

   if(emaFastHandle == INVALID_HANDLE ||
      emaSlowHandle == INVALID_HANDLE ||
      rsiHandle == INVALID_HANDLE ||
      atrHandle == INVALID_HANDLE)
   {
      Print("ERROR: Failed to create indicator handles.");
      return(INIT_FAILED);
   }

   ResetDailyStats();

   Print("M5 Trend Pullback EA initialized.");
   Print("Symbol: ", _Symbol);
   Print("Risk: ", DoubleToString(RiskPercent, 2), "%");

   return(INIT_SUCCEEDED);
}

//==================================================================
// DEINITIALIZATION
//==================================================================

void OnDeinit(const int reason)
{
   if(emaFastHandle != INVALID_HANDLE)
      IndicatorRelease(emaFastHandle);

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

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

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

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

void OnTick()
{
   UpdateDailyStats();

   ManageBreakEven();

   if(!IsNewBar())
      return;

   if(!TradingAllowed())
      return;

   if(HasOpenPosition())
      return;

   if(!SpreadIsAcceptable())
      return;

   if(!SessionAllowed())
      return;

   CheckForEntry();
}

//==================================================================
// NEW BAR DETECTION
//==================================================================

bool IsNewBar()
{
   datetime currentBar = iTime(_Symbol, TradingTF, 0);

   if(currentBar == 0)
      return false;

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

   return false;
}

//==================================================================
// ENTRY LOGIC
//==================================================================

void CheckForEntry()
{
   double emaFast[3];
   double emaSlow[3];
   double rsi[3];
   double atr[3];
   double closePrice[3];

   ArraySetAsSeries(emaFast, true);
   ArraySetAsSeries(emaSlow, true);
   ArraySetAsSeries(rsi, true);
   ArraySetAsSeries(atr, true);
   ArraySetAsSeries(closePrice, true);

   if(CopyBuffer(emaFastHandle, 0, 0, 3, emaFast) < 3)
      return;

   if(CopyBuffer(emaSlowHandle, 0, 0, 3, emaSlow) < 3)
      return;

   if(CopyBuffer(rsiHandle, 0, 0, 3, rsi) < 3)
      return;

   if(CopyBuffer(atrHandle, 0, 0, 3, atr) < 3)
      return;

   if(CopyClose(_Symbol, TradingTF, 0, 3, closePrice) < 3)
      return;

   // Use the LAST CLOSED candle: index 1
   double price = closePrice[1];
   double previousPrice = closePrice[2];

   double currentATR = atr[1];

   if(currentATR <= 0)
      return;

   //==============================================================
   // BUY CONDITIONS
   //==============================================================

   bool bullishTrend =
      price > emaSlow[1] &&
      emaFast[1] > emaSlow[1];

   bool pullbackBuy =
      price <= emaFast[1] + (currentATR * PullbackToleranceATR);

   bool rsiBuy =
      rsi[2] <= RSI_Buy_Level &&
      rsi[1] > RSI_Buy_Level;

   bool bullishCandle =
      price > previousPrice;

   if(bullishTrend &&
      pullbackBuy &&
      rsiBuy &&
      bullishCandle)
   {
      OpenBuy(currentATR);
      return;
   }

   //==============================================================
   // SELL CONDITIONS
   //==============================================================

   bool bearishTrend =
      price < emaSlow[1] &&
      emaFast[1] < emaSlow[1];

   bool pullbackSell =
      price >= emaFast[1] - (currentATR * PullbackToleranceATR);

   bool rsiSell =
      rsi[2] >= RSI_Sell_Level &&
      rsi[1] < RSI_Sell_Level;

   bool bearishCandle =
      price < previousPrice;

   if(bearishTrend &&
      pullbackSell &&
      rsiSell &&
      bearishCandle)
   {
      OpenSell(currentATR);
      return;
   }
}

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

void OpenBuy(double atr)
{
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   if(ask <= 0)
      return;

   double stopDistance = atr * ATR_SL_Multiplier;

   double sl = ask - stopDistance;
   double tp = ask + (stopDistance * RewardRiskRatio);

   AdjustStopsForBroker(ORDER_TYPE_BUY, ask, sl, tp);

   double lot = CalculateLotSize(
      ORDER_TYPE_BUY,
      ask,
      sl
   );

   if(lot <= 0)
      return;

   bool result = trade.Buy(
      lot,
      _Symbol,
      ask,
      sl,
      tp,
      "M5 Trend Pullback BUY"
   );

   if(result)
   {
      Print(
         "BUY opened | Lot=",
         DoubleToString(lot, 2),
         " | SL=",
         DoubleToString(sl, _Digits),
         " | TP=",
         DoubleToString(tp, _Digits)
      );
   }
   else
   {
      Print("BUY failed. Error: ", GetLastError());
   }
}

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

void OpenSell(double atr)
{
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   if(bid <= 0)
      return;

   double stopDistance = atr * ATR_SL_Multiplier;

   double sl = bid + stopDistance;
   double tp = bid - (stopDistance * RewardRiskRatio);

   AdjustStopsForBroker(ORDER_TYPE_SELL, bid, sl, tp);

   double lot = CalculateLotSize(
      ORDER_TYPE_SELL,
      bid,
      sl
   );

   if(lot <= 0)
      return;

   bool result = trade.Sell(
      lot,
      _Symbol,
      bid,
      sl,
      tp,
      "M5 Trend Pullback SELL"
   );

   if(result)
   {
      Print(
         "SELL opened | Lot=",
         DoubleToString(lot, 2),
         " | SL=",
         DoubleToString(sl, _Digits),
         " | TP=",
         DoubleToString(tp, _Digits)
      );
   }
   else
   {
      Print("SELL failed. Error: ", GetLastError());
   }
}

//==================================================================
// LOT SIZE CALCULATION
//==================================================================

double CalculateLotSize(
   ENUM_ORDER_TYPE orderType,
   double entryPrice,
   double stopLoss
)
{
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);

   double riskMoney =
      equity * (RiskPercent / 100.0);

   if(riskMoney <= 0)
      return 0;

   double tickSize =
      SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);

   double tickValue =
      SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);

   if(tickSize <= 0 || tickValue <= 0)
      return 0;

   double priceDistance =
      MathAbs(entryPrice - stopLoss);

   double ticks =
      priceDistance / tickSize;

   double lossPerLot =
      ticks * tickValue;

   if(lossPerLot <= 0)
      return 0;

   double lot =
      riskMoney / lossPerLot;

   return NormalizeVolume(lot);
}

//==================================================================
// VOLUME NORMALIZATION
//==================================================================

double NormalizeVolume(double volume)
{
   double minLot =
      SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);

   double maxLot =
      SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

   double lotStep =
      SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   if(lotStep <= 0)
      return 0;

   volume =
      MathFloor(volume / lotStep) * lotStep;

   volume =
      MathMax(volume, minLot);

   volume =
      MathMin(volume, maxLot);

   int digits = 2;

   if(lotStep == 0.1)
      digits = 1;

   if(lotStep == 0.01)
      digits = 2;

   if(lotStep == 0.001)
      digits = 3;

   return NormalizeDouble(volume, digits);
}

//==================================================================
// OPEN POSITION CHECK
//==================================================================

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

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      string symbol =
         PositionGetString(POSITION_SYMBOL);

      long magic =
         PositionGetInteger(POSITION_MAGIC);

      if(symbol == _Symbol &&
         magic == (long)MagicNumber)
      {
         return true;
      }
   }

   return false;
}

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

bool SpreadIsAcceptable()
{
   double ask =
      SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   double bid =
      SymbolInfoDouble(_Symbol, SYMBOL_BID);

   if(ask <= 0 || bid <= 0)
      return false;

   double spreadPoints =
      (ask - bid) / _Point;

   if(spreadPoints > MaxSpreadPoints)
   {
      Print(
         "Spread too high: ",
         DoubleToString(spreadPoints, 1),
         " points"
      );

      return false;
   }

   return true;
}

//==================================================================
// SESSION FILTER
//==================================================================

bool SessionAllowed()
{
   if(!UseSessionFilter)
      return true;

   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);

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

      return false;
   }

   // Handles sessions crossing midnight
   if(dt.hour >= StartHour ||
      dt.hour < EndHour)
      return true;

   return false;
}

//==================================================================
// DAILY PROTECTION
//==================================================================

bool TradingAllowed()
{
   if(dayStartEquity <= 0)
      return false;

   double equity =
      AccountInfoDouble(ACCOUNT_EQUITY);

   double dailyLossPercent =
      ((dayStartEquity - equity) /
       dayStartEquity) * 100.0;

   if(dailyLossPercent >= MaxDailyLossPercent)
   {
      Print("Daily loss limit reached.");

      return false;
   }

   if(consecutiveLosses >= MaxConsecutiveLosses)
   {
      Print("Maximum consecutive losses reached.");

      return false;
   }

   return true;
}

//==================================================================
// DAILY STATS
//==================================================================

void ResetDailyStats()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);

   currentDay = dt.day;

   dayStartEquity =
      AccountInfoDouble(ACCOUNT_EQUITY);

   consecutiveLosses = 0;
}

void UpdateDailyStats()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);

   if(dt.day != currentDay)
   {
      ResetDailyStats();
   }
}

//==================================================================
// BREAK-EVEN
//==================================================================

void ManageBreakEven()
{
   if(!UseBreakEven)
      return;

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

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      string symbol =
         PositionGetString(POSITION_SYMBOL);

      long magic =
         PositionGetInteger(POSITION_MAGIC);

      if(symbol != _Symbol ||
         magic != (long)MagicNumber)
         continue;

      long type =
         PositionGetInteger(POSITION_TYPE);

      double openPrice =
         PositionGetDouble(POSITION_PRICE_OPEN);

      double currentSL =
         PositionGetDouble(POSITION_SL);

      double currentTP =
         PositionGetDouble(POSITION_TP);

      double currentPrice;

      if(type == POSITION_TYPE_BUY)
         currentPrice =
            SymbolInfoDouble(_Symbol, SYMBOL_BID);
      else
         currentPrice =
            SymbolInfoDouble(_Symbol, SYMBOL_ASK);

      if(currentPrice <= 0)
         continue;

      double riskDistance =
         MathAbs(openPrice - currentSL);

      if(riskDistance <= 0)
         continue;

      if(type == POSITION_TYPE_BUY)
      {
         double profitDistance =
            currentPrice - openPrice;

         if(profitDistance >=
            riskDistance * BreakEvenAtR)
         {
            double newSL =
               openPrice +
               BreakEvenOffsetPoints * _Point;

            if(currentSL < newSL)
            {
               trade.PositionModify(
                  ticket,
                  NormalizeDouble(newSL, _Digits),
                  currentTP
               );
            }
         }
      }

      if(type == POSITION_TYPE_SELL)
      {
         double profitDistance =
            openPrice - currentPrice;

         if(profitDistance >=
            riskDistance * BreakEvenAtR)
         {
            double newSL =
               openPrice -
               BreakEvenOffsetPoints * _Point;

            if(currentSL == 0 ||
               currentSL > newSL)
            {
               trade.PositionModify(
                  ticket,
                  NormalizeDouble(newSL, _Digits),
                  currentTP
               );
            }
         }
      }
   }
}

//==================================================================
// BROKER STOP LEVEL ADJUSTMENT
//==================================================================

void AdjustStopsForBroker(
   ENUM_ORDER_TYPE orderType,
   double entry,
   double &sl,
   double &tp
)
{
   long stopLevel =
      SymbolInfoInteger(
         _Symbol,
         SYMBOL_TRADE_STOPS_LEVEL
      );

   double minimumDistance =
      stopLevel * _Point;

   if(orderType == ORDER_TYPE_BUY)
   {
      if(entry - sl < minimumDistance)
         sl = entry - minimumDistance;

      if(tp - entry < minimumDistance)
         tp = entry + minimumDistance;
   }

   if(orderType == ORDER_TYPE_SELL)
   {
      if(sl - entry < minimumDistance)
         sl = entry + minimumDistance;

      if(entry - tp < minimumDistance)
         tp = entry - minimumDistance;
   }

   sl = NormalizeDouble(sl, _Digits);
   tp = NormalizeDouble(tp, _Digits);
}

//==================================================================
// TRADE TRANSACTION
//==================================================================

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

   ulong dealTicket = trans.deal;

   if(dealTicket == 0)
      return;

   if(!HistoryDealSelect(dealTicket))
      return;

   long magic =
      HistoryDealGetInteger(
         dealTicket,
         DEAL_MAGIC
      );

   if(magic != (long)MagicNumber)
      return;

   long entryType =
      HistoryDealGetInteger(
         dealTicket,
         DEAL_ENTRY
      );

   if(entryType != DEAL_ENTRY_OUT)
      return;

   double profit =
      HistoryDealGetDouble(
         dealTicket,
         DEAL_PROFIT
      );

   double commission =
      HistoryDealGetDouble(
         dealTicket,
         DEAL_COMMISSION
      );

   double swap =
      HistoryDealGetDouble(
         dealTicket,
         DEAL_SWAP
      );

   double netResult =
      profit + commission + swap;

   if(netResult < 0)
   {
      consecutiveLosses++;

      Print(
         "Losing trade. Consecutive losses: ",
         consecutiveLosses
      );
   }
   else if(netResult > 0)
   {
      consecutiveLosses = 0;

      Print(
         "Winning trade. Consecutive losses reset."
      );
   }
}
//+------------------------------------------------------------------+

Respondido

1
Desenvolvedor 1
Classificação
(406)
Projetos
524
24%
Arbitragem
62
58% / 24%
Expirado
60
11%
Carregado
2
Desenvolvedor 2
Classificação
(2)
Projetos
4
0%
Arbitragem
0
Expirado
0
Livre
3
Desenvolvedor 3
Classificação
(24)
Projetos
34
41%
Arbitragem
9
22% / 33%
Expirado
5
15%
Ocupado
Publicou: 8 artigos, 35 códigos
4
Desenvolvedor 4
Classificação
(2)
Projetos
2
0%
Arbitragem
1
0% / 100%
Expirado
0
Livre
5
Desenvolvedor 5
Classificação
(565)
Projetos
862
61%
Arbitragem
33
27% / 45%
Expirado
24
3%
Livre
Publicou: 1 código
6
Desenvolvedor 6
Classificação
(258)
Projetos
269
29%
Arbitragem
2
50% / 0%
Expirado
3
1%
Trabalhando
Publicou: 2 códigos
7
Desenvolvedor 7
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
8
Desenvolvedor 8
Classificação
(266)
Projetos
316
74%
Arbitragem
17
71% / 0%
Expirado
6
2%
Trabalhando
9
Desenvolvedor 9
Classificação
(10)
Projetos
12
33%
Arbitragem
0
Expirado
2
17%
Trabalhando
Publicou: 1 código
10
Desenvolvedor 10
Classificação
(64)
Projetos
145
46%
Arbitragem
21
38% / 24%
Expirado
32
22%
Livre
11
Desenvolvedor 11
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
12
Desenvolvedor 12
Classificação
Projetos
1
0%
Arbitragem
0
Expirado
0
Livre
13
Desenvolvedor 13
Classificação
(14)
Projetos
23
35%
Arbitragem
0
Expirado
2
9%
Livre
14
Desenvolvedor 14
Classificação
(2)
Projetos
3
33%
Arbitragem
0
Expirado
2
67%
Trabalhando
15
Desenvolvedor 15
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
16
Desenvolvedor 16
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
17
Desenvolvedor 17
Classificação
(4)
Projetos
9
56%
Arbitragem
0
Expirado
2
22%
Carregado
Publicou: 6 códigos
18
Desenvolvedor 18
Classificação
(6)
Projetos
8
38%
Arbitragem
1
0% / 100%
Expirado
0
Livre
19
Desenvolvedor 19
Classificação
Projetos
1
0%
Arbitragem
0
Expirado
0
Livre
Publicou: 11 códigos
20
Desenvolvedor 20
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
21
Desenvolvedor 21
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
22
Desenvolvedor 22
Classificação
(1)
Projetos
1
0%
Arbitragem
0
Expirado
0
Livre
Publicou: 4 códigos
23
Desenvolvedor 23
Classificação
(10)
Projetos
14
43%
Arbitragem
0
Expirado
3
21%
Livre
24
Desenvolvedor 24
Classificação
(6)
Projetos
6
67%
Arbitragem
0
Expirado
0
Livre
25
Desenvolvedor 25
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
26
Desenvolvedor 26
Classificação
(12)
Projetos
12
17%
Arbitragem
2
0% / 50%
Expirado
1
8%
Livre
27
Desenvolvedor 27
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
28
Desenvolvedor 28
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
29
Desenvolvedor 29
Classificação
(1)
Projetos
1
0%
Arbitragem
0
Expirado
0
Livre
30
Desenvolvedor 30
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
31
Desenvolvedor 31
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
32
Desenvolvedor 32
Classificação
(574)
Projetos
945
47%
Arbitragem
309
58% / 27%
Expirado
125
13%
Livre
33
Desenvolvedor 33
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
Publicou: 1 código
34
Desenvolvedor 34
Classificação
Projetos
0
0%
Arbitragem
0
Expirado
0
Livre
Pedidos semelhantes
Metafix 50 - 200 USD
Here is a professional specification you can send directly to your developer. # Project Requirements Specification: MetaTrader 5 Trading Robot Development ### 1. Project Overview I want to develop an automated Forex trading robot (Expert Advisor) for MetaTrader 5 (MT5). The robot should analyse the financial markets, identify trading opportunities, and execute trades automatically based on predefined strategies. ###
FTMO-Compliant TradingView Webhook Multi-Timeframe & Dual-Position EA for XAUUSD (MT5) 150 - 200 USD
Overview: Build an MT5 Expert Advisor that receives webhook alerts from TradingView (RayAlgo indicator) across three timeframes ( H1, M5, M1 ) for XAUUSD and executes a dual-position strategy when all three conditions align, including strict FTMO server-request limits and automated pre-market-close trade closures. 1. Webhook Receiver & Multi-Timeframe State Logic: H1 Bias State: Updates to BULLISH or BEARISH upon
Experienced Trading Software Developer Needed for Long-Term Collaboration 50 - 200 USD
I am looking for an experienced trading software developer interested in building a long-term working relationship. Im a professional Trader, Coach and Mentor, I work with traders and Student who require customized trading solutions, including automated trading bots, Expert Advisors, custom indicators, trading strategies and other algorithmic trading tools. I am looking for a technically skilled developer who can
Salman serhal 30 - 100 USD
MT5 ICT XAUUSD Sell-Only Trading Robot with Fibonacci Confirmation I am looking for an experienced MQL5 developer to create a custom Expert Advisor (EA) for MetaTrader 5, specifically for trading Gold (XAUUSD). 1. Trading Strategy The robot must use the ICT trading methodology and focus on SELL trades only. The strategy should include: * Identify important resistance and premium zones. * Use Fibonacci retracement
MT5 Quantitative Strategy Validation, Deep Backtesting & Walk-Forward Optimization 100 - 200 USD
Objective: I am looking for an experienced MQL5 quantitative developer to code an Expert Advisor (EA) from scratch based on a fully defined, rule-based strategy, and then rigorously validate, optimize, and stress-test it before I deploy it on a live VPS environment. Note: The exact mathematical rules, indicator names, and chart screenshots will be shared privately with shortlisted candidates. Strategy Overview
Automated ES trading bot for tradovate or ninjatrader 50 - 300 USD
JOB SPECIFICATION: Fully Automated ES/MES 5-Minute NY Opening Range Breakout EA 1. Project objective I am looking for an experienced trading algo developer to build a fully automated trading bot (EA) based on my specific 5-minute New York Opening Range Breakout strategy. The EA must identify setups, confirm breakouts, identify retests, confirm continuation, execute trades, calculate position size, place stop-loss and
Profitable Smart Auto trade EA 30 - 80 USD
Custom MT5 Expert Advisor – Developer Specification 1. Project Objective Develop a fully autonomous, custom MetaTrader 5 Expert Advisor (EA) using native MQL5. The EA must independently analyze financial markets, generate its own trading signals, evaluate opportunities, execute trades, and manage open positions without requiring an external signal provider, another trading bot, or manual intervention. The EA must
Create a Combined Indicator from 3 EX4 Indicators + Fully Automatic Trading EA (MT4) 100+ USD
​​ Title: ​Create a Combined Indicator from 3 EX4 Indicators + Fully Automatic Trading EA (MT4) ​ Description: ​Hello, ​I need an experienced MQL4 developer to build a custom trading system based on 3 existing .ex4 indicators. ​ Project Requirements: ​ Combined Custom Indicator: ​Read and merge signals from 3 specified .ex4 indicators via buffer reading (iCustom). ​Generate a consolidated BUY or SELL arrow/signal
نازدك 30+ USD
Specify your Requirements Specification here point by point. Try to describe your requirements briefly and clearly, so that your potential developer is able to correctly assess its complexity and cost, as well as the required execution time. A bad or too generic description will result in your order being ignored, or you will spend a lot of time negotiating the details with each applicant. Remember: It is better to
Development of MT5 Expert Advisor (EA) – DSTR Novaa Strategy Replica with MQ5 Source Code 30 - 100 USD
I am looking for an experienced MQL5 developer to recreate my existing MT5 Expert Advisor (DSTR Novaa). I have the original compiled EX5 file, Vantage MT5 live trading history and original Strategy Tester report. Required Trading Logic: EMA Period: 3. BUY when price crosses below EMA 3. SELL when price crosses above EMA 3. Starting Lot: 0.01 (configurable). Martingale Multiplier: 2.0. Maximum Martingale Cycle: 9

Informações sobre o projeto

Orçamento
30 - 200 USD
Prazo
de 10 para 60 dias