FreelanceKategorien

Make the strategy better with news filters and a better trailing SL

MQL5 Experten Debugging eines Roboters/Indikators C++

Spezifikation

//+------------------------------------------------------------------+
//| BORGMAN SMC EA v8.7 - INSTITUTIONAL MERGE |
//| Combines v8.5 risk architecture + v8.6 SMC engine |
//+------------------------------------------------------------------+
#property strict
#property version "8.70"

#include <Trade/Trade.mqh>
CTrade Trade;

//---------------------- ENUMS ----------------------//
enum ENUM_RR_MODE
{
   RR_2R, // 1:2
   RR_3R, // 1:3
   RR_5R // 1:5
};

enum ENUM_TRAIL_MODE
{
   TRAIL_NONE, // No trailing
   TRAIL_BREAKEVEN, // Move to breakeven at 1R
   TRAIL_DYNAMIC // v8.5 style: trail behind price by 1R distance
};

//---------------------- INPUTS ----------------------//
input group "--- Risk Management ---"
input double RiskPercentPerTrade = 0.50;
input double MaxLotHardCap = 0.25; // Your preferred fixed lot
input double MinLotFloor = 0.01;
input int MagicNumber = 87001;
input bool UseFixedLotMode = true; // If true, ignores risk% calc

input group "--- Prop Firm Guard ---"
input int MaxTradesPerDay = 2;
input int TradeCooldownMinutes = 25;
input double MaxDailyLossPct = 3.0;
input double MaxWeeklyLossPct = 6.0;
input double DailyProfitTargetPct = 1.5;
input bool CloseOnLock = true; // Close positions when limit hit

input group "--- Sessions ---"
input bool UseKillZones = true;
input bool TradeLondon = true;
input bool TradeNewYork = true;

input group "--- Filters ---"
input int MaxSpreadPoints = 18;
input ENUM_TIMEFRAMES HTF = PERIOD_H4;
input ENUM_TIMEFRAMES LTF = PERIOD_M15;
input bool UseNewsFilter = false; // Disabled until implemented

input group "--- SMC Engine ---"
input int SwingLookback = 20;
input int FVG_MinPips = 3;
input int OB_Lookback = 5;
input bool UseLiquiditySweeps = true;
input bool UseDisplacement = true;
input double DisplacementATR = 1.5;
input bool UseOrderBlocks = true;
input bool UseFVG = true;

input group "--- Entry Score ---"
input int MinEntryScore = 7;

input group "--- R:R & Trailing ---"
input ENUM_RR_MODE RR_Mode = RR_3R;
input ENUM_TRAIL_MODE TrailMode = TRAIL_DYNAMIC;
input double TrailStartR = 1.0;
input double TrailStopR = 1.0; // For dynamic mode only

input group "--- Partials ---"
input bool UsePartials = true;
input double PartialClosePercent = 50.0;
input double PartialTriggerR = 1.0;

//---------------------- GLOBALS ----------------------//
int hATR_LTF, hEMA50_LTF, hEMA200_LTF;
datetime lastBar = 0;
datetime lastTradeTime = 0;
double dayStartEquity, weekStartEquity, peakEquity;
int tradesToday = 0;
int currentDay = -1;
int currentWeek = -1;

struct TrailRecord { ulong ticket; double riskPrice; bool partialTaken; };
TrailRecord trailData[];

//+------------------------------------------------------------------+
//| INIT |
//+------------------------------------------------------------------+
int OnInit()
{
   Trade.SetExpertMagicNumber(MagicNumber);
   Trade.SetDeviationInPoints(5);
   
   ENUM_SYMBOL_TRADE_EXECUTION execMode = (ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_EXEMODE);
   Trade.SetTypeFilling(execMode == SYMBOL_TRADE_EXECUTION_MARKET ? ORDER_FILLING_IOC : ORDER_FILLING_FOK);

   hATR_LTF = iATR(_Symbol, LTF, 14);
   hEMA50_LTF = iMA(_Symbol, LTF, 50, 0, MODE_EMA, PRICE_CLOSE);
   hEMA200_LTF = iMA(_Symbol, LTF, 200, 0, MODE_EMA, PRICE_CLOSE);

   if(hATR_LTF == INVALID_HANDLE || hEMA50_LTF == INVALID_HANDLE || hEMA200_LTF == INVALID_HANDLE)
      return INIT_FAILED;

   ResetCycle();
   peakEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   IndicatorRelease(hATR_LTF);
   IndicatorRelease(hEMA50_LTF);
   IndicatorRelease(hEMA200_LTF);
}

//+------------------------------------------------------------------+
//| CYCLE RESET |
//+------------------------------------------------------------------+
void ResetCycle()
{
   MqlDateTime t;
   TimeToStruct(TimeCurrent(), t);

   if(currentDay != t.day_of_year)
   {
      currentDay = t.day_of_year;
      tradesToday = 0;
      dayStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   }

   int week = (int)MathFloor(t.day_of_year / 7.0);
   if(currentWeek != week)
   {
      currentWeek = week;
      weekStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   }
}

//+------------------------------------------------------------------+
//| RISK LOCK (v8.5 architecture - daily + weekly + profit) |
//+------------------------------------------------------------------+
bool RiskLock()
{
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   if(equity > peakEquity) peakEquity = equity;

   double dayLossPct = (dayStartEquity - equity) / dayStartEquity * 100.0;
   double weekLossPct = (weekStartEquity - equity) / weekStartEquity * 100.0;
   double dayProfitPct = (equity - dayStartEquity) / dayStartEquity * 100.0;

   if(dayLossPct >= MaxDailyLossPct) return true;
   if(weekLossPct >= MaxWeeklyLossPct) return true;
   if(dayProfitPct >= DailyProfitTargetPct) return true;

   return false;
}

//+------------------------------------------------------------------+
//| NEW BAR |
//+------------------------------------------------------------------+
bool NewBar()
{
   datetime t = iTime(_Symbol, LTF, 0);
   if(t == lastBar) return false;
   lastBar = t;
   return true;
}

//+------------------------------------------------------------------+
//| SPREAD CHECK |
//+------------------------------------------------------------------+
bool SpreadOK()
{
   return SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) <= MaxSpreadPoints;
}

//+------------------------------------------------------------------+
//| SESSION FILTER (Kill Zones) |
//+------------------------------------------------------------------+
bool SessionOK()
{
   if(!UseKillZones) return true;
   
   MqlDateTime t;
   TimeToStruct(TimeGMT(), t);
   int h = t.hour;
   
   bool london = (h >= 7 && h <= 10);
   bool ny = (h >= 13 && h <= 16);
   
   if(TradeLondon && london) return true;
   if(TradeNewYork && ny) return true;
   
   return false;
}

//+------------------------------------------------------------------+
//| NEWS FILTER (stub - implement your feed) |
//+------------------------------------------------------------------+
bool NewsFilterOK()
{
   if(!UseNewsFilter) return true;
   // Return false within 15 min before/after high-impact event
   return true;
}

//+------------------------------------------------------------------+
//| OPEN POSITION CHECK |
//+------------------------------------------------------------------+
bool HasOpenPosition()
{
   for(int i = 0; i < PositionsTotal(); i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionGetInteger(POSITION_MAGIC) == MagicNumber &&
         PositionGetString(POSITION_SYMBOL) == _Symbol)
         return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| INDICATOR HELPERS |
//+------------------------------------------------------------------+
double ATR(int shift = 1)
{
   double buf[1];
   if(CopyBuffer(hATR_LTF, 0, shift, 1, buf) < 1) return 0;
   return buf[0];
}

double EMA50_LTF(int shift = 1)
{
   double buf[1];
   if(CopyBuffer(hEMA50_LTF, 0, shift, 1, buf) < 1) return 0;
   return buf[0];
}

double EMA200_LTF(int shift = 1)
{
   double buf[1];
   if(CopyBuffer(hEMA200_LTF, 0, shift, 1, buf) < 1) return 0;
   return buf[0];
}

//+------------------------------------------------------------------+
//| HTF BIAS (FIXED: separate HTF handles, not LTF) |
//+------------------------------------------------------------------+
int HTFBias()
{
   int hFast = iMA(_Symbol, HTF, 50, 0, MODE_EMA, PRICE_CLOSE);
   int hSlow = iMA(_Symbol, HTF, 200, 0, MODE_EMA, PRICE_CLOSE);
   
   if(hFast == INVALID_HANDLE || hSlow == INVALID_HANDLE) return 0;
   
   double fast[1], slow[1];
   bool ok = CopyBuffer(hFast, 0, 1, 1, fast) > 0 && CopyBuffer(hSlow, 0, 1, 1, slow) > 0;
   
   IndicatorRelease(hFast);
   IndicatorRelease(hSlow);
   
   if(!ok) return 0;
   
   if(fast[0] > slow[0]) return 1;
   if(fast[0] < slow[0]) return -1;
   return 0;
}

//+------------------------------------------------------------------+
//| SWING HIGH / LOW |
//+------------------------------------------------------------------+
double SwingHigh(int lookback)
{
   double h = iHigh(_Symbol, LTF, 1);
   for(int i = 2; i <= lookback; i++)
      if(iHigh(_Symbol, LTF, i) > h) h = iHigh(_Symbol, LTF, i);
   return h;
}

double SwingLow(int lookback)
{
   double l = iLow(_Symbol, LTF, 1);
   for(int i = 2; i <= lookback; i++)
      if(iLow(_Symbol, LTF, i) < l) l = iLow(_Symbol, LTF, i);
   return l;
}

//+------------------------------------------------------------------+
//| BREAK OF STRUCTURE |
//+------------------------------------------------------------------+
bool BullishBOS()
{
   return iClose(_Symbol, LTF, 1) > SwingHigh(SwingLookback);
}

bool BearishBOS()
{
   return iClose(_Symbol, LTF, 1) < SwingLow(SwingLookback);
}

//+------------------------------------------------------------------+
//| CHANGE OF CHARACTER |
//+------------------------------------------------------------------+
bool BullishChoCh()
{
   return iLow(_Symbol, LTF, 2) < iLow(_Symbol, LTF, 4) &&
          iClose(_Symbol, LTF, 1) > iHigh(_Symbol, LTF, 3);
}

bool BearishChoCh()
{
   return iHigh(_Symbol, LTF, 2) > iHigh(_Symbol, LTF, 4) &&
          iClose(_Symbol, LTF, 1) < iLow(_Symbol, LTF, 3);
}

//+------------------------------------------------------------------+
//| LIQUIDITY SWEEP (from v8.6) |
//+------------------------------------------------------------------+
bool BuyLiquiditySweep()
{
   if(!UseLiquiditySweeps) return false;
   
   double eqLow1 = iLow(_Symbol, LTF, 2);
   double eqLow2 = iLow(_Symbol, LTF, 3);
   double tolerance = 10 * _Point;
   
   bool equalLows = MathAbs(eqLow1 - eqLow2) <= tolerance;
   bool sweep = iLow(_Symbol, LTF, 1) < eqLow1 && iClose(_Symbol, LTF, 1) > eqLow1;
   
   return equalLows && sweep;
}

bool SellLiquiditySweep()
{
   if(!UseLiquiditySweeps) return false;
   
   double eqHigh1 = iHigh(_Symbol, LTF, 2);
   double eqHigh2 = iHigh(_Symbol, LTF, 3);
   double tolerance = 10 * _Point;
   
   bool equalHighs = MathAbs(eqHigh1 - eqHigh2) <= tolerance;
   bool sweep = iHigh(_Symbol, LTF, 1) > eqHigh1 && iClose(_Symbol, LTF, 1) < eqHigh1;
   
   return equalHighs && sweep;
}

//+------------------------------------------------------------------+
//| DISPLACEMENT (from v8.6) |
//+------------------------------------------------------------------+
bool BullishDisplacement()
{
   if(!UseDisplacement) return false;
   double body = MathAbs(iClose(_Symbol, LTF, 1) - iOpen(_Symbol, LTF, 1));
   return body >= ATR() * DisplacementATR && iClose(_Symbol, LTF, 1) > iOpen(_Symbol, LTF, 1);
}

bool BearishDisplacement()
{
   if(!UseDisplacement) return false;
   double body = MathAbs(iClose(_Symbol, LTF, 1) - iOpen(_Symbol, LTF, 1));
   return body >= ATR() * DisplacementATR && iClose(_Symbol, LTF, 1) < iOpen(_Symbol, LTF, 1);
}

//+------------------------------------------------------------------+
//| FAIR VALUE GAP (v8.5 logic with close confirmation) |
//+------------------------------------------------------------------+
bool BullishFVG()
{
   if(!UseFVG) return false;
   
   double gap = iLow(_Symbol, LTF, 1) - iHigh(_Symbol, LTF, 3);
   double minGap = FVG_MinPips * _Point * 10;
   double fvgMid = (iLow(_Symbol, LTF, 1) + iHigh(_Symbol, LTF, 3)) / 2.0;
   
   return gap >= minGap && iClose(_Symbol, LTF, 1) > fvgMid;
}

bool BearishFVG()
{
   if(!UseFVG) return false;
   
   double gap = iLow(_Symbol, LTF, 3) - iHigh(_Symbol, LTF, 1);
   double minGap = FVG_MinPips * _Point * 10;
   double fvgMid = (iLow(_Symbol, LTF, 3) + iHigh(_Symbol, LTF, 1)) / 2.0;
   
   return gap >= minGap && iClose(_Symbol, LTF, 1) < fvgMid;
}

//+------------------------------------------------------------------+
//| ORDER BLOCK (v8.5 retest logic) |
//+------------------------------------------------------------------+
bool BullishOB()
{
   if(!UseOrderBlocks) return false;
   
   double price = iClose(_Symbol, LTF, 1);
   for(int i = 2; i <= OB_Lookback + 2; i++)
   {
      double obOpen = iOpen(_Symbol, LTF, i);
      double obClose = iClose(_Symbol, LTF, i);
      if(obClose < obOpen && price >= obClose && price <= obOpen)
         return true;
   }
   return false;
}

bool BearishOB()
{
   if(!UseOrderBlocks) return false;
   
   double price = iClose(_Symbol, LTF, 1);
   for(int i = 2; i <= OB_Lookback + 2; i++)
   {
      double obOpen = iOpen(_Symbol, LTF, i);
      double obClose = iClose(_Symbol, LTF, i);
      if(obClose > obOpen && price >= obOpen && price <= obClose)
         return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| CONFLUENCE SCORING (merged max 16) |
//+------------------------------------------------------------------+
int BuyScore()
{
   int score = 0;
   if(HTFBias() == 1) score += 3;
   if(BullishBOS()) score += 2;
   if(BullishChoCh()) score += 2;
   if(BuyLiquiditySweep()) score += 3;
   if(BullishDisplacement()) score += 2;
   if(BullishFVG()) score += 2;
   if(BullishOB()) score += 2;
   if(EMA50_LTF() > EMA200_LTF()) score += 2;
   if(iClose(_Symbol, LTF, 1) > EMA50_LTF()) score += 1;
   return score;
}

int SellScore()
{
   int score = 0;
   if(HTFBias() == -1) score += 3;
   if(BearishBOS()) score += 2;
   if(BearishChoCh()) score += 2;
   if(SellLiquiditySweep()) score += 3;
   if(BearishDisplacement()) score += 2;
   if(BearishFVG()) score += 2;
   if(BearishOB()) score += 2;
   if(EMA50_LTF() < EMA200_LTF()) score += 2;
   if(iClose(_Symbol, LTF, 1) < EMA50_LTF()) score += 1;
   return score;
}

//+------------------------------------------------------------------+
//| LOT SIZING (fixed lot mode + risk mode) |
//+------------------------------------------------------------------+
double CalcLots(double slPoints)
{
   if(UseFixedLotMode)
   {
      double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
      double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
      double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
      double lots = MathMin(MaxLotHardCap, maxLot);
      lots = MathMax(lots, minLot);
      lots = MathFloor(lots / lotStep) * lotStep;
      return lots;
   }
   
   // Risk-based calculation
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   double riskAmount = equity * RiskPercentPerTrade / 100.0;
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double pointValue = tickValue / tickSize;
   double lots = riskAmount / (slPoints * pointValue);

   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

   lots = MathFloor(lots / lotStep) * lotStep;
   lots = MathMin(lots, MathMin(MaxLotHardCap, maxLot));
   lots = MathMax(lots, MathMax(MinLotFloor, minLot));
   return lots;
}

//+------------------------------------------------------------------+
//| RR MULTIPLIER |
//+------------------------------------------------------------------+
double RRMultiplier()
{
   switch(RR_Mode)
   {
      case RR_2R: return 2.0;
      case RR_5R: return 5.0;
   }
   return 3.0;
}

//+------------------------------------------------------------------+
//| TRAIL RECORD HELPERS |
//+------------------------------------------------------------------+
void AddTrailRecord(ulong ticket, double riskPrice)
{
   int n = ArraySize(trailData);
   ArrayResize(trailData, n + 1);
   trailData[n].ticket = ticket;
   trailData[n].riskPrice = riskPrice;
   trailData[n].partialTaken = false;
}

double GetTrailRisk(ulong ticket)
{
   for(int i = 0; i < ArraySize(trailData); i++)
      if(trailData[i].ticket == ticket) return trailData[i].riskPrice;
   return 0;
}

bool GetPartialTaken(ulong ticket)
{
   for(int i = 0; i < ArraySize(trailData); i++)
      if(trailData[i].ticket == ticket) return trailData[i].partialTaken;
   return false;
}

void SetPartialTaken(ulong ticket)
{
   for(int i = 0; i < ArraySize(trailData); i++)
      if(trailData[i].ticket == ticket) { trailData[i].partialTaken = true; return; }
}

void RemoveTrailRecord(ulong ticket)
{
   int n = ArraySize(trailData);
   for(int i = 0; i < n; i++)
   {
      if(trailData[i].ticket == ticket)
      {
         for(int j = i; j < n - 1; j++) trailData[j] = trailData[j + 1];
         ArrayResize(trailData, n - 1);
         return;
      }
   }
}

//+------------------------------------------------------------------+
//| EXECUTE BUY |
//+------------------------------------------------------------------+
void Buy()
{
   double atr = ATR();
   double price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double sl = price - atr * 1.0; // 1x ATR for SL base
   double risk = price - sl;
   double tp = price + (risk * RRMultiplier());
   double lots = CalcLots(risk / _Point);

   if(Trade.Buy(lots, _Symbol, price, sl, tp, "BORGMAN_BUY_v87"))
   {
      lastTradeTime = TimeCurrent();
      tradesToday++;
      AddTrailRecord(Trade.ResultOrder(), risk);
   }
}

//+------------------------------------------------------------------+
//| EXECUTE SELL |
//+------------------------------------------------------------------+
void Sell()
{
   double atr = ATR();
   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double sl = price + atr * 1.0;
   double risk = sl - price;
   double tp = price - (risk * RRMultiplier());
   double lots = CalcLots(risk / _Point);

   if(Trade.Sell(lots, _Symbol, price, sl, tp, "BORGMAN_SELL_v87"))
   {
      lastTradeTime = TimeCurrent();
      tradesToday++;
      AddTrailRecord(Trade.ResultOrder(), risk);
   }
}

//+------------------------------------------------------------------+
//| TRAILING STOP MANAGER (3 modes) |
//+------------------------------------------------------------------+
void ManageTrailingStop()
{
   if(TrailMode == TRAIL_NONE) return;

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

Bewerbungen

1
Entwickler 1
Bewertung
(15)
Projekte
19
16%
Schlichtung
5
40% / 40%
Frist nicht eingehalten
0
Frei
2
Entwickler 2
Bewertung
(19)
Projekte
24
8%
Schlichtung
9
33% / 33%
Frist nicht eingehalten
1
4%
Beschäftigt
3
Entwickler 3
Bewertung
(106)
Projekte
173
25%
Schlichtung
23
9% / 78%
Frist nicht eingehalten
16
9%
Arbeitet
4
Entwickler 4
Bewertung
(73)
Projekte
83
28%
Schlichtung
8
13% / 63%
Frist nicht eingehalten
4
5%
Arbeitet
5
Entwickler 5
Bewertung
(2)
Projekte
3
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
6
Entwickler 6
Bewertung
(1)
Projekte
3
33%
Schlichtung
0
Frist nicht eingehalten
0
Frei
7
Entwickler 7
Bewertung
(572)
Projekte
664
32%
Schlichtung
42
45% / 45%
Frist nicht eingehalten
12
2%
Arbeitet
8
Entwickler 8
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
9
Entwickler 9
Bewertung
(10)
Projekte
11
0%
Schlichtung
3
0% / 33%
Frist nicht eingehalten
1
9%
Arbeitet
10
Entwickler 10
Bewertung
(452)
Projekte
565
26%
Schlichtung
24
42% / 38%
Frist nicht eingehalten
85
15%
Arbeitet
Veröffentlicht: 6 Beispiele
11
Entwickler 11
Bewertung
(542)
Projekte
822
62%
Schlichtung
33
27% / 45%
Frist nicht eingehalten
23
3%
Frei
Veröffentlicht: 1 Beispiel
12
Entwickler 12
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Ähnliche Aufträge
Semi Automated Gold Trading Signal System for MT5 300 - 800 USD
I need an experienced MQL5 developer to build a semi automated trading signal system for Gold (XAUUSD) on MT5. The system is NOT a martingale or grid EA. The goal is to build a clean rule based signal engine that detects high probability setups based on predefined strategy rules and sends trading alerts with optional pending order logic. Main Requirements: 1. Signal Generation - Buy and Sell signals - Buy Limit - Buy
Mambo 30+ USD
I need a bot that can trade weltrade synthetic indices that can be consistently making profits if you have one for deriv its also fine a bot that executes and closes trades automat Will be ideal
Advanced MT5 EA: Asian Liquidity Sweep & M5 FVG Entry with Economic News Filter 30 - 250 USD
MT5 Expert Advisor Specification: Asian Liquidity Sweep & M5 FVG Entry ​Project Overview ​Automated Expert Advisor for EUR/USD on MT5. The strategy maps structural liquidity (Fractal Swings) for entry triggers but targets absolute session extremes for Take Profit. It enters on the first opposite M5 Fair Value Gap (FVG) and features a dynamic, user-controlled risk engine. ​1. Timezone & News Filter Requirements ​The
Need Custom MT4 Indicator through cracking file (Non-Repaint, Same Signal Logic as Existing Tool, Legit PC ID system ) 150 - 350 USD
I am looking for an experienced MQL4/MQL5 developer to build a custom MT4 indicator from scratch or cracking my ex4 file that i provide to you. I already have an existing indicator (EX4) which produces highly accurate buy/sell signals. I want a similar indicator developed based on its observable behavior and signal structure. my existing indicator is pc id protected so you have to do PC ID security bypass and source
Professional EA for GBPUSD and EURUSD — Price Action + AI Filter — MT5 200 - 500 USD
I am looking for an experienced MQL5 developer to build a professional Expert Advisor with the following specs: TECHNICAL REQUIREMENTS: - Platform: MetaTrader 5 (MT5) - Pairs: GBPUSD and EURUSD - Broker suffix support (e.g. GBPUSD@, EURUSD@) - Primary timeframe: M5 -Higher timeframe bias: H1 and H4 (for trend direction only) - One chart setup — manages both pairs from one chart STRATEGY: - Price action based: BOS
Advanced XAUUSD Trend Scalping EA for MT5 — Professional Risk Management & Smart Filters 100 - 200 USD
OBJETIVO Criar um Expert Advisor MT5 profissional para XAUUSD focado em: Consistência Baixo drawdown Scalping profissional Proteção da conta Crescimento sustentável Compatibilidade com conta micro e prop firms NÃO utilizar: Martingale Grid Hedge agressivo Recovery system Multiplicação de lotes após perda --- ATIVO XAUUSD apenas --- TIMEFRAMES Timeframe principal M5 Confirmação tendência M15 Confirmação macro opcional
Advanced ICT + CRT Smart Money Expert Advisor for MT5 300 - 1000 USD
I need a very advanced and intelligent MT5 Expert Advisor coded in MQL5 for XAUUSD, based on ICT + CRT + Smart Money Concepts. The goal is not a simple robot, but a professional decision-making system with strong filters, risk control, and high-quality trade selection. The EA must include: 1. Multi-Timeframe Analysis - D1 / H4 / H1 bias - M15 / M5 entry confirmation - Bullish or bearish market structure - BOS, CHoCH
An EA based on my INTRADAY TRADE NINJA system 30 - 35 USD
Intraday Trade Ninja EA — Complete Logic Structure This document maps the full architecture, execution logic, signal flow, trade management, and safety structure of the Intraday Trade Ninja MT4 Expert Advisor. 1. Core Indicators · ©Price Border (TMA bands) · MA-X Arrows · MA-Y Arrows · LeManSignal · EMA 49 & 89 - Per Candle Color Switching 2. EA Entry Architecture ·
MT5 EA Debugging / Execution Optimization 50+ USD
I have a 90% completed project with the execution part left to complete, I have been struggling to complete this section and I need help from someone expert in MQL5 with knowledge on forex trading and ICT Concepts coding. Contact me for further details
XAUUSD trading scalping indicator trading view high succes rate 100+ USD
Hi, I am looking for someone to create me a trading indicator that will scalp the market 30-90 pips successfully in high volumes, I would like to be able to bridge this to create a signal channel for my community so it would need to have buy and sell indication on the indicator we run quite small stop losses so execution of trades can’t go in to draw down much alternatively create me a MT5 EA bot that scalps the

Projektdetails

Budget
30 - 70 USD

Kunde

Veröffentlichte Aufträge1
Anzahl der Schlichtungen0