FreelanceSecciones

EA SMC/ICT

MQL5 Asesores Expertos

Tarea técnica

//+------------------------------------------------------------------+
//|                                          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);
}

Han respondido

1
Desarrollador 1
Evaluación
(13)
Proyectos
20
40%
Arbitraje
3
0% / 67%
Caducado
3
15%
Libre
2
Desarrollador 2
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
3
Desarrollador 3
Evaluación
(4)
Proyectos
3
33%
Arbitraje
2
0% / 100%
Caducado
0
Libre
4
Desarrollador 4
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
5
Desarrollador 5
Evaluación
(5)
Proyectos
6
0%
Arbitraje
1
0% / 100%
Caducado
1
17%
Trabaja
6
Desarrollador 6
Evaluación
(64)
Proyectos
83
28%
Arbitraje
9
33% / 56%
Caducado
9
11%
Libre
Ha publicado: 1 ejemplo
7
Desarrollador 7
Evaluación
(3)
Proyectos
4
50%
Arbitraje
0
Caducado
0
Libre
8
Desarrollador 8
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
Solicitudes similares
Leonard Quantum FX 80 - 120 USD
I want the EA to be fully automated and capable of taking trades across multiple timeframes. It should be optimized for a starting account balance of $100 with proper risk management suitable for a small account, and it will be used with the broker ApexMarket.io. ⸻ Platform • Platform: MetaTrader 5 (MT5) • Type: Fully automated Expert Advisor • Operation: Hands-free (no manual trade management required) ⸻ 📈 Markets
Wealthy bot 50 - 200 USD
‎Build a mobile-based trading bot system integrated with MetaTrader 5 that specializes in high-frequency “machine gun” style trading on synthetic indices (crash 50 and Crash 300). ‎ ‎The bot must continuously scan the market in real-time using M1 and M5 timeframes and execute frequent trades based on probability, not prediction. Its core function is to detect early signs of potential reversals by analyzing combined
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

Información sobre el proyecto

Presupuesto
30+ USD

Cliente

Encargos realizados1
Número de arbitrajes0