Ozzman45/Warrior_EA
Watch
1
0
Fork
You've already forked Warrior_EA
 0
forked from mnbvc188199/Warrior_EA
Code Pull requests Projects Releases Packages Wiki Activity Actions
Warrior_EA/System/TradeChecks.mqh
AnimateDread 47a5ef338b Refactor Warrior EA: Integrate custom signal modules, enhance voting mechanism, and improve management features 
- Replaced standard library signal modules with custom implementations to allow for named patterns and improved voting.
- Added new input parameters for module weights, allowing for optimization of individual signal contributions.
- Enhanced the management of trades with new options for breakeven and management cut.
- Introduced a mechanism for dynamic ranking of signal weights based on historical performance.
- Improved initialization logic to ensure proper registration of filters and handling of trading conditions.
- Added detailed logging for trading permissions and account status during initialization.
2026-09-13 14:32:40 -04:00

1197 lines
52 KiB
MQL5
RawPermalinkBlameHistory

//+------------------------------------------------------------------+
//| TradeChecks.mqh |
//| AnimateDread |
//| "The Checks a Trading Robot Must Pass Before Publication in the |
//| Market" (https://www.mql5.com/en/articles/2555). One function |
//| per rule, all free functions prefixed TC*, so any call site |
//| (money management, signal SL/TP shaping, the expert's trade |
//| paths) can apply the same rule without duplicating the symbol- |
//| property math. |
//+------------------------------------------------------------------+
#ifndef WARRIOR_TRADECHECKS_MQH
#define WARRIOR_TRADECHECKS_MQH
//--- one journal line per distinct message key per this many seconds
#define TC_LOG_THROTTLE_SECONDS 60
//--- volume comparisons are done in units of 1/1000 of a volume step, so floating-point
//--- representation error in e.g. 0.1/0.01 can never make a legal volume look off-step
#define TC_VOLUME_EPSILON_FRAC 0.001
//+------------------------------------------------------------------+
//| Throttled journal output. `key` identifies the CONDITION (not the |
//| formatted text), so a message whose numbers change every tick |
//| still collapses to one line per throttle window. |
//| |
//| THE WINDOW IS WALL CLOCK, NOT BROKER TIME (fixed 2026-09-07), and |
//| the difference is the whole value of this function. It used |
//| TimeCurrent(), which in the Strategy Tester is SIMULATED time: a |
//| pass over years of history crosses sixty simulated seconds many |
//| times a second, so the throttle admitted almost every call and |
//| the function did nothing where it was needed most. Measured on the|
//| 2026-09-06 tester log: 247,146 lines - 15.7% of 1,570,535 - were |
//| two "rejected" messages that this throttle was supposed to be |
//| collapsing. GetTickCount64() is real elapsed milliseconds and |
//| behaves the same in both worlds: unchanged in live trading, where |
//| wall clock and broker time advance together, and genuinely one |
//| line per key per minute of RUN TIME in a tester pass. |
//| |
//| Suppressed calls are COUNTED and reported on the next line that |
//| gets through, so throttling never silently hides how often a |
//| condition fired - the number is usually the interesting part. |
//+------------------------------------------------------------------+
void TCLog(const string key, const string message)
{
static string s_keys[];
static ulong s_times[];
static long s_suppressed[];
const ulong now = GetTickCount64();
const ulong window = (ulong)TC_LOG_THROTTLE_SECONDS * 1000;
int total = ArraySize(s_keys);
for(int i = 0; i < total; i++)
{
if(s_keys[i] != key)
continue;
//--- Unsigned subtraction, so this stays correct across the 64-bit tick counter's wrap.
if(now - s_times[i] < window)
{
s_suppressed[i]++;
return;
}
s_times[i] = now;
if(s_suppressed[i] > 0)
{
Print(message + StringFormat(" [+%I64d more since the last line]", s_suppressed[i]));
s_suppressed[i] = 0;
}
else
Print(message);
return;
}
ArrayResize(s_keys, total + 1);
ArrayResize(s_times, total + 1);
ArrayResize(s_suppressed, total + 1);
s_keys[total] = key;
s_times[total] = now;
s_suppressed[total] = 0;
Print(message);
}
//+------------------------------------------------------------------+
//| Article #10 - zero divide. |
//| Returns `fallback` instead of raising the runtime error whenever |
//| the denominator is zero or not a finite number. |
//+------------------------------------------------------------------+
double TCSafeDivide(const double numerator, const double denominator, const double fallback = 0.0)
{
if(!MathIsValidNumber(numerator) || !MathIsValidNumber(denominator) || denominator == 0.0)
return fallback;
double result = numerator / denominator;
return MathIsValidNumber(result) ? result : fallback;
}
//+------------------------------------------------------------------+
//| Article #9 - array out of range. |
//| The index rule the article states verbatim: an index may not be |
//| negative and must be strictly less than ArraySize(). |
//+------------------------------------------------------------------+
bool TCIndexOk(const int index, const int size)
{
return(index >= 0 && index < size);
}
//+------------------------------------------------------------------+
//| Symbol property accessors. All of them return a safe default when |
//| the broker has not synced the property yet, so a caller never |
//| divides by / compares against a garbage 0. |
//+------------------------------------------------------------------+
double TCPoint(const string symbol)
{
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
return (point > 0.0) ? point : _Point;
}
int TCDigits(const string symbol)
{
return((int)SymbolInfoInteger(symbol, SYMBOL_DIGITS));
}
//+------------------------------------------------------------------+
//| Two-sided quote, or false with a description saying what could |
//| not be done without one. The single definition of "usable quote" |
//| for every check below - a symbol that has not synced yet reads |
//| back 0 on both sides, and 0 would pass a distance test that a |
//| real price fails. |
//+------------------------------------------------------------------+
bool TCLiveQuote(const string symbol, const string purpose, double &bid, double &ask, string &description)
{
bid = SymbolInfoDouble(symbol, SYMBOL_BID);
ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
if(bid > 0.0 && ask > 0.0)
return true;
description = "no live quote for " + symbol + ", cannot " + purpose;
return false;
}
//+------------------------------------------------------------------+
//| Price formatter for the diagnostics below. Deliberately builds |
//| the string with DoubleToString() rather than a "%.*f" format: |
//| StringFormat() does not support printf's star-precision form, so |
//| a "%.*f" would print the digit count as a separate argument and |
//| silently shift every remaining placeholder by one. |
//+------------------------------------------------------------------+
string TCPrice(const string symbol, const double price)
{
return DoubleToString(price, TCDigits(symbol));
}
double TCVolumeMin(const string symbol)
{
return SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
}
double TCVolumeMax(const string symbol)
{
return SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
}
double TCVolumeStep(const string symbol)
{
double step = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
//--- a 0 step would make every "is it a multiple of the step" test a division by zero (article #10)
return (step > 0.0) ? step : TCVolumeMin(symbol);
}
//+------------------------------------------------------------------+
//| Article #6/#7 - the two broker distance levels, in price units. |
//+------------------------------------------------------------------+
double TCStopsLevel(const string symbol)
{
double point = TCPoint(symbol);
double stops = (double)SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL) * point;
double spread = (double)SymbolInfoInteger(symbol, SYMBOL_SPREAD) * point;
return MathMax(stops, spread);
}
double TCFreezeLevel(const string symbol)
{
return((double)SymbolInfoInteger(symbol, SYMBOL_TRADE_FREEZE_LEVEL) * TCPoint(symbol));
}
//+------------------------------------------------------------------+
//| The distance a NEW stop/limit price must respect. Brokers set the |
//| two levels independently and either can be the larger, so a price |
//| is only safe once it clears BOTH - see the same reasoning in |
//| Trailing\TrailingATR.mqh::AdjustStopLoss(). |
//+------------------------------------------------------------------+
double TCMinStopDistance(const string symbol)
{
return MathMax(TCStopsLevel(symbol), TCFreezeLevel(symbol));
}
//+------------------------------------------------------------------+
//| Which order type an entry price will produce - see |
//| CExpertTrade::Buy()/Sell(), whose routing this reproduces. `ask`/ |
//| `bid` are taken as parameters rather than re-queried here so a |
//| caller's own (possibly RefreshRates()-cached) CSymbolInfo values |
//| are what decide the routing, matching what CExpertTrade itself |
//| would see. |
//+------------------------------------------------------------------+
ENUM_ORDER_TYPE TCResolveOrderType(const string symbol, const bool isLong, const double price,
const double ask, const double bid)
{
if(price <= 0.0 || price == EMPTY_VALUE)
return(isLong ? ORDER_TYPE_BUY : ORDER_TYPE_SELL);
double stops = TCStopsLevel(symbol);
if(isLong)
{
if(price > ask + stops)
return(ORDER_TYPE_BUY_STOP);
if(price < ask - stops)
return(ORDER_TYPE_BUY_LIMIT);
return(ORDER_TYPE_BUY);
}
if(price > bid + stops)
return(ORDER_TYPE_SELL_LIMIT);
if(price < bid - stops)
return(ORDER_TYPE_SELL_STOP);
return(ORDER_TYPE_SELL);
}
//+------------------------------------------------------------------+
//| Article #14 - passing invalid parameters to functions. |
//| Every other check here reads symbol properties; if the symbol is |
//| not selected/known, those reads return zeros and each downstream |
//| rule silently degenerates into "always passes". Verify the symbol |
//| is real, selected, and currently open for the trade mode we need |
//| before trusting anything else. |
//+------------------------------------------------------------------+
bool TCSymbolIsTradeable(const string symbol, string &description)
{
if(symbol == "")
{
description = "empty symbol name";
return false;
}
if(!SymbolInfoInteger(symbol, SYMBOL_SELECT))
{
//--- a symbol absent from Market Watch has no live quote and no synced properties
if(!SymbolSelect(symbol, true))
{
description = "symbol " + symbol + " could not be selected in Market Watch";
return false;
}
}
ENUM_SYMBOL_TRADE_MODE mode = (ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(symbol, SYMBOL_TRADE_MODE);
if(mode == SYMBOL_TRADE_MODE_DISABLED)
{
description = "trading is disabled for " + symbol;
return false;
}
if(mode == SYMBOL_TRADE_MODE_CLOSEONLY)
{
description = "symbol " + symbol + " is close-only right now";
return false;
}
double bid = 0.0, ask = 0.0;
if(!TCLiveQuote(symbol, "trade it yet", bid, ask, description))
return false;
description = "";
return true;
}
//+------------------------------------------------------------------+
//| IS TRADING PERMITTED AT ALL - terminal, program, account, server. |
//| |
//| Five separate switches, any one of which stops an EA dead, and |
//| they fail in different places: |
//| TERMINAL_CONNECTED no server - every request times out |
//| TERMINAL_TRADE_ALLOWED the AlgoTrading button |
//| MQL_TRADE_ALLOWED this program's own checkbox |
//| ACCOUNT_TRADE_ALLOWED the BROKER disabled trading (an |
//| investor password lands here) |
//| ACCOUNT_TRADE_EXPERT the broker forbids EAs specifically |
//| |
//| This repo has already lost a session to the second one: the EA |
//| ran for days placing nothing because AlgoTrading was off, and |
//| nothing said so. Checked and REPORTED, never assumed. |
//+------------------------------------------------------------------+
bool TCTradingPermitted(string &description)
{
if(!TerminalInfoInteger(TERMINAL_CONNECTED))
{ description = "terminal is not connected to a trade server"; return false; }
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
{ description = "AlgoTrading is disabled in the terminal"; return false; }
if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
{ description = "trading is disabled for this program"; return false; }
if(!AccountInfoInteger(ACCOUNT_TRADE_ALLOWED))
{ description = "the broker has disabled trading on this account"; return false; }
if(!AccountInfoInteger(ACCOUNT_TRADE_EXPERT))
{ description = "the broker forbids expert advisors on this account"; return false; }
description = "";
return true;
}
//+------------------------------------------------------------------+
//| THE FILLING MODE THE SYMBOL WILL ACCEPT. |
//| |
//| SYMBOL_FILLING_MODE is a BIT MASK of what the symbol permits, and |
//| a request carrying an unsupported one is rejected outright with |
//| "Unsupported filling mode" - a run of zero trades that looks |
//| exactly like a strategy which never fired. Neither bit set means |
//| only ORDER_FILLING_RETURN is legal, which is the usual case on |
//| exchange-execution symbols and the one most often missed. |
//+------------------------------------------------------------------+
bool TCPickFilling(const string symbol, ENUM_ORDER_TYPE_FILLING &mode, string &description)
{
const long mask = SymbolInfoInteger(symbol, SYMBOL_FILLING_MODE);
//--- FOK first: it is the strictest and the least surprising. A partial fill the EA does not
//--- expect is a position of the wrong size, which every later R calculation then misstates.
if((mask & SYMBOL_FILLING_FOK) != 0)
mode = ORDER_FILLING_FOK;
else
if((mask & SYMBOL_FILLING_IOC) != 0)
mode = ORDER_FILLING_IOC;
else
mode = ORDER_FILLING_RETURN;
description = "";
return true;
}
//+------------------------------------------------------------------+
//| DOES THE SYMBOL ALLOW THIS ORDER TYPE, and stops attached to it? |
//| |
//| SYMBOL_ORDER_MODE is another bit mask. A symbol may permit market |
//| orders but not stops, or permit the order but not a stop loss on |
//| it - in which case the SL is rejected and the position opens |
//| NAKED. That is the dangerous one: the order succeeds and the |
//| protection silently does not. |
//+------------------------------------------------------------------+
bool TCOrderTypeAllowed(const string symbol, const ENUM_ORDER_TYPE type,
const bool withSL, const bool withTP, string &description)
{
const long mask = SymbolInfoInteger(symbol, SYMBOL_ORDER_MODE);
long need = 0;
switch(type)
{
case ORDER_TYPE_BUY:
case ORDER_TYPE_SELL: need = SYMBOL_ORDER_MARKET; break;
case ORDER_TYPE_BUY_LIMIT:
case ORDER_TYPE_SELL_LIMIT: need = SYMBOL_ORDER_LIMIT; break;
case ORDER_TYPE_BUY_STOP:
case ORDER_TYPE_SELL_STOP: need = SYMBOL_ORDER_STOP; break;
case ORDER_TYPE_BUY_STOP_LIMIT:
case ORDER_TYPE_SELL_STOP_LIMIT: need = SYMBOL_ORDER_STOP_LIMIT; break;
default:
description = "unsupported order type for " + symbol;
return false;
}
if((mask & need) == 0)
{
description = StringFormat("%s does not accept this order type (SYMBOL_ORDER_MODE %d)",
symbol, (int)mask);
return false;
}
if(withSL && (mask & SYMBOL_ORDER_SL) == 0)
{
description = symbol + " rejects a stop loss on the order - it would open unprotected";
return false;
}
if(withTP && (mask & SYMBOL_ORDER_TP) == 0)
{
description = symbol + " rejects a take profit on the order";
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Expiration modes the symbol accepts. Pending orders only. |
//+------------------------------------------------------------------+
bool TCExpirationAllowed(const string symbol, const ENUM_ORDER_TYPE_TIME mode, string &description)
{
const long mask = SymbolInfoInteger(symbol, SYMBOL_EXPIRATION_MODE);
long need = 0;
switch(mode)
{
case ORDER_TIME_GTC: need = SYMBOL_EXPIRATION_GTC; break;
case ORDER_TIME_DAY: need = SYMBOL_EXPIRATION_DAY; break;
case ORDER_TIME_SPECIFIED: need = SYMBOL_EXPIRATION_SPECIFIED; break;
case ORDER_TIME_SPECIFIED_DAY: need = SYMBOL_EXPIRATION_SPECIFIED_DAY; break;
default:
description = "unknown expiration mode";
return false;
}
if((mask & need) == 0)
{
description = StringFormat("%s rejects this expiration mode (SYMBOL_EXPIRATION_MODE %d)",
symbol, (int)mask);
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Hedging account? Netting changes what a second order DOES - it |
//| nets against the open position instead of adding one, so "sell |
//| while long" is a CLOSE on netting and a hedge on hedging. Logic |
//| that assumes one is wrong on the other. |
//+------------------------------------------------------------------+
bool TCIsHedging(void)
{
return ((ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE)
== ACCOUNT_MARGIN_MODE_RETAIL_HEDGING);
}
//+------------------------------------------------------------------+
//| WHAT TO DO WITH A RETCODE. Three outcomes, and conflating them is |
//| how an EA either hammers a dead server or gives up on a requote. |
//| >0 retry is sensible - transient (requote, price changed, busy) |
//| 0 accept - it worked, or there was nothing to do |
//| <0 do NOT retry - the request itself is wrong |
//+------------------------------------------------------------------+
int TCRetcodeAdvice(const uint retcode, string &description)
{
switch(retcode)
{
case TRADE_RETCODE_DONE:
case TRADE_RETCODE_DONE_PARTIAL:
case TRADE_RETCODE_PLACED:
case TRADE_RETCODE_NO_CHANGES:
description = "accepted";
return 0;
case TRADE_RETCODE_REQUOTE:
case TRADE_RETCODE_PRICE_CHANGED:
case TRADE_RETCODE_PRICE_OFF:
case TRADE_RETCODE_TIMEOUT:
case TRADE_RETCODE_CONNECTION:
case TRADE_RETCODE_TOO_MANY_REQUESTS:
case TRADE_RETCODE_SERVER_DISABLES_AT:
description = "transient - a retry is sensible";
return 1;
default:
description = StringFormat("permanent rejection (retcode %u) - the request is wrong",
retcode);
return -1;
}
}
//+------------------------------------------------------------------+
//| IS THE MARKET ACTUALLY OPEN FOR THIS SYMBOL, right now? |
//| |
//| SYMBOL_TRADE_MODE above catches a symbol that is disabled or |
//| close-only, which is a PROPERTY of the symbol. It does not catch |
//| the far more common case: the symbol is perfectly tradeable and |
//| the session is simply shut. The tester will still hand the EA a |
//| tick at 00:01 on a Monday before the session opens, the order |
//| goes out, and the server answers "Market closed" - measured on |
//| AUDUSD, four rejected entries in one run. |
//| |
//| A rejected order is not a harmless no-op. The signal that would |
//| have been traded is silently discarded, so the backtest is |
//| quietly measuring a DIFFERENT strategy from the one being |
//| described - one that skips whichever trades happen to land in a |
//| session gap, which is not a rule anybody chose. |
//| |
//| Sessions are per day-of-week and there may be several in a day |
//| (an index with a lunch break has two). A session whose end is at |
//| or before its start has wrapped past midnight. |
//+------------------------------------------------------------------+
bool TCMarketIsOpen(const string symbol, const datetime when, string &description)
{
MqlDateTime t;
TimeToStruct(when, t);
const ENUM_DAY_OF_WEEK dow = (ENUM_DAY_OF_WEEK)t.day_of_week;
const int now = t.hour * 3600 + t.min * 60 + t.sec;
datetime from = 0, to = 0;
for(int i = 0; i < 8; i++) // MT5 allows a handful of sessions per day
{
if(!SymbolInfoSessionTrade(symbol, dow, i, from, to))
break; // no more sessions defined for this day
const int s = (int)((long)from % 86400);
const int e = (int)((long)to % 86400);
const bool inside = (e > s) ? (now >= s && now < e) // ordinary session
: (now >= s || now < e); // wraps past midnight
if(inside)
{
description = "";
return true;
}
}
description = StringFormat("%s has no open trading session at %s", symbol,
TimeToString(when, TIME_DATE | TIME_MINUTES));
return false;
}
//+------------------------------------------------------------------+
//| Article #3 - invalid volumes in trade operations. |
//| Report-only form: states exactly why a volume is illegal without |
//| changing it, mirroring the article's CheckVolumeValue(). |
//+------------------------------------------------------------------+
bool TCCheckVolumeValue(const string symbol, const double volume, string &description)
{
if(!MathIsValidNumber(volume) || volume <= 0.0)
{
description = StringFormat("volume %.8f is not a valid positive number", volume);
return false;
}
double min_volume = TCVolumeMin(symbol);
if(volume < min_volume)
{
description = StringFormat("volume %.8f is below the minimum SYMBOL_VOLUME_MIN=%.8f", volume, min_volume);
return false;
}
double max_volume = TCVolumeMax(symbol);
if(max_volume > 0.0 && volume > max_volume)
{
description = StringFormat("volume %.8f exceeds the maximum SYMBOL_VOLUME_MAX=%.8f", volume, max_volume);
return false;
}
double step = TCVolumeStep(symbol);
if(step > 0.0)
{
//--- "volume must be a multiple of SYMBOL_VOLUME_STEP", compared with a tolerance so
//--- binary representation error in e.g. 0.07/0.01 is not mistaken for an off-step volume
double steps = MathRound(volume / step);
double residual = MathAbs(volume - steps * step);
if(residual > step * TC_VOLUME_EPSILON_FRAC)
{
description = StringFormat("volume %.8f is not a multiple of SYMBOL_VOLUME_STEP=%.8f", volume, step);
return false;
}
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #3, corrective form. Snaps `volume` onto the volume grid |
//| and into [min,max], then re-verifies the result with |
//| TCCheckVolumeValue() so a correction can never itself emit an |
//| illegal volume. |
//+------------------------------------------------------------------+
bool TCNormalizeVolume(const string symbol, double &volume, string &description)
{
if(!MathIsValidNumber(volume))
{
description = "volume is not a valid number";
return false;
}
double min_volume = TCVolumeMin(symbol);
double max_volume = TCVolumeMax(symbol);
double step = TCVolumeStep(symbol);
if(min_volume <= 0.0 || step <= 0.0)
{
description = "broker volume properties for " + symbol + " are not available yet (min/step are 0)";
return false;
}
//--- Snap DOWN to the grid: rounding up could exceed the free margin already verified upstream.
//--- The epsilon is not cosmetic - 0.03/0.01 evaluates to 2.9999999999999996 in binary floating
//--- point, so a bare MathFloor() would silently drop an already-legal volume a whole step.
double snapped = MathFloor(volume / step + TC_VOLUME_EPSILON_FRAC) * step;
if(snapped < min_volume)
snapped = min_volume;
if(max_volume > 0.0 && snapped > max_volume)
snapped = max_volume;
//--- kill the residue MathFloor leaves behind (0.1*3 = 0.30000000000000004) before it reaches OrderSend
int volume_digits = (int)MathMax(0.0, MathCeil(-MathLog10(step)));
snapped = NormalizeDouble(snapped, volume_digits);
if(!TCCheckVolumeValue(symbol, snapped, description))
return false;
volume = snapped;
return true;
}
//+------------------------------------------------------------------+
//| Article #2 - insufficient funds to perform a trade operation. |
//| Report-only form: the article's CheckMoneyForTrade() verbatim - |
//| compute the required margin with OrderCalcMargin() and compare it |
//| against ACCOUNT_MARGIN_FREE before ever calling OrderSend(). |
//+------------------------------------------------------------------+
bool TCCheckMoneyForTrade(const string symbol, const double lots, const ENUM_ORDER_TYPE type, string &description)
{
double price = SymbolInfoDouble(symbol, (type == ORDER_TYPE_BUY || type == ORDER_TYPE_BUY_LIMIT ||
type == ORDER_TYPE_BUY_STOP) ? SYMBOL_ASK : SYMBOL_BID);
if(price <= 0.0)
{
description = "no live quote for " + symbol + ", cannot evaluate margin";
return false;
}
double margin = 0.0;
if(!OrderCalcMargin(type, symbol, lots, price, margin))
{
description = StringFormat("OrderCalcMargin() failed for %s %.8f lots, error %d", symbol, lots, GetLastError());
return false;
}
double free_margin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
if(margin > free_margin)
{
description = StringFormat("not enough money: %.8f lots of %s needs %.2f margin, only %.2f free",
lots, symbol, margin, free_margin);
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #2, corrective form. Steps `lots` down one |
//| SYMBOL_VOLUME_ STEP at a time until the required margin fits |
//| inside the free margin, or reports failure once the minimum |
//| volume still does not fit. |
//+------------------------------------------------------------------+
bool TCFitVolumeToFreeMargin(const string symbol, double &lots, const ENUM_ORDER_TYPE type, string &description)
{
if(!TCNormalizeVolume(symbol, lots, description))
return false;
double step = TCVolumeStep(symbol);
double min_volume = TCVolumeMin(symbol);
//--- hard bound on the walk: it can never need more iterations than there are steps
//--- between the requested volume and the minimum, +1 for the final min test
int max_iterations = (int)MathCeil(TCSafeDivide(lots - min_volume, step, 0.0)) + 1;
for(int i = 0; i <= max_iterations; i++)
{
if(TCCheckMoneyForTrade(symbol, lots, type, description))
return true;
if(lots <= min_volume)
break;
lots -= step;
if(lots < min_volume)
lots = min_volume;
if(!TCNormalizeVolume(symbol, lots, description))
return false;
}
description = StringFormat("free margin cannot cover even the minimum %.8f lots of %s (%s)",
min_volume, symbol, description);
lots = 0.0;
return false;
}
//+------------------------------------------------------------------+
//| Article #4 - limiting the number of pending orders. |
//| ACCOUNT_LIMIT_ORDERS is the account's cap on simultaneously |
//| placed pending orders; 0 means "no limitation". |
//+------------------------------------------------------------------+
bool TCIsNewOrderAllowed(string &description)
{
int max_allowed = (int)AccountInfoInteger(ACCOUNT_LIMIT_ORDERS);
if(max_allowed == 0)
{
description = "";
return true; // no limitation on this account
}
int orders = OrdersTotal();
if(orders < max_allowed)
{
description = "";
return true;
}
description = StringFormat("account pending-order limit reached: %d of %d ACCOUNT_LIMIT_ORDERS in place",
orders, max_allowed);
return false;
}
//+------------------------------------------------------------------+
//| Article #5 - limiting the number of lots by a specific symbol. |
//| SYMBOL_VOLUME_LIMIT caps the AGGREGATE volume of open positions |
//| plus pending orders on one symbol in one direction. Returns the |
//| volume still available for `type`'s direction, or -1.0 when the |
//| broker imposes no limit at all. |
//+------------------------------------------------------------------+
double TCSymbolVolumeAllowed(const string symbol, const ENUM_ORDER_TYPE type)
{
double limit = SymbolInfoDouble(symbol, SYMBOL_VOLUME_LIMIT);
if(limit <= 0.0)
return(-1.0); // no limitation for this symbol
bool want_buy_side = (type == ORDER_TYPE_BUY || type == ORDER_TYPE_BUY_LIMIT || type == ORDER_TYPE_BUY_STOP);
double used = 0.0;
//--- open positions on this symbol, same side
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket == 0 || !PositionSelectByTicket(ticket))
continue;
if(PositionGetString(POSITION_SYMBOL) != symbol)
continue;
bool position_is_buy = ((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY);
if(position_is_buy == want_buy_side)
used += PositionGetDouble(POSITION_VOLUME);
}
//--- pending orders on this symbol, same side
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i);
if(ticket == 0)
continue;
if(OrderGetString(ORDER_SYMBOL) != symbol)
continue;
ENUM_ORDER_TYPE order_type = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
bool order_is_buy = (order_type == ORDER_TYPE_BUY || order_type == ORDER_TYPE_BUY_LIMIT ||
order_type == ORDER_TYPE_BUY_STOP);
if(order_is_buy == want_buy_side)
used += OrderGetDouble(ORDER_VOLUME_CURRENT);
}
double available = limit - used;
return (available > 0.0) ? available : 0.0;
}
//+------------------------------------------------------------------+
//| Article #5, corrective form. Trims `lots` down to whatever |
//| SYMBOL_VOLUME_LIMIT still allows in this direction, then |
//| re-normalizes onto the volume grid. Fails (lots = 0) when the |
//| remaining allowance cannot even cover SYMBOL_VOLUME_MIN. |
//+------------------------------------------------------------------+
bool TCApplySymbolVolumeLimit(const string symbol, double &lots, const ENUM_ORDER_TYPE type, string &description)
{
double available = TCSymbolVolumeAllowed(symbol, type);
if(available < 0.0)
{
description = "";
return true; // no SYMBOL_VOLUME_LIMIT on this symbol
}
if(available < TCVolumeMin(symbol))
{
description = StringFormat("SYMBOL_VOLUME_LIMIT for %s is exhausted in this direction (%.8f lots left, "
"minimum is %.8f)", symbol, available, TCVolumeMin(symbol));
lots = 0.0;
return false;
}
if(lots > available)
{
description = StringFormat("volume trimmed from %.8f to %.8f by SYMBOL_VOLUME_LIMIT on %s", lots, available, symbol);
lots = available;
string normalize_error;
if(!TCNormalizeVolume(symbol, lots, normalize_error))
{
description = normalize_error;
lots = 0.0;
return false;
}
return true;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #2/#3/#4/#5 combined gate. Everything a volume must clear |
//| before OrderSend(): a tradeable symbol, a legal volume on the |
//| grid, the per-symbol aggregate limit, and enough free margin. Call |
//| sites that size a lot only need this one function. |
//| `lots` is corrected in place and set to 0.0 on rejection. |
//+------------------------------------------------------------------+
bool TCValidateVolumeForTrade(const string symbol, double &lots, const ENUM_ORDER_TYPE type, string &description)
{
if(!TCSymbolIsTradeable(symbol, description))
{
lots = 0.0;
return false;
}
if(!TCNormalizeVolume(symbol, lots, description))
{
lots = 0.0;
return false;
}
double requested = lots;
if(!TCApplySymbolVolumeLimit(symbol, lots, type, description))
return false;
if(!TCFitVolumeToFreeMargin(symbol, lots, type, description))
return false;
//--- On success `description` is cleared by whichever check ran last, so any note left by an
//--- EARLIER corrective step (a SYMBOL_VOLUME_LIMIT trim, say) would be lost before the caller
//--- ever saw it. Report the net correction instead - that is the part a caller wants logged.
if(lots != requested)
description = StringFormat("volume corrected from %.8f to %.8f for %s %s",
requested, lots, symbol, EnumToString(type));
else
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #6 - TakeProfit and StopLoss within SYMBOL_TRADE_STOPS_ |
//| LEVEL. The article's rule is that both levels are measured |
//| against the price of the OPPOSITE operation - a long is closed |
//| at Bid, a short at Ask - and each must sit at least stops-level |
//| points away on the correct side. |
//+------------------------------------------------------------------+
bool TCCheckStops(const string symbol, const ENUM_ORDER_TYPE type, const double order_price,
const double sl, const double tp, string &description)
{
if(!MathIsValidNumber(order_price) || order_price < 0.0)
{
description = "order price is not a finite non-negative number";
return false;
}
if(sl != 0.0 && (!MathIsValidNumber(sl) || sl < 0.0))
{
description = "stop loss is not a finite non-negative number";
return false;
}
if(tp != 0.0 && (!MathIsValidNumber(tp) || tp < 0.0))
{
description = "take profit is not a finite non-negative number";
return false;
}
double stops = TCStopsLevel(symbol);
double bid = 0.0, ask = 0.0;
if(!TCLiveQuote(symbol, "validate stops", bid, ask, description))
return false;
bool is_buy_side = (type == ORDER_TYPE_BUY || type == ORDER_TYPE_BUY_LIMIT || type == ORDER_TYPE_BUY_STOP);
bool is_pending = (type != ORDER_TYPE_BUY && type != ORDER_TYPE_SELL);
//--- market orders: measure from the price the position would be CLOSED at (the opposite side).
//--- pending orders: measure from the order's own activation price.
double reference = is_pending ? order_price : (is_buy_side ? bid : ask);
if(is_pending && reference <= 0.0)
{
description = "pending order price is 0, cannot validate stops";
return false;
}
bool tp_too_close = (tp != 0.0) && (is_buy_side ? (tp - reference < stops) : (reference - tp < stops));
bool sl_too_close = (sl != 0.0) && (is_buy_side ? (reference - sl < stops) : (sl - reference < stops));
if(tp_too_close)
{
description = StringFormat("take profit %s is closer than the %s stops level to the %s reference price %s",
TCPrice(symbol, tp), TCPrice(symbol, stops),
EnumToString(type), TCPrice(symbol, reference));
return false;
}
if(sl_too_close)
{
description = StringFormat("stop loss %s is closer than the %s stops level to the %s reference price %s",
TCPrice(symbol, sl), TCPrice(symbol, stops),
EnumToString(type), TCPrice(symbol, reference));
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #6, corrective form. Pushes an SL/TP that violates the |
//| stops level out to exactly the minimum legal distance, keeping |
//| it on the correct side, and normalizes to the symbol's digits. |
//| Returns false only when the levels cannot be made legal at all |
//| (no quote, or a pending order with no price). |
//+------------------------------------------------------------------+
bool TCAdjustStops(const string symbol, const ENUM_ORDER_TYPE type, const double order_price,
double &sl, double &tp, string &description)
{
if(!MathIsValidNumber(order_price) || order_price < 0.0)
{
description = "order price is not a finite non-negative number";
return false;
}
if(sl != 0.0 && (!MathIsValidNumber(sl) || sl < 0.0))
{
description = "stop loss is not a finite non-negative number";
return false;
}
if(tp != 0.0 && (!MathIsValidNumber(tp) || tp < 0.0))
{
description = "take profit is not a finite non-negative number";
return false;
}
double stops = TCMinStopDistance(symbol);
double bid = 0.0, ask = 0.0;
if(!TCLiveQuote(symbol, "adjust stops", bid, ask, description))
return false;
int digits = TCDigits(symbol);
bool is_buy_side = (type == ORDER_TYPE_BUY || type == ORDER_TYPE_BUY_LIMIT || type == ORDER_TYPE_BUY_STOP);
bool is_pending = (type != ORDER_TYPE_BUY && type != ORDER_TYPE_SELL);
double reference = is_pending ? order_price : (is_buy_side ? bid : ask);
if(reference <= 0.0)
{
description = "reference price is 0, cannot adjust stops";
return false;
}
double original_sl = sl;
double original_tp = tp;
if(is_buy_side)
{
if(tp != 0.0 && tp - reference < stops)
tp = NormalizeDouble(reference + stops, digits);
if(sl != 0.0 && reference - sl < stops)
sl = NormalizeDouble(reference - stops, digits);
}
else
{
if(tp != 0.0 && reference - tp < stops)
tp = NormalizeDouble(reference - stops, digits);
if(sl != 0.0 && sl - reference < stops)
sl = NormalizeDouble(reference + stops, digits);
}
if(sl != original_sl || tp != original_tp)
description = StringFormat("stops widened to the %s broker minimum (%s): sl %s -> %s, tp %s -> %s",
symbol, TCPrice(symbol, stops),
DoubleToString(original_sl, digits), DoubleToString(sl, digits),
DoubleToString(original_tp, digits), DoubleToString(tp, digits));
else
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #6, pending-order price. A limit/stop order's own |
//| activation price must also sit at least stops-level points away |
//| from the current market, on the side its type implies. This is the |
//| check CExpertTrade::Buy()/Sell() applies when it decides between a |
//| market fill and a pending order; exposing it here lets a caller |
//| know IN ADVANCE which of the two it is about to get. |
//+------------------------------------------------------------------+
bool TCCheckPendingPrice(const string symbol, const ENUM_ORDER_TYPE type, const double price, string &description)
{
double stops = TCStopsLevel(symbol);
double bid = 0.0, ask = 0.0;
if(!TCLiveQuote(symbol, "check the stop distance", bid, ask, description))
return false;
bool ok = true;
switch(type)
{
case ORDER_TYPE_BUY_LIMIT:
ok = (ask - price >= stops);
break;
case ORDER_TYPE_BUY_STOP:
ok = (price - ask >= stops);
break;
case ORDER_TYPE_SELL_LIMIT:
ok = (price - bid >= stops);
break;
case ORDER_TYPE_SELL_STOP:
ok = (bid - price >= stops);
break;
default:
description = "";
return true; // market orders have no activation price to validate
}
if(!ok)
{
description = StringFormat("pending price %s for %s is inside the %s stops level (bid %s / ask %s)",
TCPrice(symbol, price), EnumToString(type), TCPrice(symbol, stops),
TCPrice(symbol, bid), TCPrice(symbol, ask));
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #7 - attempt to modify/close a POSITION inside |
//| SYMBOL_TRADE_FREEZE_LEVEL. While the market is within freeze- |
//| level points of a position's SL or TP, the server refuses to |
//| modify or close it, so the request must not be sent at all. |
//+------------------------------------------------------------------+
bool TCFreezeOkForPosition(const string symbol, const ENUM_POSITION_TYPE position_type,
const double sl, const double tp, string &description)
{
double freeze = TCFreezeLevel(symbol);
if(freeze <= 0.0)
{
description = "";
return true;
}
double bid = 0.0, ask = 0.0;
if(!TCLiveQuote(symbol, "evaluate the freeze level", bid, ask, description))
return false;
bool is_long = (position_type == POSITION_TYPE_BUY);
double reference = is_long ? bid : ask;
string side = is_long ? "long" : "short";
string ref_name = is_long ? "bid" : "ask";
if(tp != 0.0 && (is_long ? (tp - reference) : (reference - tp)) < freeze)
{
description = StringFormat("%s position on %s is frozen: take profit %s is within %s of %s %s",
side, symbol, TCPrice(symbol, tp), TCPrice(symbol, freeze),
ref_name, TCPrice(symbol, reference));
return false;
}
if(sl != 0.0 && (is_long ? (reference - sl) : (sl - reference)) < freeze)
{
description = StringFormat("%s position on %s is frozen: stop loss %s is within %s of %s %s",
side, symbol, TCPrice(symbol, sl), TCPrice(symbol, freeze),
ref_name, TCPrice(symbol, reference));
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #7 - attempt to modify/delete a PENDING ORDER inside |
//| SYMBOL_TRADE_FREEZE_LEVEL. |
//| |
//| BuyLimit: Ask - OpenPrice >= freeze |
//| BuyStop: OpenPrice - Ask >= freeze |
//| SellLimit: OpenPrice - Bid >= freeze |
//| SellStop: Bid - OpenPrice >= freeze |
//+------------------------------------------------------------------+
bool TCFreezeOkForOrder(const string symbol, const ENUM_ORDER_TYPE order_type,
const double open_price, string &description)
{
double freeze = TCFreezeLevel(symbol);
if(freeze <= 0.0)
{
description = "";
return true;
}
double bid = 0.0, ask = 0.0;
if(!TCLiveQuote(symbol, "evaluate the freeze level", bid, ask, description))
return false;
bool ok = true;
switch(order_type)
{
case ORDER_TYPE_BUY_LIMIT:
ok = (ask - open_price >= freeze);
break;
case ORDER_TYPE_BUY_STOP:
ok = (open_price - ask >= freeze);
break;
case ORDER_TYPE_SELL_LIMIT:
ok = (open_price - bid >= freeze);
break;
case ORDER_TYPE_SELL_STOP:
ok = (bid - open_price >= freeze);
break;
default:
description = "";
return true; // a filled market order is not a pending order
}
if(!ok)
{
description = StringFormat("%s on %s at %s is inside the %s freeze level (bid %s / ask %s)",
EnumToString(order_type), symbol, TCPrice(symbol, open_price),
TCPrice(symbol, freeze), TCPrice(symbol, bid), TCPrice(symbol, ask));
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #11 - sending modification requests without actual changes.|
//| "A trade request which does not make any changes is considered an |
//| error" (TRADE_RETCODE_NO_CHANGES=10025). Both helpers return true |
//| only when at least one parameter really differs, using one point |
//| as the comparison tolerance exactly as the article does. |
//+------------------------------------------------------------------+
bool TCPositionModifyIsMeaningful(const string symbol, const double current_sl, const double new_sl,
const double current_tp, const double new_tp)
{
double point = TCPoint(symbol);
if(MathAbs(current_sl - new_sl) > point)
return true;
if(MathAbs(current_tp - new_tp) > point)
return true;
return false;
}
bool TCOrderModifyIsMeaningful(const string symbol, const double current_price, const double new_price,
const double current_sl, const double new_sl,
const double current_tp, const double new_tp)
{
double point = TCPoint(symbol);
if(MathAbs(current_price - new_price) > point)
return true;
if(MathAbs(current_sl - new_sl) > point)
return true;
if(MathAbs(current_tp - new_tp) > point)
return true;
return false;
}
//+------------------------------------------------------------------+
//| Article #8 - errors caused by insufficient quote history. The |
//| article's "correct" approach: check that the required depth is |
//| actually there, and REQUEST the missing data instead of assuming |
//| it is already loaded. |
//+------------------------------------------------------------------+
bool TCHasEnoughHistory(const string symbol, const ENUM_TIMEFRAMES timeframe,
const int required_bars, string &description)
{
if(required_bars <= 0)
{
description = "";
return true;
}
if(MQLInfoInteger(MQL_TESTER))
{
description = "";
return true;
}
//--- SERIES_SYNCHRONIZED is the terminal's own "this series is fully built" flag; a series that
//--- reports enough bars while still syncing can still hand back gaps to iHighest/CopyBuffer
if(!SeriesInfoInteger(symbol, timeframe, SERIES_SYNCHRONIZED))
{
description = StringFormat("%s %s series is still synchronising", symbol, EnumToString(timeframe));
//--- touching the series is what asks the terminal to build it
datetime probe[];
CopyTime(symbol, timeframe, 0, 1, probe);
return false;
}
int bars = Bars(symbol, timeframe);
if(bars < required_bars)
{
description = StringFormat("only %d bars of %s %s history available, %d required",
bars, symbol, EnumToString(timeframe), required_bars);
datetime probe[];
CopyTime(symbol, timeframe, 0, required_bars, probe);
return false;
}
description = "";
return true;
}
//+------------------------------------------------------------------+
//| Article #16 - consumption of CPU resources and memory. |
//| TCWarnIfSlow() is the article's GetMicrosecondCount() measurement |
//| turned into a guard rail: pass the timestamp taken before the |
//| section and a budget, and it reports (throttled) whenever the |
//| section overruns. The article's own yardstick is that a first |
//| calculation over 10+ years of M1 data should stay under 100 ms. |
//+------------------------------------------------------------------+
ulong TCNow(void)
{
return GetMicrosecondCount();
}
bool TCWarnIfSlow(const string label, const ulong started_us, const ulong budget_us)
{
ulong elapsed = GetMicrosecondCount() - started_us;
if(elapsed <= budget_us)
return true;
TCLog("slow:" + label,
StringFormat("PERFORMANCE: %s took %.1f ms (budget %.1f ms) - see article 2555 #16; "
"profile it in MetaEditor if this persists",
label, elapsed / 1000.0, budget_us / 1000.0));
return false;
}
//--- MQL_MEMORY_USED is reported in megabytes
int TCMemoryUsedMb(void)
{
return((int)MQLInfoInteger(MQL_MEMORY_USED));
}
bool TCWarnIfMemoryAbove(const int limit_mb)
{
int used = TCMemoryUsedMb();
if(used <= limit_mb)
return true;
TCLog("memory",
StringFormat("MEMORY: the EA is holding %d MB (soft limit %d MB) - see article 2555 #16", used, limit_mb));
return false;
}
//+------------------------------------------------------------------+
//| THE ONE GATE. Every entry runs the whole checklist, in order. |
//| |
//| WHY THIS EXISTS AS A SINGLE FUNCTION. Every rule below was |
//| already implemented in this file and NONE of them were called -
//| the entry path reached the broker with nothing between it and the
//| server but hope. Coverage that lives in uncalled functions is not
//| coverage, it is documentation, and it reads identically in a code
//| review. One gate on the one path means a rule cannot be added and
//| then quietly not used.
//| |
//| ORDER MATTERS. Cheap and global first (permissions, connection), |
//| then per-symbol, then per-request, then the arithmetic that needs |
//| a live quote. The first refusal wins and names itself, so the log |
//| says WHICH rule declined rather than that something did. |
//| |
//| `lots` and the stops are IN/OUT: this normalises rather than |
//| merely judging, because a volume off its step and a stop inside |
//| the freeze level are both fixable and both fatal if sent as-is. |
//+------------------------------------------------------------------+
bool TCCanOpen(const string symbol, const ENUM_ORDER_TYPE type, double &lots,
const double price, double &sl, double &tp, string &description)
{
//--- 1. Is trading possible at all - terminal, program, account, server.
if(!TCTradingPermitted(description))
return false;
//--- 2. Is the symbol tradeable, selected, and quoting.
if(!TCSymbolIsTradeable(symbol, description))
return false;
//--- 3. Is the session actually open. A closed market rejects at the server and the firing is
//--- lost, so the run silently measures a strategy that skips session gaps.
if(!TCMarketIsOpen(symbol, TimeCurrent(), description))
return false;
//--- 4. Does the symbol accept this order type, and a stop/target attached to it. Rejecting the
//--- SL while accepting the order is the one failure that opens an UNPROTECTED position.
if(!TCOrderTypeAllowed(symbol, type, sl != 0.0, tp != 0.0, description))
return false;
//--- 5. Volume: legal, on-step, inside the symbol's and the account's limits.
if(!TCValidateVolumeForTrade(symbol, lots, type, description))
return false;
//--- 6. Is another order allowed - account order/position limits.
if(!TCIsNewOrderAllowed(description))
return false;
//--- 7. Money. Last of the request checks because it is the most expensive.
if(!TCCheckMoneyForTrade(symbol, lots, type, description))
return false;
//--- 8. Stops outside the broker's minimum distance and freeze band. Adjusted, not just judged -
//--- a stop a few points inside the level is a legal trade with an illegal request.
if(!TCAdjustStops(symbol, type, price, sl, tp, description))
return false;
description = "";
return true;
}
#endif // WARRIOR_TRADECHECKS_MQH
//+------------------------------------------------------------------+
View git blameCopy permalink