forked from animatedread/Warrior_EA
9d60289f9f
BLUEPRINT.md reviews the feature/label layers and designs fractional differencing, Garman-Klass / Yang-Zhang targets and a 48-72h expansion label; mql5_patches/ holds the MQL5 side (FFD safe past the 1024-bar series ceiling, vol estimators, the label + veto gate, NY-time swap window). premise_test.py measured the premise on real broker bars: the headline AUC 0.75 was a day-of-week / path-length artifact (a Friday-clipped path is shorter, so it touches K*ATR less). Honest residual 0.56-0.62, mostly within noise once overlap is deflated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
282 lines
12 KiB
MQL5
282 lines
12 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| SwapWindow.mqh |
|
|
//| Intra-week CFD operations: Friday liquidation + triple-swap gate|
|
|
//+------------------------------------------------------------------+
|
|
//| THIS MODULE FIXES TWO DEFECTS IN THE EXISTING SCHEDULED CLOSE |
|
|
//| (CExpertCustom::OnTick, ExpertCustom.mqh ~line 878). |
|
|
//| |
|
|
//| DEFECT 1 - THE CLOSE IS A +-1 MINUTE TICK LOTTERY. |
|
|
//| The current test is |
|
|
//| MathAbs(nowMinOfDay - targetMinOfDay) <= 1 |
|
|
//| evaluated inside OnTick. It fires only if a TICK ARRIVES in that |
|
|
//| two-minute window. On a Friday CFD close - thin book, and on |
|
|
//| indices the session shutting - that is exactly when ticks stop. |
|
|
//| Miss the window and the position is carried over the weekend, |
|
|
//| which is the one outcome the rule exists to prevent. This is the |
|
|
//| same class of failure already recorded for the session-aware bar |
|
|
//| clock: work scheduled on a tick that never comes. |
|
|
//| FIX: a LATCH. Fire on the first tick at-or-after the deadline, |
|
|
//| once per week, and keep firing until flat rather than assuming |
|
|
//| one attempt succeeded. |
|
|
//| |
|
|
//| DEFECT 2 - BROKER SERVER TIME IS NOT NEW YORK TIME. |
|
|
//| TimeCurrent() is broker server time (commonly EET/GMT+2/+3). The |
|
|
//| triple-swap rollover is defined at 17:00 NEW YORK. EU and US DST |
|
|
//| switch on DIFFERENT dates, so the offset between the two is not |
|
|
//| constant - there are two ~3-week windows each year where any |
|
|
//| hardcoded server-hour constant is off by one hour. Deriving from |
|
|
//| TimeGMT() and applying US DST rules is offset-stable. |
|
|
//| |
|
|
//| AND ONE ASSUMPTION NOT TO MAKE: the triple-swap day is NOT always |
|
|
//| Wednesday. It is per-symbol and the broker publishes it as |
|
|
//| SYMBOL_SWAP_ROLLOVER3DAYS. Several index and metal CFDs bill on |
|
|
//| Friday. Read it; never hardcode Wednesday. |
|
|
//+------------------------------------------------------------------+
|
|
#ifndef SWAPWINDOW_MQH
|
|
#define SWAPWINDOW_MQH
|
|
|
|
//--- 17:00 New York, the standard CFD rollover instant
|
|
#define SW_ROLLOVER_HOUR_NY 17
|
|
#define SW_SECONDS_PER_HOUR 3600
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| US DST: second Sunday of March 02:00 -> first Sunday of November. |
|
|
//| Returns the UTC offset in seconds (-5h EST / -4h EDT). |
|
|
//| |
|
|
//| Computed from the date, not from TimeGMTOffset(): in the strategy |
|
|
//| tester the terminal's own offset reporting follows the BROKER, so |
|
|
//| using it here would reintroduce defect 2. |
|
|
//+------------------------------------------------------------------+
|
|
int SWNewYorkUtcOffset(const datetime utc)
|
|
{
|
|
MqlDateTime t;
|
|
TimeToStruct(utc, t);
|
|
//--- day_of_week of the 1st of the month, from the given date
|
|
int dowFirst = (int)(t.day_of_week - ((t.day - 1) % 7) + 7) % 7;
|
|
//--- second Sunday of March
|
|
int firstSun = 1 + ((7 - dowFirst) % 7);
|
|
if(t.mon == 3)
|
|
{
|
|
int secondSun = firstSun + 7;
|
|
if(t.day > secondSun || (t.day == secondSun && t.hour >= 7)) // 02:00 EST = 07:00 UTC
|
|
return -4 * SW_SECONDS_PER_HOUR;
|
|
return -5 * SW_SECONDS_PER_HOUR;
|
|
}
|
|
if(t.mon == 11)
|
|
{
|
|
if(t.day > firstSun || (t.day == firstSun && t.hour >= 6)) // 02:00 EDT = 06:00 UTC
|
|
return -5 * SW_SECONDS_PER_HOUR;
|
|
return -4 * SW_SECONDS_PER_HOUR;
|
|
}
|
|
if(t.mon > 3 && t.mon < 11)
|
|
return -4 * SW_SECONDS_PER_HOUR;
|
|
return -5 * SW_SECONDS_PER_HOUR;
|
|
}
|
|
|
|
//--- New York wall-clock time for a given UTC instant.
|
|
datetime SWNewYorkTime(const datetime utc)
|
|
{
|
|
return utc + SWNewYorkUtcOffset(utc);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| The symbol's OWN triple-swap day, as the broker publishes it. |
|
|
//| Falls back to Wednesday only when the symbol reports nothing. |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_DAY_OF_WEEK SWTripleSwapDay(const string symbol)
|
|
{
|
|
long day = 0;
|
|
if(!SymbolInfoInteger(symbol, SYMBOL_SWAP_ROLLOVER3DAYS, day))
|
|
return WEDNESDAY;
|
|
if(day < 0 || day > 6)
|
|
return WEDNESDAY;
|
|
return (ENUM_DAY_OF_WEEK)day;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Are we inside the `windowMinutes` run-up to this symbol's triple- |
|
|
//| swap rollover? |
|
|
//+------------------------------------------------------------------+
|
|
bool SWInTripleSwapWindow(const string symbol, const int windowMinutes = 120)
|
|
{
|
|
datetime utc = TimeGMT();
|
|
datetime ny = SWNewYorkTime(utc);
|
|
MqlDateTime n;
|
|
TimeToStruct(ny, n);
|
|
if((ENUM_DAY_OF_WEEK)n.day_of_week != SWTripleSwapDay(symbol))
|
|
return false;
|
|
int nowMin = n.hour * 60 + n.min;
|
|
int rolloverMin = SW_ROLLOVER_HOUR_NY * 60;
|
|
return (nowMin >= rolloverMin - windowMinutes && nowMin < rolloverMin);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| SWAP DRAG, in ACCOUNT CURRENCY, for holding `lots` across the |
|
|
//| triple-swap rollover. |
|
|
//| |
|
|
//| Returns false when the symbol's swap mode is one this cannot price |
|
|
//| exactly. A false here must BLOCK the override (fall back to the |
|
|
//| plain volatility gate) - never be treated as "drag = 0", which |
|
|
//| would silently wave through the trades this rule exists to stop. |
|
|
//+------------------------------------------------------------------+
|
|
bool SWTripleSwapCost(const string symbol, const bool isLong, const double lots,
|
|
double &cost)
|
|
{
|
|
double rate = isLong ? SymbolInfoDouble(symbol, SYMBOL_SWAP_LONG)
|
|
: SymbolInfoDouble(symbol, SYMBOL_SWAP_SHORT);
|
|
if(!MathIsValidNumber(rate) || lots <= 0.0)
|
|
return false;
|
|
long mode = SymbolInfoInteger(symbol, SYMBOL_SWAP_MODE);
|
|
double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
|
|
double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
double price = SymbolInfoDouble(symbol, SYMBOL_BID);
|
|
double contract = SymbolInfoDouble(symbol, SYMBOL_TRADE_CONTRACT_SIZE);
|
|
|
|
double oneDay = 0.0;
|
|
switch((int)mode)
|
|
{
|
|
case SYMBOL_SWAP_MODE_POINTS:
|
|
if(tickSize <= 0.0 || tickValue <= 0.0 || point <= 0.0)
|
|
return false;
|
|
oneDay = rate * point * (tickValue / tickSize) * lots;
|
|
break;
|
|
case SYMBOL_SWAP_MODE_CURRENCY_SYMBOL:
|
|
case SYMBOL_SWAP_MODE_CURRENCY_MARGIN:
|
|
case SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT:
|
|
//--- already money per lot; currency conversion for the first two is
|
|
//--- the broker's, and assuming parity here would be a fabrication.
|
|
oneDay = rate * lots;
|
|
break;
|
|
case SYMBOL_SWAP_MODE_INTEREST_CURRENT:
|
|
case SYMBOL_SWAP_MODE_INTEREST_OPEN:
|
|
if(price <= 0.0 || contract <= 0.0)
|
|
return false;
|
|
oneDay = (rate / 100.0) * price * contract * lots / 360.0;
|
|
break;
|
|
default:
|
|
return false; // unpriceable - caller must not override
|
|
}
|
|
//--- Triple charge. Sign convention is the broker's: a POSITIVE swap is a
|
|
//--- credit, so drag is the negative part. Report drag as a positive cost.
|
|
cost = -3.0 * oneDay;
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| THE GATE. Should this trade be blocked ahead of the triple swap? |
|
|
//| |
|
|
//| Blocks unless the expected expansion pays for the carry by a real |
|
|
//| margin. `expectedMoveAtr` is the meta-label's forecast expansion |
|
|
//| in ATR units; `atrPrice` is ATR in price units. |
|
|
//+------------------------------------------------------------------+
|
|
bool SWBlockedByTripleSwap(const string symbol, const bool isLong, const double lots,
|
|
const double expectedMoveAtr, const double atrPrice,
|
|
const double overrideMultiple, string &why,
|
|
const int windowMinutes = 120)
|
|
{
|
|
if(!SWInTripleSwapWindow(symbol, windowMinutes))
|
|
return false;
|
|
|
|
double drag = 0.0;
|
|
if(!SWTripleSwapCost(symbol, isLong, lots, drag))
|
|
{
|
|
why = "triple-swap window and swap cost is unpriceable on this symbol - blocked";
|
|
return true; // refuse, never assume zero
|
|
}
|
|
if(drag <= 0.0)
|
|
{
|
|
why = "triple-swap window but the carry is a credit - allowed";
|
|
return false;
|
|
}
|
|
|
|
double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
|
|
double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
if(tickSize <= 0.0 || tickValue <= 0.0 || atrPrice <= 0.0 || expectedMoveAtr <= 0.0)
|
|
{
|
|
why = "triple-swap window and the expected move cannot be valued - blocked";
|
|
return true;
|
|
}
|
|
double expectedValue = expectedMoveAtr * atrPrice * (tickValue / tickSize) * lots;
|
|
|
|
if(expectedValue >= overrideMultiple * drag)
|
|
{
|
|
why = StringFormat("triple-swap override: expected %.2f >= %.1f x drag %.2f",
|
|
expectedValue, overrideMultiple, drag);
|
|
return false;
|
|
}
|
|
why = StringFormat("blocked: expected %.2f < %.1f x triple-swap drag %.2f",
|
|
expectedValue, overrideMultiple, drag);
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| CWeeklyFlatLatch - the Friday liquidation, as a latch. |
|
|
//| |
|
|
//| Deliberately NOT a +-N minute window. Once the deadline passes the |
|
|
//| latch stays armed until the book is actually flat, so a missing |
|
|
//| tick delays the close instead of cancelling it. |
|
|
//+------------------------------------------------------------------+
|
|
class CWeeklyFlatLatch
|
|
{
|
|
private:
|
|
int m_armedWeek; // year*100 + ISO week, -1 = idle
|
|
int m_attempts;
|
|
|
|
int WeekKey(const datetime t) const
|
|
{
|
|
MqlDateTime d;
|
|
TimeToStruct(t, d);
|
|
return d.year * 100 + (d.day_of_year / 7);
|
|
}
|
|
|
|
public:
|
|
CWeeklyFlatLatch(void) : m_armedWeek(-1), m_attempts(0) { }
|
|
|
|
//+---------------------------------------------------------------+
|
|
//| True when the weekly flat deadline has passed and we are not |
|
|
//| yet flat. Call from OnTick AND OnTimer - the timer is what |
|
|
//| covers the case ticks have stopped entirely. |
|
|
//| |
|
|
//| `deadlineNy` is minutes-of-day in NEW YORK time on `flatDay`. |
|
|
//+---------------------------------------------------------------+
|
|
bool ShouldLiquidate(const ENUM_DAY_OF_WEEK flatDay, const int deadlineNyMin)
|
|
{
|
|
datetime utc = TimeGMT();
|
|
datetime ny = SWNewYorkTime(utc);
|
|
MqlDateTime n;
|
|
TimeToStruct(ny, n);
|
|
int key = WeekKey(ny);
|
|
|
|
if(m_armedWeek == key)
|
|
return true; // still armed: last attempt left something open
|
|
|
|
if((ENUM_DAY_OF_WEEK)n.day_of_week != flatDay)
|
|
return false;
|
|
int nowMin = n.hour * 60 + n.min;
|
|
//--- AT OR AFTER, not "within a minute of".
|
|
if(nowMin < deadlineNyMin)
|
|
return false;
|
|
m_armedWeek = key;
|
|
m_attempts = 0;
|
|
return true;
|
|
}
|
|
|
|
//--- Called after a liquidation attempt; disarm only once truly flat.
|
|
void ReportResult(const bool flat)
|
|
{
|
|
m_attempts++;
|
|
if(flat)
|
|
{
|
|
m_armedWeek = -1;
|
|
m_attempts = 0;
|
|
}
|
|
else
|
|
if(m_attempts % 20 == 0)
|
|
Print(__FUNCTION__ + ": weekly flat latch still armed after " +
|
|
IntegerToString(m_attempts) + " attempts - positions remain open");
|
|
}
|
|
|
|
bool Armed(void) const { return m_armedWeek != -1; }
|
|
};
|
|
#endif // SWAPWINDOW_MQH
|