Scam Example 1 – Let Losers Run!

This robot shows you one way in which unscrupulous marketers can try and scam you by showing you highly misleading "live" results on their website. The expert advisor uses the "hedging" feature of MetaTrader 4 to prevent losing trades ever being displayed in the list of closed trades. You've probably heard the advice that you should cut your losses short and let your profits run. This EA does exactly the opposite. It still manages to produce an extremely impressive graph though!

This scam example is based on our first example robot which used random entries. This time however it goes both long and short at the same time. When one out of the two trades reaches its take profit level it shows up in the MetaTrader "Account History" list as a closed trade with a healthy profit. At this point the take profit and stop loss prices on the losing order are cancelled. The loss is allowed to run forever! Rinse and repeat, and check below to see what happens. Whilst the green equity line on the backtest results reveals the true picture, the blue account balance line shows no losing trades whatsoever, at least until the strategy tester closes every order at the end of the test. The thing is though, on a forward test on a demo account, any reports created from the "Account History" tab in MetaTrader only show the impressive account balance. Try it for yourself and see.

Here are the results from the MetaTrader strategy tester (but with the list of trades shortened):

Here's the source code for the "robot":

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

//|                                                   GuruScam01.mq4 |

//|     Copyright © 2009, Marketing Dreams Ltd. All Rights Reserved. |

//|                                         http://trading-gurus.com |

//|                                                                  |

//| GuruTrader™ scam example 1                                       |

//| Version 1.0                                                      |

//|                                                                  |

//| How to produce an impressive "live" equity curve while actually  |

//| losing money!                                                    |

//|                                                                  |

//| Wealth Warning! This expert is for educational purposes only.    |

//| It should NEVER be used on a live account. Past performance is   |

//| in no way indicative of future results!                          |

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

#property copyright "Copyright © 2009, Marketing Dreams Ltd."

#property link      "http://trading-gurus.com"

#define SLEEP_OK     250
#define SLEEP_ERR    250

//---- input parameters
extern int     Magic = 54321;
extern int     Slippage=30;
extern int     ProfitTarget=500;
extern int     StopLoss=5000;
extern double  Lots=0.01;
extern bool    StpMode = FALSE;

//---- static variables
static int     Dig;
static double  Points;

static bool    Initialized = FALSE;
static bool    Running = FALSE;
static int     LongOrder;
static int     ShortOrder;
static double  LastBid;
static double  LastAsk;

static color   clBuy = DodgerBlue;
static color   clSell = Crimson;

//+------------------------------------------------------------------+
//| Utility functions                                                |
//+------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>

//+------------------------------------------------------------------+
//| Expert helper functions                                          |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Modifies target and stop levels of an order                      |
//+------------------------------------------------------------------+
int UpdateOrder(int Ticket, double TargetPrice, double StopPrice)
{
   int ErrorCode;

   if (OrderSelect(Ticket, SELECT_BY_TICKET) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error selecting order to modify ", Ticket, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      return(-1);
   }

   if (OrderModify(Ticket, OrderOpenPrice(), StopPrice, TargetPrice, 0)) {
      Sleep(SLEEP_OK);
      return (Ticket);
   }

   ErrorCode = GetLastError();
   RefreshRates();
   Print("Error modifying order ", Ticket, ": ",
         ErrorDescription(ErrorCode), " (", ErrorCode, ")");
   Sleep(SLEEP_ERR);

   return (-1);
}

//+------------------------------------------------------------------+
//| Places an order                                                  |
//+------------------------------------------------------------------+
int Order(string symbol, int Type, double Entry, double Quantity,
          double TargetPrice, double StopPrice, string comment="")
{
   string TypeStr;
   color  TypeCol;
   int    ErrorCode, Ticket;
   double Price, FillPrice;

   Price = NormalizeDouble(Entry, Dig);

   switch (Type) {
      case OP_BUY:
         TypeStr = "BUY";
         TypeCol = clBuy;
         break;
      case OP_SELL:
         TypeStr = "SELL";
         TypeCol = clSell;
         break;
      default:
         Print("Unknown order type ", Type);
         break;
   }

   if (StpMode) {
      Ticket = OrderSend(symbol, Type, Quantity, Price, Slippage,
               0, 0, comment, Magic, 0, TypeCol);
   }
   else {
      Ticket = OrderSend(symbol, Type, Quantity, Price, Slippage,
               StopPrice, TargetPrice, comment, Magic, 0, TypeCol);
   }
   if (Ticket >= 0) {
      Sleep(SLEEP_OK);
      if (OrderSelect(Ticket, SELECT_BY_TICKET) == TRUE) {
         FillPrice = OrderOpenPrice();
         if (Entry != FillPrice) {
            RefreshRates();
            Print("Slippage on order ", Ticket, " - Requested = ",
                  Entry, ", Fill = ", FillPrice, ", Current Bid = ",
                  Bid, ", Current Ask = ", Ask);
         }
         if (StpMode && ((StopPrice > 0) || (TargetPrice > 0))) {
            if (OrderModify(Ticket, FillPrice, StopPrice, TargetPrice, 0, TypeCol)) {
               Sleep(SLEEP_OK);
               return (Ticket);
            }
   	   }
      }
      else {
         ErrorCode = GetLastError();
         Print("Error selecting new order ", Ticket, ": ",
               ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      }
      return (Ticket);
   }

   ErrorCode = GetLastError();
   RefreshRates();
   Print("Error opening ", TypeStr, " order: ", ErrorDescription(ErrorCode),
         " (", ErrorCode, ")", ", Entry = ", Price, ", Target = ",
         TargetPrice, ", Stop = ", StopPrice, ", Current Bid = ", Bid,
         ", Current Ask = ", Ask);
   Sleep(SLEEP_ERR);

   return (-1);
}

//+------------------------------------------------------------------+
//| Performs system initialisation                                   |
//+------------------------------------------------------------------+
void InitSystem()
{
   Running = FALSE;

   RefreshRates();
   LastBid = Bid;
   LastAsk = Ask;

   Initialized = TRUE;
}

//+------------------------------------------------------------------+
//| Checks for entry to a trade                                      |
//+------------------------------------------------------------------+
int CheckEntry(double Size)
{
   LongOrder = Order(Symbol(), OP_BUY, Ask, Size,
         Ask + (Points * ProfitTarget), Bid - (Points * StopLoss));
   ShortOrder = Order(Symbol(), OP_SELL, Bid, Size,
         Bid - (Points * ProfitTarget), Ask + (Points * StopLoss));
   if ((LongOrder > 0) && (ShortOrder > 0))
      return(1);
   else
      return(0);
}

//+------------------------------------------------------------------+
//| Checks for exit from a trade                                     |
//+------------------------------------------------------------------+
int CheckExit()
{
   int ErrorCode;

   if (OrderSelect(LongOrder, SELECT_BY_TICKET) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error selecting order ", LongOrder, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      return(-1);
   }
   else if (OrderCloseTime() > 0) {
      Print("Order ", LongOrder, " closed: ", OrderClosePrice(),
            ", at ", TimeToStr(OrderCloseTime()));
      UpdateOrder(ShortOrder, 0, 0);
      return(1);
   }

   if (OrderSelect(ShortOrder, SELECT_BY_TICKET) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error selecting order ", ShortOrder, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      return(-1);
   }
   else if (OrderCloseTime() > 0) {
      Print("Order ", ShortOrder, " closed: ", OrderClosePrice(),
            ", at ", TimeToStr(OrderCloseTime()));
      UpdateOrder(LongOrder, 0, 0);
      return(1);
   }
   return(0);
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   Dig = MarketInfo(Symbol(), MODE_DIGITS);
   Points = MarketInfo(Symbol(), MODE_POINT);

   Print("Digits = ", Dig, ", Points = ", DoubleToStr(Points, 5));

   if (!IsDemo() && !IsTesting()) {
      MessageBox("Wealth Warning! This expert is for educational purposes only." +
            " It should NEVER be used on a live account." +
            " Past performance is in no way indicative of future results!");
      Print("Initialization Failure");
      return(-1);
   }

   InitSystem();

   Print("Initialized OK");

   return(0);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
    Print("DeInitialized OK");

    return(0);
}

//+------------------------------------------------------------------+
//| Expert start function                                            |
//| Executed on every tick                                           |
//+------------------------------------------------------------------+
int start()
{
   if (!Initialized) {
      return(-1);
   }
   else if (Running) {                    // Are we in a trade at the moment?
      if (CheckExit() > 0) {              // Yes - Last trade complete?
         Initialized = FALSE;             // Yes - Indicate we need to reinitialise
         InitSystem();                    //  and start all over again!
      }
   }
   else {
      if (CheckEntry(Lots) > 0) {         // Entered a trade?
         Running = TRUE;                  // Yes - Indicate that we're in a trade
      }
   }
   return(0);
}

You can also download the source code here.