Test EA for Cloud | Stamps Forex Trading

Test EA for Cloud - Forex EA Specifications

Most of our EAs are created using EA builder, which is third-party software that allows users to develop EAs without writing code. The software is very reasonable, easy to use, and has definitely exceeded my expectations. You can get more information about the software HERE.

Also visit the StampsFX YTube page for videos of my building several different EAs.

Strategy:

The EA takes advantage of pure price action. This EA was tested on a 30-minute GBPUSD chart. This EA places a buy or sell based on the previous 4 candles. If the candles are bullish it places a sell order, if the candles are bearish it places a buy order.

Strategy Tester Results:

From 02/13/2023 to 03/02/2023 the MT4 strategy tester returned a profit of $2632.79. The account started with 10k, and the absolute drawdown was only $102.81. The EA took 9 Total Trades. The EA Won 4 trades, and Loss 5 Trades. Stop Loss was 30 PIPS, Take Profit was 200 PIPS. Visit the StampsFX YTube channel for details. Past results are not indicative of future results. The strategy test results are not a guarantee of future success. The strategy and EA provided below is not a recommendation to buy or sell a currency pair, currency, or any derivates.

//CODE

Risk - Warning:

The overall risk is not known. Past results do not indicate future success. This EA is very risky, and the chances of it blowing an account is extremely high, as with any EA. Backtesting and running the EA on a demo account is the safest option. You (as the user) are responsible for any trading losses. Only trade with funds you are prepared to lose. Stampsfx, the creator, nor any affiliated parties are responsible for trading losses.

Live Account Results:

A live account was opened to test a similar forex EA, however, it was only a test. The live account took the first trade on 2/22/2023 and will run for approximately about a month. The live account test is being utilized with a lot size between .02 and .05. You can see the details on the StampsFX Youtube channel. As of 3/3/2023 the EA has returned a total ROI of 60%.

Instructions to Save EA:
1. COPY THE CODE ON THIS PAGE.
2. PASTE CODE IN META EDITOR

//+------------------------------------------------------------------+
//| Strategy: Test EA for Cloud.mq4 |
//| Created with EABuilder.com |
//| |
//+------------------------------------------------------------------+
#property copyright "Stampsfx"
#property link "https://www.Stampsfx.com"
#property version "1.00"
#property description ""

#include <stdlib.mqh>
#include <stderror.mqh>

extern double SL_PIPS = 30;
extern double TP_PIPS = 200;
extern double BreakEven_Points = 100;
int LotDigits; //initialized in OnInit
int MagicNumber = 1239264;
int NextOpenTradeAfterBars = 1; //next open trade after time
double TradeSize = 0.01;
int MaxSlippage = 3; //slippage, adjusted in OnInit
int MaxOpenTrades = 1;
int MaxLongTrades = 1000;
int MaxShortTrades = 1000;
int MaxPendingOrders = 1000;
int MaxLongPendingOrders = 1000;
int MaxShortPendingOrders = 1000;
bool Hedging = false;
int OrderRetry = 5; //# of retries if sending order returns error
int OrderWait = 5; //# of seconds to wait if sending order returns error
double myPoint; //initialized in OnInit

void myAlert(string type, string message)
{
if(type == "print")
Print(message);
else if(type == "error")
{
Print(type+" | Test EA for Cloud @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
}
else if(type == "order")
{
}
else if(type == "modify")
{
}
}

int TradesCount(int type) //returns # of open trades for order type, current symbol and magic number
{
int result = 0;
int total = OrdersTotal();
for(int i = 0; i < total; i++)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) == false) continue;
if(OrderMagicNumber() != MagicNumber || OrderSymbol() != Symbol() || OrderType() != type) continue;
result++;
}
return(result);
}

bool SelectLastHistoryTrade()
{
int lastOrder = -1;
int total = OrdersHistoryTotal();
for(int i = total-1; i >= 0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
{
lastOrder = i;
break;
}
}
return(lastOrder >= 0);
}

datetime LastCloseTime()
{
if(SelectLastHistoryTrade())
{
return(OrderCloseTime());
}
return(0);
}

int myOrderSend(int type, double price, double volume, string ordername) //send order, return ticket ("price" is irrelevant for market orders)
{
if(!IsTradeAllowed()) return(-1);
int ticket = -1;
int retries = 0;
int err = 0;
int long_trades = TradesCount(OP_BUY);
int short_trades = TradesCount(OP_SELL);
int long_pending = TradesCount(OP_BUYLIMIT) + TradesCount(OP_BUYSTOP);
int short_pending = TradesCount(OP_SELLLIMIT) + TradesCount(OP_SELLSTOP);
string ordername_ = ordername;
if(ordername != "")
ordername_ = "("+ordername+")";
//test Hedging
if(!Hedging && ((type % 2 == 0 && short_trades + short_pending > 0) || (type % 2 == 1 && long_trades + long_pending > 0)))
{
myAlert("print", "Order"+ordername_+" not sent, hedging not allowed");
return(-1);
}
//test maximum trades
if((type % 2 == 0 && long_trades >= MaxLongTrades)
|| (type % 2 == 1 && short_trades >= MaxShortTrades)
|| (long_trades + short_trades >= MaxOpenTrades)
|| (type > 1 && type % 2 == 0 && long_pending >= MaxLongPendingOrders)
|| (type > 1 && type % 2 == 1 && short_pending >= MaxShortPendingOrders)
|| (type > 1 && long_pending + short_pending >= MaxPendingOrders)
)
{
myAlert("print", "Order"+ordername_+" not sent, maximum reached");
return(-1);
}
//prepare to send order
while(IsTradeContextBusy()) Sleep(100);
RefreshRates();
if(type == OP_BUY)
price = Ask;
else if(type == OP_SELL)
price = Bid;
else if(price < 0) //invalid price for pending order
{
myAlert("order", "Order"+ordername_+" not sent, invalid price for pending order");
return(-1);
}
int clr = (type % 2 == 1) ? clrRed : clrBlue;
while(ticket < 0 && retries < OrderRetry+1)
{
ticket = OrderSend(Symbol(), type, NormalizeDouble(volume, LotDigits), NormalizeDouble(price, Digits()), MaxSlippage, 0, 0, ordername, MagicNumber, 0, clr);
if(ticket < 0)
{
err = GetLastError();
myAlert("print", "OrderSend"+ordername_+" error #"+IntegerToString(err)+" "+ErrorDescription(err));
Sleep(OrderWait*1000);
}
retries++;
}
if(ticket < 0)
{
myAlert("error", "OrderSend"+ordername_+" failed "+IntegerToString(OrderRetry+1)+" times; error #"+IntegerToString(err)+" "+ErrorDescription(err));
return(-1);
}
string typestr[6] = {"Buy", "Sell", "Buy Limit", "Sell Limit", "Buy Stop", "Sell Stop"};
myAlert("order", "Order sent"+ordername_+": "+typestr[type]+" "+Symbol()+" Magic #"+IntegerToString(MagicNumber));
return(ticket);
}

int myOrderModify(int ticket, double SL, double TP) //modify SL and TP (absolute price), zero targets do not modify
{
if(!IsTradeAllowed()) return(-1);
bool success = false;
int retries = 0;
int err = 0;
SL = NormalizeDouble(SL, Digits());
TP = NormalizeDouble(TP, Digits());
if(SL < 0) SL = 0;
if(TP < 0) TP = 0;
//prepare to select order
while(IsTradeContextBusy()) Sleep(100);
if(!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
{
err = GetLastError();
myAlert("error", "OrderSelect failed; error #"+IntegerToString(err)+" "+ErrorDescription(err));
return(-1);
}
//prepare to modify order
while(IsTradeContextBusy()) Sleep(100);
RefreshRates();
if(CompareDoubles(SL, 0)) SL = OrderStopLoss(); //not to modify
if(CompareDoubles(TP, 0)) TP = OrderTakeProfit(); //not to modify
if(CompareDoubles(SL, OrderStopLoss()) && CompareDoubles(TP, OrderTakeProfit())) return(0); //nothing to do
while(!success && retries < OrderRetry+1)
{
success = OrderModify(ticket, NormalizeDouble(OrderOpenPrice(), Digits()), NormalizeDouble(SL, Digits()), NormalizeDouble(TP, Digits()), OrderExpiration(), CLR_NONE);
if(!success)
{
err = GetLastError();
myAlert("print", "OrderModify error #"+IntegerToString(err)+" "+ErrorDescription(err));
Sleep(OrderWait*1000);
}
retries++;
}
if(!success)
{
myAlert("error", "OrderModify failed "+IntegerToString(OrderRetry+1)+" times; error #"+IntegerToString(err)+" "+ErrorDescription(err));
return(-1);
}
string alertstr = "Order modified: ticket="+IntegerToString(ticket);
if(!CompareDoubles(SL, 0)) alertstr = alertstr+" SL="+DoubleToString(SL);
if(!CompareDoubles(TP, 0)) alertstr = alertstr+" TP="+DoubleToString(TP);
myAlert("modify", alertstr);
return(0);
}

int myOrderModifyRel(int ticket, double SL, double TP) //modify SL and TP (relative to open price), zero targets do not modify
{
if(!IsTradeAllowed()) return(-1);
bool success = false;
int retries = 0;
int err = 0;
SL = NormalizeDouble(SL, Digits());
TP = NormalizeDouble(TP, Digits());
if(SL < 0) SL = 0;
if(TP < 0) TP = 0;
//prepare to select order
while(IsTradeContextBusy()) Sleep(100);
if(!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
{
err = GetLastError();
myAlert("error", "OrderSelect failed; error #"+IntegerToString(err)+" "+ErrorDescription(err));
return(-1);
}
//prepare to modify order
while(IsTradeContextBusy()) Sleep(100);
RefreshRates();
//convert relative to absolute
if(OrderType() % 2 == 0) //buy
{
if(NormalizeDouble(SL, Digits()) != 0)
SL = OrderOpenPrice() - SL;
if(NormalizeDouble(TP, Digits()) != 0)
TP = OrderOpenPrice() + TP;
}
else //sell
{
if(NormalizeDouble(SL, Digits()) != 0)
SL = OrderOpenPrice() + SL;
if(NormalizeDouble(TP, Digits()) != 0)
TP = OrderOpenPrice() - TP;
}
if(CompareDoubles(SL, 0)) SL = OrderStopLoss(); //not to modify
if(CompareDoubles(TP, 0)) TP = OrderTakeProfit(); //not to modify
if(CompareDoubles(SL, OrderStopLoss()) && CompareDoubles(TP, OrderTakeProfit())) return(0); //nothing to do
while(!success && retries < OrderRetry+1)
{
success = OrderModify(ticket, NormalizeDouble(OrderOpenPrice(), Digits()), NormalizeDouble(SL, Digits()), NormalizeDouble(TP, Digits()), OrderExpiration(), CLR_NONE);
if(!success)
{
err = GetLastError();
myAlert("print", "OrderModify error #"+IntegerToString(err)+" "+ErrorDescription(err));
Sleep(OrderWait*1000);
}
retries++;
}
if(!success)
{
myAlert("error", "OrderModify failed "+IntegerToString(OrderRetry+1)+" times; error #"+IntegerToString(err)+" "+ErrorDescription(err));
return(-1);
}
string alertstr = "Order modified: ticket="+IntegerToString(ticket);
if(!CompareDoubles(SL, 0)) alertstr = alertstr+" SL="+DoubleToString(SL);
if(!CompareDoubles(TP, 0)) alertstr = alertstr+" TP="+DoubleToString(TP);
myAlert("modify", alertstr);
return(0);
}

void TrailingStopBE(int type, double profit, double add) //set Stop Loss to open price if in profit
{
int total = OrdersTotal();
profit = NormalizeDouble(profit, Digits());
for(int i = total-1; i >= 0; i--)
{
while(IsTradeContextBusy()) Sleep(100);
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderMagicNumber() != MagicNumber || OrderSymbol() != Symbol() || OrderType() != type) continue;
RefreshRates();
if((type == OP_BUY && Bid > OrderOpenPrice() + profit && (NormalizeDouble(OrderStopLoss(), Digits()) <= 0 || OrderOpenPrice() > OrderStopLoss()))
|| (type == OP_SELL && Ask < OrderOpenPrice() - profit && (NormalizeDouble(OrderStopLoss(), Digits()) <= 0 || OrderOpenPrice() < OrderStopLoss())))
myOrderModify(OrderTicket(), OrderOpenPrice() + add, 0);
}
}

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//initialize myPoint
myPoint = Point();
if(Digits() == 5 || Digits() == 3)
{
myPoint *= 10;
MaxSlippage *= 10;
}
//initialize LotDigits
double LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
if(NormalizeDouble(LotStep, 3) == round(LotStep))
LotDigits = 0;
else if(NormalizeDouble(10*LotStep, 3) == round(10*LotStep))
LotDigits = 1;
else if(NormalizeDouble(100*LotStep, 3) == round(100*LotStep))
LotDigits = 2;
else LotDigits = 3;
return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
int ticket = -1;
double price;
double SL;
double TP;

TrailingStopBE(OP_BUY, BreakEven_Points * myPoint, 0); //Trailing Stop = go break even
TrailingStopBE(OP_SELL, BreakEven_Points * myPoint, 0); //Trailing Stop = go break even

//Open Buy Order
if(Open[1] > Close[1] //Candlestick Open > Candlestick Close
&& Open[2] > Close[2] //Candlestick Open > Candlestick Close
&& Open[3] > Close[3] //Candlestick Open > Candlestick Close
&& Open[4] > Close[4] //Candlestick Open > Candlestick Close
)
{
RefreshRates();
price = Ask;
SL = SL_PIPS * myPoint; //Stop Loss = value in points (relative to price)
TP = TP_PIPS * myPoint; //Take Profit = value in points (relative to price)
if(TradesCount(OP_BUY) + TradesCount(OP_SELL) > 0 || TimeCurrent() - LastCloseTime() < NextOpenTradeAfterBars * PeriodSeconds()) return; //next open trade after time after previous trade's close
if(IsTradeAllowed())
{
ticket = myOrderSend(OP_BUY, price, TradeSize, "");
if(ticket <= 0) return;
}
else //not autotrading => only send alert
myAlert("order", "");
myOrderModifyRel(ticket, SL, 0);
myOrderModifyRel(ticket, 0, TP);
}

//Open Sell Order
if(Open[1] < Close[1] //Candlestick Open < Candlestick Close
&& Open[2] < Close[2] //Candlestick Open < Candlestick Close
&& Open[3] < Close[3] //Candlestick Open < Candlestick Close
&& Open[4] < Close[4] //Candlestick Open < Candlestick Close
)
{
RefreshRates();
price = Bid;
SL = SL_PIPS * myPoint; //Stop Loss = value in points (relative to price)
TP = TP_PIPS * myPoint; //Take Profit = value in points (relative to price)
if(TradesCount(OP_BUY) + TradesCount(OP_SELL) > 0 || TimeCurrent() - LastCloseTime() < NextOpenTradeAfterBars * PeriodSeconds()) return; //next open trade after time after previous trade's close
if(IsTradeAllowed())
{
ticket = myOrderSend(OP_SELL, price, TradeSize, "");
if(ticket <= 0) return;
}
else //not autotrading => only send alert
myAlert("order", "");
myOrderModifyRel(ticket, SL, 0);
myOrderModifyRel(ticket, 0, TP);
}
}
//+------------------------------------------------------------------+