FreelanceBölümler

GoldTrade EA

MQL5 Uzmanlar Forex Trading robot/indicator debugging Strategy optimization Statistics and mathematics

Şartname

//+------------------------------------------------------------------+
//| XAUUSD Wolfe + SMC Quick Profit EA |
//| MT5 / MQL5 |
//+------------------------------------------------------------------+
#property strict

#include <Trade/Trade.mqh>

CTrade trade;

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

//--- General
input string InpSymbol = ""; // Blank = chart symbol
input ulong MagicNumber = 26082301;
input double InitialLot = 0.01;
input double AddLot = 0.01;
input int MaxPositions = 3;
input double MaxTotalLots = 0.03;

//--- Commission / profit
input double CommissionPer001 = 0.45; // USD per 0.01 lot
input double MinimumNetProfit = 0.10; // Desired net profit
input double ProfitBuffer = 0.05; // Safety buffer

//--- Entry
input ENUM_TIMEFRAMES BiasTF = PERIOD_M5;
input ENUM_TIMEFRAMES EntryTF = PERIOD_M1;

input int FastEMA = 20;
input int SlowEMA = 50;

input int SwingLookback = 80;
input int SwingStrength = 2;

input double WolfeTolerancePoints = 150;
input double EntryZonePoints = 250;

//--- Risk
input double StopLossPoints = 1200;
input double MaxBasketLossUSD = 25.0;
input double MaxDailyLossUSD = 50.0;

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

//--- Scaling
input double AddAfterProfitUSD = 0.30;
input int MinimumSecondsBetweenAdds = 60;

//--- Trading hours
input bool UseTradingHours = true;
input int StartHour = 7;
input int EndHour = 22;

//--- Execution
input int DeviationPoints = 30;

//==================================================================
// GLOBALS
//==================================================================

string TradeSymbol;

datetime LastBarM1 = 0;
datetime LastAddTime = 0;
datetime DayStart = 0;

double DailyStartEquity = 0;

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

int OnInit()
{
   TradeSymbol = InpSymbol;

   if(TradeSymbol == "")
      TradeSymbol = _Symbol;

   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(DeviationPoints);

   DailyStartEquity = AccountInfoDouble(ACCOUNT_EQUITY);

   MqlDateTime dt;
   TimeToStruct(TimeCurrent(),dt);
   dt.hour = 0;
   dt.min = 0;
   dt.sec = 0;

   DayStart = StructToTime(dt);

   Print("EA initialized on ", TradeSymbol);

   return(INIT_SUCCEEDED);
}

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

void OnTick()
{
   if(_Symbol != TradeSymbol)
      return;

   UpdateDailyReference();

   // Manage existing basket first
   ManageBasket();

   // Protect account
   if(DailyLossExceeded())
      return;

   if(!TradingTime())
      return;

   if(!SpreadOK())
      return;

   // Only make a new decision on a new M1 candle
   datetime currentBar = iTime(TradeSymbol,EntryTF,0);

   if(currentBar == LastBarM1)
      return;

   LastBarM1 = currentBar;

   // Existing basket?
   int positions = CountPositions();

   if(positions > 0)
   {
      ManageScaling();
      return;
   }

   // No open basket: search for new trade
   int signal = GetTradeSignal();

   if(signal == 1)
   {
      OpenBuy(InitialLot);
   }
   else if(signal == -1)
   {
      OpenSell(InitialLot);
   }
}

//==================================================================
// SIGNAL ENGINE
//==================================================================

int GetTradeSignal()
{
   int bias = GetMarketBias();

   if(bias == 0)
      return 0;

   bool wolfe = DetectWolfeStyleSetup(bias);

   if(!wolfe)
      return 0;

   bool confirmation = M1Confirmation(bias);

   if(!confirmation)
      return 0;

   return bias;
}

//==================================================================
// MARKET BIAS
//==================================================================

int GetMarketBias()
{
   double fast = iMAValue(TradeSymbol,BiasTF,FastEMA,1);
   double slow = iMAValue(TradeSymbol,BiasTF,SlowEMA,1);

   if(fast == 0 || slow == 0)
      return 0;

   double close = iClose(TradeSymbol,BiasTF,1);

   // Bearish
   if(fast < slow && close < fast)
      return -1;

   // Bullish
   if(fast > slow && close > fast)
      return 1;

   return 0;
}

//==================================================================
// WOLFE STYLE SETUP
//==================================================================

bool DetectWolfeStyleSetup(int direction)
{
   double highs[10];
   double lows[10];

   int highCount = GetSwingHighs(highs,10);
   int lowCount = GetSwingLows(lows,10);

   if(highCount < 3 || lowCount < 3)
      return false;

   double price = iClose(TradeSymbol,BiasTF,1);

   //==============================================================
   // BEARISH WOLFE-STYLE SETUP
   //==============================================================

   if(direction == -1)
   {
      double h1 = highs[2];
      double h3 = highs[1];
      double h5 = highs[0];

      double l2 = lows[2];
      double l4 = lows[1];

      // Successive higher highs
      bool higherHighs = (h3 > h1 && h5 > h3);

      // Higher lows
      bool higherLows = (l4 > l2);

      if(!higherHighs || !higherLows)
         return false;

      // Estimate upper wedge boundary
      double upperSlope = (h5 - h1) / 4.0;

      double projectedResistance = h5 + upperSlope;

      // Price should be near final high / rejection zone
      double distance =
         MathAbs(price - h5) / SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      if(distance <= EntryZonePoints)
         return true;
   }

   //==============================================================
   // BULLISH WOLFE-STYLE SETUP
   //==============================================================

   if(direction == 1)
   {
      double l1 = lows[2];
      double l3 = lows[1];
      double l5 = lows[0];

      double h2 = highs[2];
      double h4 = highs[1];

      bool lowerLows = (l3 < l1 && l5 < l3);

      bool lowerHighs = (h4 < h2);

      if(!lowerLows || !lowerHighs)
         return false;

      double lowerSlope = (l5 - l1) / 4.0;

      double projectedSupport = l5 + lowerSlope;

      double distance =
         MathAbs(price - l5) / SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      if(distance <= EntryZonePoints)
         return true;
   }

   return false;
}

//==================================================================
// M1 CONFIRMATION
//==================================================================

bool M1Confirmation(int direction)
{
   double open1 = iOpen(TradeSymbol,EntryTF,1);
   double close1 = iClose(TradeSymbol,EntryTF,1);

   double high1 = iHigh(TradeSymbol,EntryTF,1);
   double low1 = iLow(TradeSymbol,EntryTF,1);

   double open2 = iOpen(TradeSymbol,EntryTF,2);
   double close2 = iClose(TradeSymbol,EntryTF,2);

   //==============================================================
   // BEARISH
   //==============================================================

   if(direction == -1)
   {
      bool bearishCandle = close1 < open1;

      bool bearishShift = close1 < low2();

      bool rejection =
         (high1 - MathMax(open1,close1)) >
         (MathMin(open1,close1) - low1);

      if(bearishCandle && (bearishShift || rejection))
         return true;
   }

   //==============================================================
   // BULLISH
   //==============================================================

   if(direction == 1)
   {
      bool bullishCandle = close1 > open1;

      bool bullishShift = close1 > high2();

      bool rejection =
         (MathMin(open1,close1) - low1) >
         (high1 - MathMax(open1,close1));

      if(bullishCandle && (bullishShift || rejection))
         return true;
   }

   return false;
}

//==================================================================
// SWING DETECTION
//==================================================================

int GetSwingHighs(double &values[],int maxValues)
{
   int found = 0;

   for(int i=SwingStrength+1;
       i<SwingLookback && found<maxValues;
       i++)
   {
      bool swing = true;

      double h = iHigh(TradeSymbol,BiasTF,i);

      for(int j=1;j<=SwingStrength;j++)
      {
         if(h <= iHigh(TradeSymbol,BiasTF,i-j) ||
            h <= iHigh(TradeSymbol,BiasTF,i+j))
         {
            swing = false;
            break;
         }
      }

      if(swing)
      {
         values[found] = h;
         found++;
      }
   }

   return found;
}

//------------------------------------------------------------------

int GetSwingLows(double &values[],int maxValues)
{
   int found = 0;

   for(int i=SwingStrength+1;
       i<SwingLookback && found<maxValues;
       i++)
   {
      bool swing = true;

      double l = iLow(TradeSymbol,BiasTF,i);

      for(int j=1;j<=SwingStrength;j++)
      {
         if(l >= iLow(TradeSymbol,BiasTF,i-j) ||
            l >= iLow(TradeSymbol,BiasTF,i+j))
         {
            swing = false;
            break;
         }
      }

      if(swing)
      {
         values[found] = l;
         found++;
      }
   }

   return found;
}

//==================================================================
// POSITION MANAGEMENT
//==================================================================

void ManageBasket()
{
   int count = CountPositions();

   if(count <= 0)
      return;

   double basketProfit = BasketProfit();

   double requiredProfit =
      BasketCommission() +
      MinimumNetProfit +
      ProfitBuffer;

   // Fast profit exit
   if(basketProfit >= requiredProfit)
   {
      CloseBasket();

      Print("Basket closed. Gross P/L: ",
            basketProfit,
            " Required: ",
            requiredProfit);

      return;
   }

   // Emergency basket stop
   if(basketProfit <= -MaxBasketLossUSD)
   {
      CloseBasket();

      Print("Emergency basket loss reached.");

      return;
   }
}

//==================================================================
// SCALING
//==================================================================

void ManageScaling()
{
   int count = CountPositions();

   if(count >= MaxPositions)
      return;

   double lots = TotalLots();

   if(lots + AddLot > MaxTotalLots)
      return;

   if(TimeCurrent() - LastAddTime <
      MinimumSecondsBetweenAdds)
      return;

   double profit = BasketProfit();

   // NEVER add to a losing basket
   if(profit < AddAfterProfitUSD)
      return;

   int direction = BasketDirection();

   if(direction == 1)
   {
      if(OpenBuy(AddLot))
         LastAddTime = TimeCurrent();
   }
   else if(direction == -1)
   {
      if(OpenSell(AddLot))
         LastAddTime = TimeCurrent();
   }
}

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

bool OpenBuy(double lot)
{
   lot = NormalizeLot(lot);

   double ask = SymbolInfoDouble(TradeSymbol,SYMBOL_ASK);

   if(ask <= 0)
      return false;

   double sl = 0;

   if(StopLossPoints > 0)
   {
      sl = ask -
           StopLossPoints *
           SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      sl = NormalizeDouble(
         sl,
         (int)SymbolInfoInteger(TradeSymbol,SYMBOL_DIGITS)
      );
   }

   return trade.Buy(
      lot,
      TradeSymbol,
      ask,
      sl,
      0,
      "Wolfe-SMC BUY"
   );
}

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

bool OpenSell(double lot)
{
   lot = NormalizeLot(lot);

   double bid = SymbolInfoDouble(TradeSymbol,SYMBOL_BID);

   if(bid <= 0)
      return false;

   double sl = 0;

   if(StopLossPoints > 0)
   {
      sl = bid +
           StopLossPoints *
           SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

      sl = NormalizeDouble(
         sl,
         (int)SymbolInfoInteger(TradeSymbol,SYMBOL_DIGITS)
      );
   }

   return trade.Sell(
      lot,
      TradeSymbol,
      bid,
      sl,
      0,
      "Wolfe-SMC SELL"
   );
}

//==================================================================
// BASKET PROFIT
//==================================================================

double BasketProfit()
{
   double total = 0;

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

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      total += PositionGetDouble(POSITION_PROFIT);
      total += PositionGetDouble(POSITION_SWAP);
   }

   return total;
}

//==================================================================
// COMMISSION ESTIMATE
//==================================================================

double BasketCommission()
{
   double lots = TotalLots();

   return (lots / 0.01) * CommissionPer001;
}

//==================================================================
// TOTAL LOTS
//==================================================================

double TotalLots()
{
   double lots = 0;

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

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      lots += PositionGetDouble(POSITION_VOLUME);
   }

   return lots;
}

//==================================================================
// COUNT POSITIONS
//==================================================================

int CountPositions()
{
   int count = 0;

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

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      count++;
   }

   return count;
}

//==================================================================
// BASKET DIRECTION
//==================================================================

int BasketDirection()
{
   double buyLots = 0;
   double sellLots = 0;

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

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      ENUM_POSITION_TYPE type =
         (ENUM_POSITION_TYPE)
         PositionGetInteger(POSITION_TYPE);

      double lots =
         PositionGetDouble(POSITION_VOLUME);

      if(type == POSITION_TYPE_BUY)
         buyLots += lots;

      if(type == POSITION_TYPE_SELL)
         sellLots += lots;
   }

   if(buyLots > sellLots)
      return 1;

   if(sellLots > buyLots)
      return -1;

   return 0;
}

//==================================================================
// CLOSE BASKET
//==================================================================

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

      if(ticket == 0)
         continue;

      if(!PositionSelectByTicket(ticket))
         continue;

      if(PositionGetString(POSITION_SYMBOL) != TradeSymbol)
         continue;

      if((ulong)PositionGetInteger(POSITION_MAGIC)
         != MagicNumber)
         continue;

      trade.PositionClose(ticket);
   }
}

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

bool SpreadOK()
{
   double ask =
      SymbolInfoDouble(TradeSymbol,SYMBOL_ASK);

   double bid =
      SymbolInfoDouble(TradeSymbol,SYMBOL_BID);

   double point =
      SymbolInfoDouble(TradeSymbol,SYMBOL_POINT);

   if(point <= 0)
      return false;

   double spread =
      (ask-bid)/point;

   return spread <= MaxSpreadPoints;
}

//==================================================================
// TRADING HOURS
//==================================================================

bool TradingTime()
{
   if(!UseTradingHours)
      return true;

   MqlDateTime dt;

   TimeToStruct(TimeCurrent(),dt);

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

   return false;
}

//==================================================================
// DAILY LOSS
//==================================================================

bool DailyLossExceeded()
{
   double equity =
      AccountInfoDouble(ACCOUNT_EQUITY);

   double loss =
      DailyStartEquity - equity;

   return loss >= MaxDailyLossUSD;
}

//==================================================================
// RESET DAILY EQUITY
//==================================================================

void UpdateDailyReference()
{
   MqlDateTime dt;

   TimeToStruct(TimeCurrent(),dt);

   dt.hour = 0;
   dt.min = 0;
   dt.sec = 0;

   datetime today = StructToTime(dt);

   if(today != DayStart)
   {
      DayStart = today;

      DailyStartEquity =
         AccountInfoDouble(ACCOUNT_EQUITY);
   }
}

//==================================================================
// EMA VALUE
//==================================================================

double iMAValue(
   string symbol,
   ENUM_TIMEFRAMES timeframe,
   int period,
   int shift
)
{
   int handle =
      iMA(
         symbol,
         timeframe,
         period,
         0,
         MODE_EMA,
         PRICE_CLOSE
      );

   if(handle == INVALID_HANDLE)
      return 0;

   double buffer[];

   ArraySetAsSeries(buffer,true);

   if(CopyBuffer(handle,0,shift,1,buffer) <= 0)
   {
      IndicatorRelease(handle);
      return 0;
   }

   double value = buffer[0];

   IndicatorRelease(handle);

   return value;
}

//==================================================================
// BAR HELPERS
//==================================================================

double low2()
{
   return iLow(TradeSymbol,EntryTF,2);
}

double high2()
{
   return iHigh(TradeSymbol,EntryTF,2);
}

//==================================================================
// LOT NORMALIZATION
//==================================================================

double NormalizeLot(double lot)
{
   double minLot =
      SymbolInfoDouble(TradeSymbol,SYMBOL_VOLUME_MIN);

   double maxLot =
      SymbolInfoDouble(TradeSymbol,SYMBOL_VOLUME_MAX);

   double step =
      SymbolInfoDouble(TradeSymbol,SYMBOL_VOLUME_STEP);

   if(lot < minLot)
      lot = minLot;

   if(lot > maxLot)
      lot = maxLot;

   lot =
      MathFloor(lot/step)*step;

   return NormalizeDouble(lot,2);
}

//+------------------------------------------------------------------+

Yanıtlandı

1
Geliştirici 1
Derecelendirme
(396)
Projeler
511
23%
Arabuluculuk
60
57% / 25%
Süresi dolmuş
60
12%
Çalışıyor
2
Geliştirici 2
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
3
Geliştirici 3
Derecelendirme
(1)
Projeler
1
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
Yayınlandı: 1 kod
4
Geliştirici 4
Derecelendirme
(1)
Projeler
1
0%
Arabuluculuk
0
Süresi dolmuş
1
100%
Serbest
5
Geliştirici 5
Derecelendirme
(1)
Projeler
1
0%
Arabuluculuk
1
0% / 100%
Süresi dolmuş
0
Çalışıyor
6
Geliştirici 6
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
7
Geliştirici 7
Derecelendirme
(3)
Projeler
3
33%
Arabuluculuk
0
Süresi dolmuş
0
Yüklendi
8
Geliştirici 8
Derecelendirme
(13)
Projeler
20
45%
Arabuluculuk
5
40% / 20%
Süresi dolmuş
2
10%
Çalışıyor
Yayınlandı: 7 makale, 35 kod
9
Geliştirici 9
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
10
Geliştirici 10
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
11
Geliştirici 11
Derecelendirme
(2)
Projeler
2
50%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
12
Geliştirici 12
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
13
Geliştirici 13
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
14
Geliştirici 14
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
15
Geliştirici 15
Derecelendirme
(5)
Projeler
6
50%
Arabuluculuk
0
Süresi dolmuş
0
Yüklendi
Yayınlandı: 1 kod
16
Geliştirici 16
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
17
Geliştirici 17
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
18
Geliştirici 18
Derecelendirme
(3)
Projeler
3
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
19
Geliştirici 19
Derecelendirme
(3)
Projeler
4
0%
Arabuluculuk
1
100% / 0%
Süresi dolmuş
1
25%
Serbest
20
Geliştirici 20
Derecelendirme
(258)
Projeler
269
29%
Arabuluculuk
1
100% / 0%
Süresi dolmuş
3
1%
Çalışıyor
Yayınlandı: 2 kod
21
Geliştirici 21
Derecelendirme
(298)
Projeler
478
40%
Arabuluculuk
105
40% / 24%
Süresi dolmuş
82
17%
Yüklendi
Yayınlandı: 2 kod
22
Geliştirici 22
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
23
Geliştirici 23
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
Yayınlandı: 1 kod
24
Geliştirici 24
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
25
Geliştirici 25
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
26
Geliştirici 26
Derecelendirme
Projeler
1
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
Benzer siparişler
ThunderGold Scalper – funktional ähnlicher Gold-Scalping-EA für MT5 30+ USD
Ich möchte einen professionellen Expert Advisor (EA) für MetaTrader 5 entwickeln lassen, der sich funktional am ThunderGold Scalper orientiert. Instrument: XAUUSD / GOLD Zeitrahmen: M15 Plattform: MetaTrader 5 / MQL5 Der EA soll eine eigene, nachprogrammierte Strategie verwenden und keine geschützten Quellcodes oder proprietären Dateien des Originalprodukts kopieren. Gewünschte Funktionen: automatischer Handel auf
XAGUSD MT5 Automated Trading Expert Advisor 30 - 200 USD
I need a fully automated Expert Advisor (EA) written in MQL5 for MetaTrader 5. The EA must work directly inside MT5 and must NOT require TradingView, PineConnector, webhooks, or another external connector to place trades. Trading Instrument Primary symbol: XAGUSD (Silver) My broker may display the symbol as XAGUSD-ECN, so the EA should work with the broker’s available XAGUSD symbol. Main entry timeframe: 5-minute
Profitable manual strategy for trading in forex 30+ USD
Hi, I am looking for a profitable manual strategy for trading in forex, no bot no EA , only EA. I want to make good profit.If any one has please let me know, i will test it and if satisfied only i will make the payment. Regards
RECHERCHE DÉVELOPPEUR MQL5 — PARTENARIAT 50/50 30+ USD
RECHERCHE DÉVELOPPEUR MQL5 — PARTENARIAT 50/50 Objectif : développer un EA de trading automatisé en 11 jours maximum pour participer à plusieurs concours de trading démo. Je recherche un développeur MQL5 expérimenté, capable de développer, tester et optimiser un EA proprement, avec une vraie maîtrise de la gestion du risque. CONCOURS VISÉS 🥇 XM — Weekly Demo Contest - Concours récurrent - Prize pool annoncé : 25 000
Trading view indicator fixing 30+ USD
can you help me with I have an indicator that I built and I work with PickMyTrade. The entries come through the alerts I get from Trading View . Trading View needs to send an alert and PickMyTrade executes a trade at that exact same second. Now, I have a problem in Trading View with the synchronization between the alert and the signal. I have a box that I built for a trade. It needs to output the box and get an
(Serious offer) Buying profitable EA Budget up to 1.5k 200 - 1500 USD
Buying profitable EA Budget up to 1.5k (Serious offer) Specification EN I will pay 1.5k (negotiable) for an EA for existing MT4 that generates a minimum of 5% or higher a month consistently no monthly DD more than 5% on ,5k account Please send demo version with optimal settings so I can test, if it performs in a strategy tester i will also need option to forward test it in a demo account. Developer should be willing
Simple EA with Very High Sniper Assertiveness and Low RRR ( 0.06:1, 0.1:1, 0.3:1) (1-3 TRADES PER DAY) 30+ USD
1- The EA must h ave a unique strategy specialized on make trades with very very low RRR, so basicaly risking 1475$ to make 100$, with an ammount adjustable of trades per day. (This is very important that i wish in 100 trades, it makes a maximum of 10 trades of mistake, maybe less...) 2- The EA must have the strategy specialized on INDEX CFD. 3- The EA must make each trade with more than 3 minutes, and less than 12h
MT4 EA - Simultaneous Buy and Sell With Stop Loss and Optional Trailing Stop 30+ USD
I need an MT4 Expert Advisor (MQL4). 1. Open one Buy and one Sell trade simultaneously. 2. Adjustable lot size (default 0.01). 3. Stop Loss on both trades. 4. If one trade hits Stop Loss: - Do not open a replacement trade. - Leave the remaining trade open. 5. Optional trailing stop: - On/Off switch. - Adjustable distance. 6. When the remaining trade closes: - Open a new Buy and Sell pair. - Repeat continuously
I am looking for an automatic trading robot that can replicate and produce a 85% or greater profit trading on most currency pairs. 50 - 100 USD
Hi, I Wanne have a trading robot that give me signals for short buy and sell. And only for all currency in forex trading and also can use it on mt5
2500k to 10k for one MT5 Expert Advisor, done properly 5000 - 10000 USD
I will pay 2500 to 10000 USD (negotiable) for one MT5 Expert Advisor, built properly. One robot done right, not a batch of cheap jobs. I have a strategy I believe in and a rough draft robot I built myself. The logic is there. The execution is not. That last part is outside my expertise, which is why I am hiring instead of continuing on my own. I am open to feedback on the strategy itself. If you see something in it

Proje bilgisi

Bütçe
89+ USD
Son teslim tarihi
from 1 to 30 gün

Müşteri

Verilmiş siparişler1
Arabuluculuk sayısı0