FreelanceSections

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

MQL5 Experts Trading robot/indicator debugging C++

Spécifications

//+------------------------------------------------------------------+
//| 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

Répondu

1
Développeur 1
Évaluation
(15)
Projets
19
16%
Arbitrage
5
40% / 40%
En retard
0
Gratuit
2
Développeur 2
Évaluation
(19)
Projets
24
8%
Arbitrage
9
33% / 33%
En retard
1
4%
Chargé
3
Développeur 3
Évaluation
(106)
Projets
173
25%
Arbitrage
23
9% / 78%
En retard
16
9%
Travail
4
Développeur 4
Évaluation
(73)
Projets
83
28%
Arbitrage
8
13% / 63%
En retard
4
5%
Travail
5
Développeur 5
Évaluation
(2)
Projets
3
0%
Arbitrage
0
En retard
0
Gratuit
6
Développeur 6
Évaluation
(1)
Projets
3
33%
Arbitrage
0
En retard
0
Gratuit
7
Développeur 7
Évaluation
(572)
Projets
664
32%
Arbitrage
42
45% / 45%
En retard
12
2%
Travail
8
Développeur 8
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
9
Développeur 9
Évaluation
(10)
Projets
11
0%
Arbitrage
3
0% / 33%
En retard
1
9%
Travail
10
Développeur 10
Évaluation
(452)
Projets
565
26%
Arbitrage
24
42% / 38%
En retard
85
15%
Travail
Publié : 6 codes
11
Développeur 11
Évaluation
(542)
Projets
822
62%
Arbitrage
33
27% / 45%
En retard
23
3%
Gratuit
Publié : 1 code
12
Développeur 12
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
13
Développeur 13
Évaluation
(195)
Projets
251
20%
Arbitrage
22
50% / 18%
En retard
0
Occupé
14
Développeur 14
Évaluation
(271)
Projets
553
50%
Arbitrage
57
40% / 37%
En retard
227
41%
Travail
15
Développeur 15
Évaluation
(6)
Projets
7
86%
Arbitrage
0
En retard
0
Gratuit
16
Développeur 16
Évaluation
Projets
0
0%
Arbitrage
1
0% / 100%
En retard
0
Gratuit
17
Développeur 17
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
Commandes similaires
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
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 ·
Smart Trade Management System for MetaTrader 4/5 (Full Dashboard + Multi-Account + Toolbox) 1000 - 3000 USD
📌 Project Overview: I need a full Smart Trade Management System for MetaTrader 4/5. This is a complete trading ecosystem, not a simple EA. 📌 Core Features: Smart Money Management (risk-based lot calculation) Advanced Trading Toolbox (TradingView-style drawing tools) Central Master Dashboard (risk, filters, account control) Multi-account monitoring (MT4/MT5 synchronization) Real-time monitoring (spread, equity
BUILDING OF NINJATRADER INDICATOR 30+ USD
Hello, i would like to have a ninjatrader indicator. I wanna to have a footprint indicator with delta, imbalances and big trades identifiable. Also I wanna sell it on whop. And it should be fully customisable in NT8
Custom MT5 EA - Perpetual NDA Required 1000 - 2000 USD
I need a professional MQL5 developer. BEFORE I SHARE ANY DETAILS: 1. You must sign a PERPETUAL NDA with no expiration date 2. NDA includes €100,000 penalty for any breach 3. I require full .mq5 source code ownership 4. Developer must have 500+ completed jobs, 4.9+ rating Budget: €1500 EUR Duration: 14 days Start your application with "RULER" to prove you read this
MT5/MT4 AND TRADINGVIEW EXPERIENCE DEVELOPER 70+ USD
Hello Developers I have a Project to get done! i have a simple strategy can you please create the automated forex ea to execute my trading strategy? i need custom ea for tradingview and mt4/mt5 correction: i need a tradingview indicator created that tells me when to buy or sell. and ea in mt4/mt5
Expert advisor (EA) for trading Szukamy eksperta ds. programowania EA dla platformy MT5 30 - 70 USD
Mam kody EA Bot. Chciałbym je dokończyć, dopracować i ukończyć projekty. Chciałbym otrzymać pliki SET po ukończeniu EA. Jeśli jesteś zainteresowany, skontaktuj się ze mną. Szukam doświadczonego programisty do stworzenia dedykowanego doradcy eksperckiego (EA) do tradingu. Programista powinien posiadać solidną wiedzę z zakresu MT5, logiki strategii, wskaźników, zarządzania ryzykiem i backtestingu. Doświadczenie w
Need a indicator with Supertrend logic and S/R pullback 30 - 100 USD
I am looking for an experienced MQL5 developer to create a custom technical indicator for MetaTrader 5. The indicator should combine Supertrend logic with Support/Resistance pullback levels to generate high-probability entry signals. 1. Core Logic The indicator must follow a two-step confirmation process: Trend Identification: Use the Supertrend indicator to determine the primary trend. Entry Signal (The

Informations sur le projet

Budget
30 - 70 USD

Client

Commandes passées1
Nombre d'arbitrages0