FreelanceBölümler

EA SMC/ICT

MQL5 Uzmanlar

İş Gereklilikleri

//+------------------------------------------------------------------+
//|                                          SMC_ICT_Advanced_EA.mq5 |
//|                                    Smart Money Concepts Trading |
//|                          Combines Order Blocks, FVG, BOS, CHoCH |
//+------------------------------------------------------------------+
#property copyright "SMC/ICT Trading System"
#property version   "2.00"
#property strict

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

//+------------------------------------------------------------------+
//| Input Parameters                                                |
//+------------------------------------------------------------------+
// Strategy Selection
input group "=== Strategy Configuration ==="
input ENUM_TIMEFRAMES ContextTimeframe = PERIOD_M15;     // Context timeframe (M15/H1)
input ENUM_TIMEFRAMES EntryTimeframe = PERIOD_M5;        // Entry timeframe (M5)
input bool UseOrderBlocks = true;                         // Use Order Blocks
input bool UseFVG = true;                                 // Use Fair Value Gaps
input bool UseBOS = true;                                 // Use Break of Structure
input bool UseCHoCH = true;                               // Use Change of Character
input bool UseLiquiditySweep = true;                      // Use Liquidity Sweep

// Risk Management
input group "=== Risk Management ==="
input double RiskPercent = 1.0;                           // Risk % per trade
input double RiskRewardRatio = 2.0;                       // Risk:Reward ratio
input bool UseAutoLot = true;                             // Auto lot sizing
input double FixedLot = 0.01;                              // Fixed lot (if auto off)
input int MaxPositions = 1;                                // Max positions at once
input int MaxTradesPerDay = 2;                             // Max trades per day

// SMC Detection Parameters
input group "=== SMC Detection Settings ==="
input int SwingLookback = 20;                              // Swing high/low lookback
input int BOSLookback = 15;                                // BOS confirmation bars
input int OBSearchRange = 10;                              // Order Block search range
input int FVGMinSize = 5;                                   // Min FVG size in points
input double FibRetraceLevel = 61.8;                        // Fibonacci retrace level
input int SL_Buffer = 30;                                   // SL buffer in points

// Session Filters
input group "=== Session Filters ==="
input bool UseSessionFilter = true;                         // Filter by session
input bool TradeLondon = true;                               // London session (08:00-10:30 GMT)
input bool TradeNY = true;                                   // NY session (13:00-16:00 GMT)
input int GMTOffset = 0;                                     // Broker GMT offset

// Advanced Filters
input group "=== Advanced Filters ==="
input bool UseATRFilter = true;                              // Use ATR volatility filter
input int ATRPeriod = 14;                                    // ATR period
input double ATRMultiplier = 1.5;                            // ATR multiplier for SL
input bool UseVolumeFilter = true;                            // Require volume confirmation
input double VolumeMultiplier = 1.25;                         // Volume spike threshold

// Trade Management
input group "=== Trade Management ==="
input bool UseBreakEven = true;                              // Move to breakeven
input int BreakEvenPips = 20;                                 // Pips to breakeven
input bool UseTrailingStop = true;                            // Use trailing stop
input int TrailingStart = 30;                                 // Start trailing at pips
input int TrailingDistance = 15;                              // Trailing stop distance

// Visual
input group "=== Visual Settings ==="
input bool ShowDashboard = true;                              // Show info dashboard
input color DashboardColor = clrWhite;                        // Dashboard text color

//+------------------------------------------------------------------+
//| Global Variables                                                |
//+------------------------------------------------------------------+
datetime lastBarTime = 0;
int tradesToday = 0;
string lastTradeDay = "";
double confidenceScore = 0;
double atrValue = 0;

// Structure for Order Block
struct OrderBlock
{
   datetime time;
   double price;
   double high;
   double low;
   bool isBullish;
   int age;
};

// Structure for Fair Value Gap
struct FVG
{
   datetime time;
   double top;
   double bottom;
   double mid;
   bool isBullish;
};

// Structure for Market Structure
struct MarketStructure
{
   double swingHigh;
   double swingLow;
   bool uptrend;
   bool downtrend;
   datetime lastBOS;
   bool bosUp;
   bool bosDown;
};

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(123456);
   lastBarTime = iTime(_Symbol, EntryTimeframe, 0);
   lastTradeDay = TimeToString(TimeCurrent(), TIME_DATE);
   tradesToday = 0;
   
   if(ShowDashboard) CreateDashboard();
   
   Print("SMC/ICT EA initialized successfully");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(ShowDashboard) ObjectsDeleteAll(0, "SMC_");
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // Update dashboard
   if(ShowDashboard) UpdateDashboard();
   
   // Reset daily counter if new day
   string today = TimeToString(TimeCurrent(), TIME_DATE);
   if(today != lastTradeDay)
   {
      lastTradeDay = today;
      tradesToday = 0;
   }
   
   // Check if we have a new bar on entry timeframe
   datetime currentBarTime = iTime(_Symbol, EntryTimeframe, 0);
   if(currentBarTime == lastBarTime) return;
   lastBarTime = currentBarTime;
   
   // Don't trade if max positions reached
   if(PositionsTotal() >= MaxPositions) return;
   
   // Don't trade if max daily trades reached
   if(tradesToday >= MaxTradesPerDay) return;
   
   // Check session filter
   if(UseSessionFilter && !IsValidSession()) return;
   
   // Get ATR for volatility filter
   if(UseATRFilter)
   {
      atrValue = iATR(_Symbol, EntryTimeframe, ATRPeriod, 1);
      if(atrValue == 0) return;
   }
   
   // Main trading logic
   CheckTradingOpportunities();
}

//+------------------------------------------------------------------+
//| Check for trading opportunities                                  |
//+------------------------------------------------------------------+
void CheckTradingOpportunities()
{
   // Reset confidence score
   confidenceScore = 0;
   
   // Step 1: Analyze context timeframe (M15/H1)
   MarketStructure contextStruct = AnalyzeMarketStructure(ContextTimeframe);
   
   // Step 2: Analyze entry timeframe (M5)
   MarketStructure entryStruct = AnalyzeMarketStructure(EntryTimeframe);
   
   // Step 3: Detect Order Blocks
   OrderBlock detectedOB = DetectOrderBlock(entryStruct);
   
   // Step 4: Detect Fair Value Gaps
   FVG detectedFVG = DetectFVG(entryStruct);
   
   // Step 5: Detect Liquidity Sweep
   bool liquiditySweep = DetectLiquiditySweep(entryStruct);
   
   // Step 6: Calculate confidence score
   confidenceScore = CalculateConfidenceScore(contextStruct, entryStruct, 
                                              detectedOB, detectedFVG, liquiditySweep);
   
   // Step 7: Execute trade if conditions met
   if(confidenceScore >= 80) // Minimum confidence threshold
   {
      if(entryStruct.uptrend && contextStruct.uptrend)
         ExecuteTrade(ORDER_TYPE_BUY, detectedOB, detectedFVG);
      else if(entryStruct.downtrend && contextStruct.downtrend)
         ExecuteTrade(ORDER_TYPE_SELL, detectedOB, detectedFVG);
   }
}

//+------------------------------------------------------------------+
//| Analyze market structure                                         |
//+------------------------------------------------------------------+
MarketStructure AnalyzeMarketStructure(ENUM_TIMEFRAMES tf)
{
   MarketStructure ms;
   ms.uptrend = false;
   ms.downtrend = false;
   ms.bosUp = false;
   ms.bosDown = false;
   
   // Find swing highs and lows
   int highBar = iHighest(_Symbol, tf, MODE_HIGH, SwingLookback, 1);
   int lowBar = iLowest(_Symbol, tf, MODE_LOW, SwingLookback, 1);
   
   ms.swingHigh = iHigh(_Symbol, tf, highBar);
   ms.swingLow = iLow(_Symbol, tf, lowBar);
   
   // Check for Break of Structure (BOS)
   double currentClose = iClose(_Symbol, tf, 1);
   double previousHigh = iHigh(_Symbol, tf, 2);
   double previousLow = iLow(_Symbol, tf, 2);
   
   // Bullish BOS: price breaks above previous high
   if(currentClose > previousHigh)
   {
      ms.bosUp = true;
      ms.uptrend = true;
      ms.lastBOS = iTime(_Symbol, tf, 1);
   }
   
   // Bearish BOS: price breaks below previous low
   if(currentClose < previousLow)
   {
      ms.bosDown = true;
      ms.downtrend = true;
      ms.lastBOS = iTime(_Symbol, tf, 1);
   }
   
   // Check for Change of Character (CHoCH)
   if(UseCHoCH)
   {
      // Bullish CHoCH: higher high after lower low
      if(currentClose > previousHigh && ms.swingLow < iLow(_Symbol, tf, lowBar+1))
         ms.uptrend = true;
      
      // Bearish CHoCH: lower low after higher high
      if(currentClose < previousLow && ms.swingHigh > iHigh(_Symbol, tf, highBar+1))
         ms.downtrend = true;
   }
   
   return ms;
}

//+------------------------------------------------------------------+
//| Detect Order Block                                               |
//+------------------------------------------------------------------+
OrderBlock DetectOrderBlock(MarketStructure &ms)
{
   OrderBlock ob;
   ob.time = 0;
   ob.price = 0;
   ob.isBullish = false;
   
   for(int i = 1; i <= OBSearchRange; i++)
   {
      double bodySize = MathAbs(iClose(_Symbol, EntryTimeframe, i) - 
                                 iOpen(_Symbol, EntryTimeframe, i));
      double rangeSize = iHigh(_Symbol, EntryTimeframe, i) - 
                         iLow(_Symbol, EntryTimeframe, i);
      
      // Bullish Order Block (in downtrend, large down candle)
      if(ms.downtrend && iClose(_Symbol, EntryTimeframe, i) < iOpen(_Symbol, EntryTimeframe, i))
      {
         if(bodySize / rangeSize > 0.6) // Large body candle
         {
            ob.time = iTime(_Symbol, EntryTimeframe, i);
            ob.high = iHigh(_Symbol, EntryTimeframe, i);
            ob.low = iLow(_Symbol, EntryTimeframe, i);
            ob.price = ob.high; // Entry at OB high for bullish
            ob.isBullish = true;
            ob.age = i;
            break;
         }
      }
      
      // Bearish Order Block (in uptrend, large up candle)
      if(ms.uptrend && iClose(_Symbol, EntryTimeframe, i) > iOpen(_Symbol, EntryTimeframe, i))
      {
         if(bodySize / rangeSize > 0.6) // Large body candle
         {
            ob.time = iTime(_Symbol, EntryTimeframe, i);
            ob.high = iHigh(_Symbol, EntryTimeframe, i);
            ob.low = iLow(_Symbol, EntryTimeframe, i);
            ob.price = ob.low; // Entry at OB low for bearish
            ob.isBullish = false;
            ob.age = i;
            break;
         }
      }
   }
   
   return ob;
}

//+------------------------------------------------------------------+
//| Detect Fair Value Gap                                            |
//+------------------------------------------------------------------+
FVG DetectFVG(MarketStructure &ms)
{
   FVG fvg;
   fvg.time = 0;
   fvg.top = 0;
   fvg.bottom = 0;
   
   for(int i = 1; i <= OBSearchRange-2; i++)
   {
      double candle1_high = iHigh(_Symbol, EntryTimeframe, i+2);
      double candle1_low = iLow(_Symbol, EntryTimeframe, i+2);
      double candle2_high = iHigh(_Symbol, EntryTimeframe, i+1);
      double candle2_low = iLow(_Symbol, EntryTimeframe, i+1);
      double candle3_high = iHigh(_Symbol, EntryTimeframe, i);
      double candle3_low = iLow(_Symbol, EntryTimeframe, i);
      
      // Bullish FVG: gap between candle1 low and candle3 high
      if(candle1_low > candle3_high)
      {
         double gapSize = candle1_low - candle3_high;
         if(gapSize >= FVGMinSize * _Point)
         {
            fvg.time = iTime(_Symbol, EntryTimeframe, i+1);
            fvg.top = candle1_low;
            fvg.bottom = candle3_high;
            fvg.mid = (fvg.top + fvg.bottom) / 2;
            fvg.isBullish = true;
            break;
         }
      }
      
      // Bearish FVG: gap between candle1 high and candle3 low
      if(candle1_high < candle3_low)
      {
         double gapSize = candle3_low - candle1_high;
         if(gapSize >= FVGMinSize * _Point)
         {
            fvg.time = iTime(_Symbol, EntryTimeframe, i+1);
            fvg.top = candle3_low;
            fvg.bottom = candle1_high;
            fvg.mid = (fvg.top + fvg.bottom) / 2;
            fvg.isBullish = false;
            break;
         }
      }
   }
   
   return fvg;
}

//+------------------------------------------------------------------+
//| Detect Liquidity Sweep                                           |
//+------------------------------------------------------------------+
bool DetectLiquiditySweep(MarketStructure &ms)
{
   if(!UseLiquiditySweep) return true;
   
   double currentLow = iLow(_Symbol, EntryTimeframe, 1);
   double currentHigh = iHigh(_Symbol, EntryTimeframe, 1);
   double currentClose = iClose(_Symbol, EntryTimeframe, 1);
   
   // Bullish liquidity sweep: price sweeps below recent low, closes back above
   if(currentLow < ms.swingLow && currentClose > ms.swingLow)
   {
      // Check volume spike for confirmation
      if(UseVolumeFilter)
      {
         double currentVolume = iVolume(_Symbol, EntryTimeframe, 1);
         double previousVolume = iVolume(_Symbol, EntryTimeframe, 2);
         if(currentVolume < previousVolume * VolumeMultiplier)
            return false;
      }
      return true;
   }
   
   // Bearish liquidity sweep: price sweeps above recent high, closes back below
   if(currentHigh > ms.swingHigh && currentClose < ms.swingHigh)
   {
      // Check volume spike for confirmation
      if(UseVolumeFilter)
      {
         double currentVolume = iVolume(_Symbol, EntryTimeframe, 1);
         double previousVolume = iVolume(_Symbol, EntryTimeframe, 2);
         if(currentVolume < previousVolume * VolumeMultiplier)
            return false;
      }
      return true;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| Calculate confidence score (0-100)                              |
//+------------------------------------------------------------------+
double CalculateConfidenceScore(MarketStructure &context, MarketStructure &entry,
                                 OrderBlock &ob, FVG &fvg, bool sweep)
{
   double score = 0;
   
   // BOS strength (20 points)
   if(context.bosUp || context.bosDown) score += 10;
   if(entry.bosUp || entry.bosDown) score += 10;
   
   // Liquidity sweep (15 points)
   if(sweep) score += 15;
   
   // FVG presence (15 points)
   if(fvg.time > 0 && UseFVG) score += 15;
   
   // Order Block quality (20 points)
   if(ob.time > 0 && UseOrderBlocks)
   {
      if(ob.age <= 5) score += 20;  // Fresh OB
      else if(ob.age <= 10) score += 10;
   }
   
   // Multi-timeframe confluence (10 points)
   if((context.uptrend && entry.uptrend) || (context.downtrend && entry.downtrend))
      score += 10;
   
   // Session quality (10 points)
   if(IsPrimeSession()) score += 10;
   
   // Volatility filter (5 points)
   if(UseATRFilter)
   {
      double currentATR = iATR(_Symbol, EntryTimeframe, ATRPeriod, 1);
      double avgATR = iATR(_Symbol, EntryTimeframe, ATRPeriod, 10);
      if(currentATR > avgATR * 0.8) score += 5;  // Healthy volatility
   }
   
   return MathMin(score, 100);
}

//+------------------------------------------------------------------+
//| Execute trade                                                   |
//+------------------------------------------------------------------+
void ExecuteTrade(ENUM_ORDER_TYPE type, OrderBlock &ob, FVG &fvg)
{
   double price = (type == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) :
                                             SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   double entryPrice = price;
   double sl = 0, tp = 0;
   
   // Determine entry price based on available SMC levels
   if(fvg.time > 0 && UseFVG)
   {
      entryPrice = fvg.mid; // Use FVG mid-line for entry
   }
   else if(ob.time > 0 && UseOrderBlocks)
   {
      entryPrice = ob.price; // Use Order Block level for entry
   }
   
   // Calculate Stop Loss
   if(type == ORDER_TYPE_BUY)
   {
      if(ob.time > 0)
         sl = ob.low - SL_Buffer * _Point;
      else if(fvg.time > 0)
         sl = fvg.bottom - SL_Buffer * _Point;
      else
         sl = price - atrValue * ATRMultiplier;
   }
   else // SELL
   {
      if(ob.time > 0)
         sl = ob.high + SL_Buffer * _Point;
      else if(fvg.time > 0)
         sl = fvg.top + SL_Buffer * _Point;
      else
         sl = price + atrValue * ATRMultiplier;
   }
   
   // Calculate Take Profit
   double riskDistance = MathAbs(price - sl);
   tp = (type == ORDER_TYPE_BUY) ? price + riskDistance * RiskRewardRatio :
                                    price - riskDistance * RiskRewardRatio;
   
   // Calculate lot size
   double lotSize = CalculateLotSize(riskDistance);
   if(lotSize <= 0) return;
   
   // Normalize prices
   sl = NormalizeDouble(sl, _Digits);
   tp = NormalizeDouble(tp, _Digits);
   
   // Send order
   trade.PositionOpen(_Symbol, type, lotSize, entryPrice, sl, tp, 
                      "SMC/ICT Entry (Conf: " + DoubleToString(confidenceScore, 0) + ")");
   
   // Check result
   if(trade.ResultRetcode() == TRADE_RETCODE_DONE)
   {
      tradesToday++;
      Print("Trade executed successfully. Confidence: ", confidenceScore);
   }
   else
   {
      Print("Trade failed. Error: ", trade.ResultRetcode());
   }
}

//+------------------------------------------------------------------+
//| Calculate lot size based on risk                                |
//+------------------------------------------------------------------+
double CalculateLotSize(double riskDistance)
{
   if(UseAutoLot)
   {
      double accountRisk = AccountInfoDouble(ACCOUNT_BALANCE) * RiskPercent / 100;
      double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
      double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
      
      double rawLot = accountRisk / (riskDistance / _Point * tickValue);
      double lotSize = MathFloor(rawLot / lotStep) * lotStep;
      
      double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
      double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
      
      return MathMax(minLot, MathMin(lotSize, maxLot));
   }
   else
   {
      return FixedLot;
   }
}

//+------------------------------------------------------------------+
//| Check if current time is within valid session                   |
//+------------------------------------------------------------------+
bool IsValidSession()
{
   if(!UseSessionFilter) return true;
   
   datetime currentTime = TimeCurrent();
   MqlDateTime dt;
   TimeToStruct(currentTime, dt);
   
   int hour = dt.hour + GMTOffset;
   if(hour >= 24) hour -= 24;
   
   // London session: 08:00-10:30 GMT
   bool london = TradeLondon && (hour >= 8 && (hour < 10 || (hour == 10 && dt.min <= 30)));
   
   // NY session: 13:00-16:00 GMT
   bool ny = TradeNY && (hour >= 13 && hour < 16);
   
   return london || ny;
}

//+------------------------------------------------------------------+
//| Check if current time is within prime session (higher confidence)|
//+------------------------------------------------------------------+
bool IsPrimeSession()
{
   datetime currentTime = TimeCurrent();
   MqlDateTime dt;
   TimeToStruct(currentTime, dt);
   
   int hour = dt.hour + GMTOffset;
   if(hour >= 24) hour -= 24;
   
   // Prime trading hours: London open + NY open overlap
   return (hour == 8) || (hour == 9) || (hour == 13) || (hour == 14);
}

//+------------------------------------------------------------------+
//| Create dashboard                                                 |
//+------------------------------------------------------------------+
void CreateDashboard()
{
   int x = 10, y = 30;
   
   ObjectCreate(0, "SMC_Title", OBJ_LABEL, 0, 0, 0);
   ObjectSetString(0, "SMC_Title", OBJPROP_TEXT, "SMC/ICT ADVANCED EA");
   ObjectSetInteger(0, "SMC_Title", OBJPROP_COLOR, clrGold);
   ObjectSetInteger(0, "SMC_Title", OBJPROP_FONTSIZE, 12);
   ObjectSetInteger(0, "SMC_Title", OBJPROP_CORNER, 0);
   ObjectSetInteger(0, "SMC_Title", OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, "SMC_Title", OBJPROP_YDISTANCE, y);
   
   // Create other dashboard labels
   string labels[] = {"SMC_Confidence", "SMC_Session", "SMC_Trades", "SMC_Status"};
   string defaultText[] = {"Confidence: --", "Session: --", "Trades: 0/--", "Status: Watching"};
   color colors[] = {clrAqua, clrLime, clrYellow, clrOrange};
   
   for(int i = 0; i < 4; i++)
   {
      ObjectCreate(0, labels[i], OBJ_LABEL, 0, 0, 0);
      ObjectSetString(0, labels[i], OBJPROP_TEXT, defaultText[i]);
      ObjectSetInteger(0, labels[i], OBJPROP_COLOR, colors[i]);
      ObjectSetInteger(0, labels[i], OBJPROP_FONTSIZE, 10);
      ObjectSetInteger(0, labels[i], OBJPROP_CORNER, 0);
      ObjectSetInteger(0, labels[i], OBJPROP_XDISTANCE, x);
      ObjectSetInteger(0, labels[i], OBJPROP_YDISTANCE, y + 20 + i * 20);
   }
}

//+------------------------------------------------------------------+
//| Update dashboard                                                 |
//+------------------------------------------------------------------+
void UpdateDashboard()
{
   if(!ShowDashboard) return;
   
   string session = IsValidSession() ? "ACTIVE" : "INACTIVE";
   string confidence = DoubleToString(confidenceScore, 0) + "/100";
   string trades = IntegerToString(tradesToday) + "/" + IntegerToString(MaxTradesPerDay);
   string status = (PositionsTotal() > 0) ? "IN POSITION" : "WATCHING";
   
   ObjectSetString(0, "SMC_Confidence", OBJPROP_TEXT, "Confidence: " + confidence);
   ObjectSetString(0, "SMC_Session", OBJPROP_TEXT, "Session: " + session);
   ObjectSetString(0, "SMC_Trades", OBJPROP_TEXT, "Trades: " + trades);
   ObjectSetString(0, "SMC_Status", OBJPROP_TEXT, "Status: " + status);
   
   // Color code session
   if(session == "ACTIVE")
      ObjectSetInteger(0, "SMC_Session", OBJPROP_COLOR, clrLime);
   else
      ObjectSetInteger(0, "SMC_Session", OBJPROP_COLOR, clrRed);
   
   ChartRedraw(0);
}

Yanıtlandı

1
Geliştirici 1
Derecelendirme
(13)
Projeler
20
40%
Arabuluculuk
3
0% / 67%
Süresi dolmuş
3
15%
Serbest
2
Geliştirici 2
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
3
Geliştirici 3
Derecelendirme
(4)
Projeler
3
33%
Arabuluculuk
2
0% / 100%
Süresi dolmuş
0
Serbest
4
Geliştirici 4
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
5
Geliştirici 5
Derecelendirme
(5)
Projeler
6
0%
Arabuluculuk
1
0% / 100%
Süresi dolmuş
1
17%
Çalışıyor
6
Geliştirici 6
Derecelendirme
(64)
Projeler
83
28%
Arabuluculuk
9
33% / 56%
Süresi dolmuş
9
11%
Serbest
Yayınlandı: 1 kod
7
Geliştirici 7
Derecelendirme
(3)
Projeler
4
50%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
8
Geliştirici 8
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
Benzer siparişler
Expert baseado na Hull Moving Average. 50 - 80 USD
Preciso de um especialista completo, totalmente profissional, que trabalhe com o indicador Hull Moving Average. Que faça entradas exatamente na mudança de cores com base no Exp_ColorHma, de Nikolay e também com a opção de entrada exatamente no cruzamento de duas Hull Average Moving(não na próxima vela), uma lenta e outra rápida. O programador deverá fazer um trabalhado de profissional. Dispenso curiosos ou
Tebza ngwenya 30 - 100 USD
Just know your deal,if you don't know what you are up to I gotchu. This is my first time trying also so yeah, but otherwise if you looking for something grand I'm here, if you got offered me well you in for some great time
Looking for Profitable Existing EA, not DD past 10% daily and profits at least 15% monthly 34 - 934 USD
Looking to acquire an existing, profitable Expert Advisor (EA) with full source code to add to our client investment portfolio. To be clear, this is not a request to develop or design a new strategy. If you already have an EA that is proven, consistent, and production-ready, with at least 6 months of history performance I’m open to reviewing it immediately. Please apply only if you meet all the requirements below
EA Script editor 30 - 35 USD
I need someone who will help me with a script that supports / cancels out negative positions. So that with a deposit of 600 euros, it doesn't close 300 euros. More info on pv
Pips Muncher 30 - 35 USD
I need a good programmer to creat an ea that will open a trade once the parametres i set are met on the chat that i place it on. The Ea will not need to do any analyses as i would do that manually. It only needs to execute a trade when all the conditions that i will be sending meets. The ea will add stop loss an Tp
Collaboratore MetaTrader 5 (Ottimizzazione algoritmi) 500 - 1500 USD
Società di investimento con attività tra Sanremo e Monaco ricerca un giovane collaboratore con esperienza nell’utilizzo avanzato di MetaTrader 5. Si richiede la conoscenza della lingua ITALIANA e INGLESE. Il collaboratore si occuperà di: • eseguire backtest di strategie di trading su MT5 • effettuare ottimizzazioni parametri tramite Strategy Tester • analizzare risultati e robustezza delle strategie • eseguire
EA Code Fixes + 4K Dashboard + Gold Settings 30 - 150 USD
ubject: Urgent Code Fixes + 4K Dashboard + Optimal Gold Settings Dear Developer, I need you to fix the following critical issues in the EA code, add a professional 4K dashboard, and implement the optimal gold settings below. These are essential requirements for the EA to work properly and profitably. 🔴 PART 1: CRITICAL ISSUES (MUST BE FIXED) 1. Trailing Stop Not Working ❌ The trailing stop does not move at all
A bot to help create my android app and buying and selling stocks. 30+ USD
Trade, buy and sell stocks for me. A bot to help create my android app and buying and A bot to help create my android app and buying and A bot to help create my android app and buying and A bot to help create my android app and buying and A bot to help create my android app and buying and A bot to help create my android app and buying and A bot to help create my android app and buying and A bot to help create my
Ca$h robot 32+ USD
A robot that can learn from errors read and decide and research companies at the time of using multiple resources in the web all.sites Yahoo Google forbes the actual.business or financial web domains able t sell buy trade currency stocks crypto on multiple platforms allowed in here and always generate profits even small amounts daily hourly on top of able t mine coins as many as possible mining for generating profits
Python based robot required based on non MT4 object 60 - 100 USD
Hi, I require a robot that can read this non MT4 object . Trade opened when the object shows ' Look to sell / Buy'. The closing logic is based on the crossing of another custom indicator . Stop loss based on Fib levels. Take profit and partial take profit also required using these levels. A more detailed breakdown of the logic to be provided. The robot/EA is to be created and installed on MT4 on my VPS

Proje bilgisi

Bütçe
30+ USD

Müşteri

Verilmiş siparişler1
Arabuluculuk sayısı0