Candle_Pressure_Gold_Silver_EA/Candle_Pressure_Gold_Silver_EA.mq5
2572 Zeilen
106 KiB
MQL5
//+------------------------------------------------------------------+
//| Candle_Pressure_Gold_Silver_EA.mq5 |
//| Candlestick pressure + market context trading system |
//| Target instruments: XAU (gold) and XAG (silver) |
//+------------------------------------------------------------------+
#property copyright "Candle Pressure EA - refactored from Quantum Gold & Silver Trader"
#property link "https://forge.mql5.io"
#property version "1.00"
#property description "Reads candlestick pressure (body, wick, close position) and only acts when price sits in a valid context:"
#property description "higher timeframe pressure, break of structure, premium/discount, liquidity sweep, order block or fair value gap."
#property description "Hard equity rules: 5 percent daily loss cap, 8 percent static drawdown cap from balance, 10 percent equity growth target."
#include <Trade\Trade.mqh>
//+------------------------------------------------------------------+
//| Inputs |
//+------------------------------------------------------------------+
input group "=== Identity ==="
input long InpMagicNumber = 20261102; // Magic number
input string InpTradeComment = "CandlePressure"; // Order comment
input bool InpShowDashboard = true; // Show on-chart status
input group "=== Timeframes and bias ==="
input ENUM_TIMEFRAMES InpWorkTimeframe = PERIOD_M30; // Signal timeframe
input ENUM_TIMEFRAMES InpHtfTimeframe = PERIOD_H4; // Higher timeframe for bias
input int InpHtfEmaPeriod = 50; // Higher timeframe EMA period
input bool InpRequireHtfBias = true; // Require higher timeframe alignment
input group "=== Candle pressure ==="
input double InpRejectionWickRatio = 0.55; // Rejection: minimum wick share of range
input double InpRejectionMaxBody = 0.35; // Rejection: maximum body share of range
input double InpRejectionClosePos = 0.60; // Rejection: required close position in range
input double InpDominantBodyRatio = 0.60; // Dominant body share of range
input group "=== Market context ==="
input bool InpRequireBos = false; // Require break of structure
input int InpSwingLookback = 12; // Swing reference lookback (bars)
input int InpBosConfirmBars = 2; // Bars allowed to print the break
input bool InpRequireDiscountPremium = true; // Discount for buys, premium for sells
input int InpRangeLookback = 60; // Dealing range lookback (bars)
input double InpEquilibriumTolerance = 0.05; // Equilibrium tolerance (share of range)
input bool InpRequireLiquiditySweep = false; // Require a liquidity sweep
input int InpSweepLookback = 6; // Sweep detection window (bars)
input int InpSweepDepth = 20; // Swing depth used as sweep reference
input bool InpRequireZoneTouch = true; // Require order block or FVG touch
input int InpZoneLookback = 30; // Zone search lookback (bars)
input double InpZoneToleranceATR = 0.35; // Zone tolerance in ATR
input double InpDisplacementATR = 1.10; // Displacement body in ATR (order blocks)
input group "=== Signal quality ==="
input double InpMinSignalScore = 0.50; // Minimum signal score (0.10 - 1.00)
input int InpMinBarsBetweenTrades = 2; // Minimum bars between entries
input bool InpUseAdxFilter = true; // Use ADX trend-strength filter
input int InpAdxPeriod = 14; // ADX period
input double InpAdxMinLevel = 18.0; // Minimum ADX value
input int InpAtrPeriod = 14; // ATR period
input group "=== Position sizing ==="
input double InpRiskPercentMin = 0.50; // Minimum risk per trade (% of balance)
input double InpRiskPercentMax = 1.20; // Maximum risk per trade (% of balance)
input int InpMaxOpenPositions = 1; // Maximum simultaneous positions
input double InpStopAtrMultiplier = 1.60; // Minimum stop distance in ATR
input double InpStopBufferATR = 0.20; // Stop buffer beyond candle extreme (ATR)
input double InpRewardRiskRatio = 2.50; // Reward to risk ratio
input double InpMaxSpreadPoints = 80.0; // Maximum allowed spread (points)
input bool InpAllowMinLotOverride = false; // Allow the broker minimum volume even when it exceeds the risk budget
input double InpMaxLotAbsolute = 5.00; // Hard cap on volume per order in lots (0 = disabled)
input group "=== Hard equity limits ==="
input double InpDailyMaxLossPercent = 5.0; // Daily maximum loss (% of day-start equity)
input double InpStaticMaxDdPercent = 8.0; // Static maximum drawdown (% of initial balance)
input double InpEquityGrowthTargetPct = 10.0; // Equity growth target (% of initial balance)
input bool InpCloseOnDailyLimit = true; // Close positions when daily limit is hit
input bool InpCloseOnStaticDd = true; // Close positions when static limit is hit
input bool InpStopEaOnStaticDd = false; // Detach the EA after the static limit (not recommended: it disables the month)
input bool InpCloseOnTarget = true; // Close positions when growth target is reached
input bool InpResetRiskState = false; // One-shot: authorise risk period provisioning (never implicit)
input bool InpTesterPersistState = false; // Keep risk state across Strategy Tester runs (breaks run isolation)
input group "=== Risk state identity ==="
input string InpRiskScopeId = "MAIN"; // Risk scope id: the account level risk ledger
input string InpRiskPeriodId = "P01"; // Risk period id: change only with explicit authorisation
input group "=== Trade management ==="
input bool InpUseBreakeven = false; // Enable breakeven
input double InpBreakevenTriggerATR = 1.00; // Breakeven trigger distance in ATR
input double InpBreakevenOffsetPts = 20.0; // Breakeven offset in points
input bool InpUseAtrTrailing = false; // Enable ATR trailing stop
input double InpTrailAtrMultiplier = 2.00; // Trailing distance in ATR
input double InpTrailStepPoints = 50.0; // Minimum trailing step (points)
input group "=== Instrument profiles ==="
input bool InpUseGoldProfile = true; // Use gold profile on XAU symbols
input double InpGoldStopAtrMult = 1.60; // Gold: stop distance in ATR
input double InpGoldRewardRisk = 2.50; // Gold: reward to risk ratio
input int InpGoldRangeLookback = 60; // Gold: dealing range lookback (bars)
input bool InpUseSilverProfile = true; // Use silver profile on XAG symbols
input double InpSilverStopAtrMult = 2.20; // Silver: stop distance in ATR
input double InpSilverRewardRisk = 2.50; // Silver: reward to risk ratio
input int InpSilverRangeLookback = 70; // Silver: dealing range lookback (bars)
//+------------------------------------------------------------------+
//| Data structures |
//+------------------------------------------------------------------+
struct SCandle
{
datetime time;
double open;
double high;
double low;
double close;
double range;
double body;
double upperWick;
double lowerWick;
double bodyRatio;
double upperWickRatio;
double lowerWickRatio;
double closePosition; // 0.0 = close at low, 1.0 = close at high
bool bullish;
bool valid;
};
//+------------------------------------------------------------------+
//| Global state |
//+------------------------------------------------------------------+
CTrade g_trade;
int g_htfEmaHandle = INVALID_HANDLE;
int g_atrHandle = INVALID_HANDLE;
int g_adxHandle = INVALID_HANDLE;
// Effective parameters after the instrument profile is resolved
double g_stopAtrMultiplier = 1.60;
double g_rewardRiskRatio = 2.00;
int g_rangeLookback = 60;
int g_historyBars = 200;
bool g_isGold = false;
bool g_isSilver = false;
// Symbol geometry
int g_digits = 2;
double g_point = 0.01;
double g_tickSize = 0.01;
double g_volumeMin = 0.01;
double g_volumeMax = 100.0;
double g_volumeStep = 0.01;
int g_stopsLevel = 0;
int g_freezeLevel = 0;
//+------------------------------------------------------------------+
//| Persistent risk state (R-01 v1.2) |
//| The FILE_COMMON archive is authoritative. Global Variables are a |
//| cache/coordination mirror only, because the terminal expires |
//| unused global variables after four weeks. Losing or corrupting |
//| the archive is a hard stop, never a licence to rebuild a baseline.|
//| |
//| R01-H3: the archive is stored in two slots (A and B). A write |
//| always targets the slot that does NOT hold the newest valid |
//| record, so the last good archive is never sacrificed. |
//| R01-H8: recovery reads both slots, keeps the highest valid |
//| sequence and resolves ties deterministically towards slot A. |
//| The struct holds no strings so it stays a POD for FileWriteStruct.|
//+------------------------------------------------------------------+
#define CP_STATE_MAGIC 0x43504753
#define CP_STATE_VERSION 103
#define CP_SLOT_A 0
#define CP_SLOT_B 1
#define CP_REC_NONE 0 // no recoverable archive for this identity
#define CP_REC_RESTORED 1 // highest valid slot restored
#define CP_REC_MISMATCH 2 // archive exists but belongs to another identity
//+------------------------------------------------------------------+
//| Persistent provisioning acknowledgement (R-01 v1.2) |
//| The marker is the local proof that the one-shot provisioning |
//| authorization of ONE risk period was consumed. Its identity is |
//| login|server|risk_scope_id|risk_period_id, so it survives a |
//| symbol, magic or timeframe change and it is never removed by |
//| archive recovery. It freezes the initial baseline, so an |
//| interrupted provisioning resumes from that snapshot instead of |
//| re-baselining on the live balance. |
//| Documented limit: deleting the marker AND both archive slots |
//| destroys every piece of local evidence. A local store cannot |
//| detect that and must not claim to. |
//+------------------------------------------------------------------+
#define CP_PROV_MAGIC 0x43505052 // 'CPPR' marker schema marker
#define CP_PROV_VERSION 100
#define CP_PSTAT_NONE 0
#define CP_PSTAT_PROVISIONING 1 // authorization consumed, provisioning unfinished
#define CP_PSTAT_PROVISIONED 2 // archives verified, provisioning complete
#define CP_MARK_NONE 0 // no marker file for this risk period
#define CP_MARK_PROVISIONING 1
#define CP_MARK_PROVISIONED 2
#define CP_MARK_CORRUPT 3
#define CP_INIT_RESTORED 0
#define CP_INIT_PROVISIONED 1
#define CP_INIT_DENIED 2
#define CP_INIT_FAILED 3
struct SProvisionMarker
{
uint magic; // schema marker
uint version; // marker schema version
ulong identity; // login|server|scope|period
long login;
ulong server_hash;
ulong scope_hash;
ulong period_hash;
ulong prov_id; // unique provisioning identifier
int status; // CP_PSTAT_PROVISIONING / CP_PSTAT_PROVISIONED
double b_init; // frozen initial balance
double e_init; // frozen initial equity
long day_id; // day id of the frozen snapshot
double e_day0; // daily equity anchor of the frozen snapshot
double cfg_fingerprint;
long provision_time;
ulong checksum;
int valid;
};
struct SRiskState
{
uint magic; // schema marker
uint version; // schema version
ulong seq; // monotonic sequence, one step per durable write
int slot; // slot that produced this record (diagnostic)
ulong identity; // composite hash of the identity components below
long login; // R01-H4: account login
ulong server_hash; // R01-H4: trade server
ulong scope_hash; // R01-H4: risk scope id
ulong period_hash; // R01-H4: risk period id
double b_init; // frozen initial BALANCE (static DD and target)
double e_init; // initial EQUITY (record only)
long day_id; // YYYYMMDD of the daily anchor
double e_day0; // equity at the start of the server day
int daily_halt;
int static_halt;
int target_triggered; // realised balance touched the goal
int target_secured; // flat and still above the goal
double cfg_fingerprint; // hash of the risk inputs
long provision_time; // time of the authorised provisioning
ulong checksum;
int valid;
};
SRiskState g_state;
bool g_riskStateValid = false;
bool g_stateStorageFault = false; // R01-H1/H2: a save that is not durable blocks entries
int g_stateSlot = CP_SLOT_A; // slot holding the newest durable record
bool g_stateSlotKnown = false; // false until a durable record exists
// Bookkeeping
datetime g_lastBarTime = 0;
datetime g_lastEntryTime = 0;
//+------------------------------------------------------------------+
//| Normalize a price to the symbol tick grid |
//+------------------------------------------------------------------+
double NormalizePrice(const double price)
{
if(g_tickSize <= 0.0)
return NormalizeDouble(price, g_digits);
return NormalizeDouble(MathRound(price / g_tickSize) * g_tickSize, g_digits);
}
//+------------------------------------------------------------------+
//| Number of decimals implied by the volume step |
//+------------------------------------------------------------------+
int VolumeDigits()
{
if(g_volumeStep >= 1.0) return 0;
if(g_volumeStep >= 0.1) return 1;
if(g_volumeStep >= 0.01) return 2;
return 3;
}
//+------------------------------------------------------------------+
//| Descriptive message for a trade server return code |
//+------------------------------------------------------------------+
string RetcodeDescription(const uint code)
{
switch((int)code)
{
case TRADE_RETCODE_REQUOTE: return "requote";
case TRADE_RETCODE_REJECT: return "request rejected";
case TRADE_RETCODE_CANCEL: return "request cancelled by trader";
case TRADE_RETCODE_PLACED: return "order placed";
case TRADE_RETCODE_DONE: return "request completed";
case TRADE_RETCODE_DONE_PARTIAL: return "request partially completed";
case TRADE_RETCODE_TIMEOUT: return "request timed out";
case TRADE_RETCODE_INVALID: return "invalid request";
case TRADE_RETCODE_INVALID_VOLUME: return "invalid volume";
case TRADE_RETCODE_INVALID_PRICE: return "invalid price";
case TRADE_RETCODE_INVALID_STOPS: return "invalid stops";
case TRADE_RETCODE_TRADE_DISABLED: return "trading is disabled";
case TRADE_RETCODE_MARKET_CLOSED: return "market is closed";
case TRADE_RETCODE_NO_MONEY: return "not enough money";
case TRADE_RETCODE_PRICE_CHANGED: return "price changed";
case TRADE_RETCODE_PRICE_OFF: return "no quotes to process the request";
case TRADE_RETCODE_INVALID_EXPIRATION: return "invalid expiration";
case TRADE_RETCODE_ORDER_CHANGED: return "order state changed";
case TRADE_RETCODE_TOO_MANY_REQUESTS: return "too many requests";
case TRADE_RETCODE_NO_CHANGES: return "no changes in the request";
case TRADE_RETCODE_LOCKED: return "request locked";
case TRADE_RETCODE_FROZEN: return "order or position is frozen";
case TRADE_RETCODE_INVALID_FILL: return "unsupported filling mode";
case TRADE_RETCODE_CONNECTION: return "no connection to the trade server";
case TRADE_RETCODE_LIMIT_ORDERS: return "order limit reached";
case TRADE_RETCODE_LIMIT_VOLUME: return "volume limit reached";
case TRADE_RETCODE_ONLY_REAL: return "operation allowed on live accounts only";
default: return "unclassified return code";
}
}
//+------------------------------------------------------------------+
//| Load a rates series indexed from the newest bar |
//+------------------------------------------------------------------+
bool LoadRates(const ENUM_TIMEFRAMES timeframe, const int count, MqlRates &rates[])
{
ArraySetAsSeries(rates, true);
const int copied = CopyRates(_Symbol, timeframe, 0, count, rates);
return (copied >= count);
}
//+------------------------------------------------------------------+
//| Convert a raw rate into a normalized candle view |
//+------------------------------------------------------------------+
void BuildCandle(const MqlRates &rate, SCandle &candle)
{
candle.time = rate.time;
candle.open = rate.open;
candle.high = rate.high;
candle.low = rate.low;
candle.close = rate.close;
candle.range = rate.high - rate.low;
candle.body = MathAbs(rate.close - rate.open);
candle.upperWick = rate.high - MathMax(rate.open, rate.close);
candle.lowerWick = MathMin(rate.open, rate.close) - rate.low;
candle.bullish = (rate.close > rate.open);
candle.valid = (candle.range > 0.0);
if(candle.valid)
{
candle.bodyRatio = candle.body / candle.range;
candle.upperWickRatio = candle.upperWick / candle.range;
candle.lowerWickRatio = candle.lowerWick / candle.range;
candle.closePosition = (rate.close - rate.low) / candle.range;
}
else
{
candle.bodyRatio = 0.0;
candle.upperWickRatio = 0.0;
candle.lowerWickRatio = 0.0;
candle.closePosition = 0.5;
}
}
//+------------------------------------------------------------------+
//| Highest high and lowest low inside a bar window |
//+------------------------------------------------------------------+
void WindowExtremes(const MqlRates &rates[], const int startShift, const int length,
double &highest, double &lowest)
{
highest = -DBL_MAX;
lowest = DBL_MAX;
const int total = ArraySize(rates);
for(int i = startShift; i < startShift + length && i < total; i++)
{
if(rates[i].high > highest) highest = rates[i].high;
if(rates[i].low < lowest) lowest = rates[i].low;
}
if(highest == -DBL_MAX) highest = 0.0;
if(lowest == DBL_MAX) lowest = 0.0;
}
//+------------------------------------------------------------------+
//| Rejection structure: one side pushed, the other took over |
//+------------------------------------------------------------------+
bool IsBullishRejection(const SCandle &candle)
{
if(!candle.valid) return false;
if(candle.lowerWickRatio < InpRejectionWickRatio) return false;
if(candle.bodyRatio > InpRejectionMaxBody) return false;
if(candle.closePosition < InpRejectionClosePos) return false;
return true;
}
bool IsBearishRejection(const SCandle &candle)
{
if(!candle.valid) return false;
if(candle.upperWickRatio < InpRejectionWickRatio) return false;
if(candle.bodyRatio > InpRejectionMaxBody) return false;
if((1.0 - candle.closePosition) < InpRejectionClosePos) return false;
return true;
}
//+------------------------------------------------------------------+
//| Engulfing structure: one side takes control aggressively |
//+------------------------------------------------------------------+
bool IsBullishEngulfing(const SCandle &previous, const SCandle &current)
{
if(!previous.valid || !current.valid) return false;
if(!current.bullish || previous.bullish) return false;
if(current.open > previous.close) return false;
if(current.close <= previous.open) return false;
return (current.body > previous.body);
}
bool IsBearishEngulfing(const SCandle &previous, const SCandle &current)
{
if(!previous.valid || !current.valid) return false;
if(current.bullish || !previous.bullish) return false;
if(current.open < previous.close) return false;
if(current.close >= previous.open) return false;
return (current.body > previous.body);
}
//+------------------------------------------------------------------+
//| Break of structure on the signal timeframe |
//| Returns +1 for a bullish break, -1 for a bearish break, 0 none |
//+------------------------------------------------------------------+
int DetectBos(const MqlRates &rates[])
{
double refHigh = 0.0;
double refLow = 0.0;
WindowExtremes(rates, InpBosConfirmBars + 1, InpSwingLookback, refHigh, refLow);
if(refHigh <= 0.0 || refLow <= 0.0 || refHigh <= refLow)
return 0;
// Scan from the newest confirmation bar so the freshest break wins
for(int i = 1; i <= InpBosConfirmBars; i++)
{
if(rates[i].close > refHigh) return 1;
if(rates[i].close < refLow) return -1;
}
return 0;
}
//+------------------------------------------------------------------+
//| Higher timeframe pressure from an EMA and its slope |
//+------------------------------------------------------------------+
int HtfBias()
{
if(g_htfEmaHandle == INVALID_HANDLE) return 0;
double ema[];
ArraySetAsSeries(ema, true);
if(CopyBuffer(g_htfEmaHandle, 0, 0, 5, ema) < 5) return 0;
const double closePrice = iClose(_Symbol, InpHtfTimeframe, 1);
if(closePrice <= 0.0) return 0;
const bool above = (closePrice > ema[1]);
const bool rising = (ema[1] > ema[3]);
const bool falling = (ema[1] < ema[3]);
if(above && rising) return 1;
if(!above && falling) return -1;
return 0;
}
//+------------------------------------------------------------------+
//| Indicator accessors |
//+------------------------------------------------------------------+
double AtrValue(const int shift)
{
if(g_atrHandle == INVALID_HANDLE) return 0.0;
double buffer[];
ArraySetAsSeries(buffer, true);
if(CopyBuffer(g_atrHandle, 0, shift, 1, buffer) < 1) return 0.0;
return buffer[0];
}
double AdxValue()
{
if(g_adxHandle == INVALID_HANDLE) return -1.0;
double buffer[];
ArraySetAsSeries(buffer, true);
if(CopyBuffer(g_adxHandle, 0, 1, 1, buffer) < 1) return -1.0;
if(buffer[0] <= 0.0) return -1.0;
return buffer[0];
}
//+------------------------------------------------------------------+
//| Zone helpers |
//+------------------------------------------------------------------+
bool ZoneContains(const double zoneLow, const double zoneHigh,
const double price, const double tolerance)
{
if(zoneHigh <= zoneLow) return false;
return (price >= zoneLow - tolerance && price <= zoneHigh + tolerance);
}
// Demand zone: bullish fair value gap or bullish order block
bool FindBullishZone(const MqlRates &rates[], const double atr, const double price,
double &zoneLow, double &zoneHigh)
{
const double tolerance = atr * InpZoneToleranceATR;
const int total = ArraySize(rates);
for(int i = 2; i < InpZoneLookback && (i + 2) < total; i++)
{
// Fair value gap: the low of the newer candle stays above the high of the older candle
if(rates[i].low > rates[i + 2].high)
{
if(ZoneContains(rates[i + 2].high, rates[i].low, price, tolerance))
{
zoneLow = rates[i + 2].high;
zoneHigh = rates[i].low;
return true;
}
}
// Order block: last bearish candle before a bullish displacement
if(rates[i].close < rates[i].open && rates[i - 1].close > rates[i - 1].open)
{
const double displacement = MathAbs(rates[i - 1].close - rates[i - 1].open);
if(displacement >= atr * InpDisplacementATR && rates[i - 1].close > rates[i].high)
{
if(ZoneContains(rates[i].low, rates[i].high, price, tolerance))
{
zoneLow = rates[i].low;
zoneHigh = rates[i].high;
return true;
}
}
}
}
return false;
}
// Supply zone: bearish fair value gap or bearish order block
bool FindBearishZone(const MqlRates &rates[], const double atr, const double price,
double &zoneLow, double &zoneHigh)
{
const double tolerance = atr * InpZoneToleranceATR;
const int total = ArraySize(rates);
for(int i = 2; i < InpZoneLookback && (i + 2) < total; i++)
{
// Fair value gap: the high of the newer candle stays below the low of the older candle
if(rates[i].high < rates[i + 2].low)
{
if(ZoneContains(rates[i].high, rates[i + 2].low, price, tolerance))
{
zoneLow = rates[i].high;
zoneHigh = rates[i + 2].low;
return true;
}
}
// Order block: last bullish candle before a bearish displacement
if(rates[i].close > rates[i].open && rates[i - 1].close < rates[i - 1].open)
{
const double displacement = MathAbs(rates[i - 1].close - rates[i - 1].open);
if(displacement >= atr * InpDisplacementATR && rates[i - 1].close < rates[i].low)
{
if(ZoneContains(rates[i].low, rates[i].high, price, tolerance))
{
zoneLow = rates[i].low;
zoneHigh = rates[i].high;
return true;
}
}
}
}
return false;
}
//+------------------------------------------------------------------+
//| Liquidity sweep: price takes a pool then closes back inside |
//+------------------------------------------------------------------+
bool DetectSweep(const MqlRates &rates[], const int direction)
{
double refHigh = 0.0;
double refLow = 0.0;
WindowExtremes(rates, InpSweepLookback + 1, InpSweepDepth, refHigh, refLow);
if(refHigh <= 0.0 || refLow <= 0.0) return false;
for(int i = 1; i <= InpSweepLookback; i++)
{
if(direction > 0)
{
if(rates[i].low < refLow && rates[i].close > refLow) return true;
}
else
{
if(rates[i].high > refHigh && rates[i].close < refHigh) return true;
}
}
return false;
}
//+------------------------------------------------------------------+
//| Signal engine |
//| The candle itself is never enough: it must sit in a valid context |
//+------------------------------------------------------------------+
int DetectSignal(double &score, SCandle &trigger)
{
score = 0.0;
MqlRates rates[];
if(!LoadRates(InpWorkTimeframe, g_historyBars, rates)) return 0;
if(ArraySize(rates) < g_historyBars) return 0;
if(ArraySize(rates) < InpSwingLookback + InpBosConfirmBars + 8) return 0;
const double atr = AtrValue(1);
if(atr <= 0.0) return 0;
if(InpUseAdxFilter)
{
const double adx = AdxValue();
if(adx < 0.0) return 0; // indicator not ready: fail closed
if(adx < InpAdxMinLevel) return 0;
}
SCandle current;
SCandle previous;
BuildCandle(rates[1], current);
BuildCandle(rates[2], previous);
if(!current.valid) return 0;
// The trigger candle must be a rejection or an engulfing, never a random shape
const bool bullishTrigger = IsBullishRejection(current) || IsBullishEngulfing(previous, current);
const bool bearishTrigger = IsBearishRejection(current) || IsBearishEngulfing(previous, current);
int direction = 0;
if(bullishTrigger && !bearishTrigger) direction = 1;
else if(bearishTrigger && !bullishTrigger) direction = -1;
else return 0;
// --- Hard context filters -------------------------------------
const int htfBias = HtfBias();
if(InpRequireHtfBias && htfBias != direction) return 0;
const int bos = DetectBos(rates);
if(InpRequireBos && bos != direction) return 0;
// Dealing range location: buy in discount, sell in premium
double rangeHigh = 0.0;
double rangeLow = 0.0;
// The dealing range is measured on the bars BEFORE the trigger candle so the
// trigger's own extreme cannot shift the location it is judged against
WindowExtremes(rates, 2, g_rangeLookback, rangeHigh, rangeLow);
if(rangeHigh <= 0.0 || rangeLow <= 0.0 || rangeHigh <= rangeLow) return 0;
const double positionInRange = (current.close - rangeLow) / (rangeHigh - rangeLow);
if(InpRequireDiscountPremium)
{
if(direction > 0 && positionInRange > 0.5 + InpEquilibriumTolerance) return 0;
if(direction < 0 && positionInRange < 0.5 - InpEquilibriumTolerance) return 0;
}
const double price = current.close;
const bool sweep = DetectSweep(rates, direction);
if(InpRequireLiquiditySweep && !sweep) return 0;
double zoneLow = 0.0;
double zoneHigh = 0.0;
const bool zoneTouch = (direction > 0)
? FindBullishZone(rates, atr, price, zoneLow, zoneHigh)
: FindBearishZone(rates, atr, price, zoneLow, zoneHigh);
if(InpRequireZoneTouch && !zoneTouch) return 0;
// --- Soft scoring ---------------------------------------------
const bool rejection = (direction > 0) ? IsBullishRejection(current) : IsBearishRejection(current);
const bool engulfing = (direction > 0) ? IsBullishEngulfing(previous, current)
: IsBearishEngulfing(previous, current);
const bool dominantBody = (current.bodyRatio >= InpDominantBodyRatio)
&& (current.bullish == (direction > 0));
score = 0.0;
score += (rejection ? 0.35 : 0.0);
score += (engulfing ? 0.20 : 0.0);
score += (dominantBody ? 0.15 : 0.0);
score += (sweep ? 0.15 : 0.0);
score += (zoneTouch ? 0.15 : 0.0);
if(score < InpMinSignalScore) return 0;
trigger = current;
return direction;
}
//+------------------------------------------------------------------+
//| Persistent risk state primitives |
//+------------------------------------------------------------------+
ulong StateHash(const string text)
{
ulong h = 1469598103934665603; // FNV-1a 64 offset basis
const int n = StringLen(text);
for(int i = 0; i < n; i++)
{
h ^= (ulong)StringGetCharacter(text, i);
h *= 1099511628211; // FNV prime
}
return h;
}
// R01-H4: every component that defines the risk ledger is explicit. A change to the
// account, the trade server, the risk scope or the risk period produces a different
// identity, and a different identity never inherits a baseline.
ulong StateIdentityServer()
{
return StateHash(AccountInfoString(ACCOUNT_SERVER));
}
ulong StateIdentityScope()
{
return StateHash(InpRiskScopeId);
}
ulong StateIdentityPeriod()
{
return StateHash(InpRiskPeriodId);
}
ulong StateIdentity()
{
return StateHash(StringFormat("%I64d|%I64u|%I64u|%I64u|%I64d|%s|%d",
AccountInfoInteger(ACCOUNT_LOGIN),
StateIdentityServer(),
StateIdentityScope(),
StateIdentityPeriod(),
InpMagicNumber,
_Symbol,
(int)InpWorkTimeframe));
}
double StateConfigFingerprint()
{
const string cfg = StringFormat("%.4f|%.4f|%.4f|%.4f|%.4f|%d|%.4f",
InpDailyMaxLossPercent, InpStaticMaxDdPercent,
InpEquityGrowthTargetPct, InpRiskPercentMin,
InpRiskPercentMax, InpMaxOpenPositions,
InpMaxLotAbsolute);
return (double)(StateHash(cfg) % 1000000007);
}
ulong StateChecksum(const SRiskState &s)
{
return StateHash(StringFormat("%u|%u|%I64u|%d|%I64u|%I64d|%I64u|%I64u|%I64u|%.10f|%.10f|%I64d|%.10f|%d|%d|%d|%d|%.4f|%I64d",
s.magic, s.version, s.seq, s.slot, s.identity,
s.login, s.server_hash, s.scope_hash, s.period_hash,
s.b_init, s.e_init, s.day_id, s.e_day0,
s.daily_halt, s.static_halt,
s.target_triggered, s.target_secured,
s.cfg_fingerprint, s.provision_time));
}
// Strategy Tester runs must stay isolated or every run inherits the previous result
bool StatePersistenceEnabled()
{
if(MQLInfoInteger(MQL_TESTER) && !InpTesterPersistState) return false;
return true;
}
string StateKey(const string suffix)
{
return StringFormat("CP_%016I64X_%s", StateIdentity(), suffix);
}
// R01-H3: two archive slots, both keyed by the risk identity
string StateSlotName(const int slot)
{
return StringFormat("CP_RISK_%016I64X_%s.bin", StateIdentity(),
(slot == CP_SLOT_A ? "A" : "B"));
}
void StateInitFresh()
{
ZeroMemory(g_state);
g_state.magic = CP_STATE_MAGIC;
g_state.version = CP_STATE_VERSION;
g_state.seq = 0; // assigned by the next durable write
g_state.slot = CP_SLOT_A;
g_state.identity = StateIdentity();
g_state.login = AccountInfoInteger(ACCOUNT_LOGIN);
g_state.server_hash = StateIdentityServer();
g_state.scope_hash = StateIdentityScope();
g_state.period_hash = StateIdentityPeriod();
g_state.b_init = AccountInfoDouble(ACCOUNT_BALANCE);
g_state.e_init = AccountInfoDouble(ACCOUNT_EQUITY);
if(g_state.e_init <= 0.0) g_state.e_init = g_state.b_init;
g_state.day_id = 0; // forces a fresh daily anchor
g_state.e_day0 = 0.0;
g_state.daily_halt = 0;
g_state.static_halt = 0;
g_state.target_triggered = 0;
g_state.target_secured = 0;
g_state.cfg_fingerprint = StateConfigFingerprint();
g_state.provision_time = (long)TimeCurrent();
g_state.valid = 1;
g_state.checksum = StateChecksum(g_state);
}
// Mirror the critical flags so sibling instances can see them immediately.
// The mirror is a coordination cache only; the archive stays authoritative.
void StateMirrorPublish(const SRiskState &s)
{
GlobalVariableSet(StateKey("valid"), (double)s.valid);
GlobalVariableSet(StateKey("daily"), (double)s.daily_halt);
GlobalVariableSet(StateKey("static"), (double)s.static_halt);
GlobalVariableSet(StateKey("target"), (double)s.target_secured);
GlobalVariableSet(StateKey("seq"), (double)(long)s.seq);
GlobalVariablesFlush();
}
// R01-H6: compare-and-swap on the shared sequence mirror. The tentative value is written
// and read back, so an instance that already advanced the sequence makes this writer lose
// the swap instead of overwriting state that it never observed.
bool StateCasAcquire(const ulong expectedSeq)
{
const string key = StateKey("seq");
if(GlobalVariableCheck(key))
{
const double mirror = GlobalVariableGet(key);
if(mirror > 0.0 && (ulong)(long)mirror != expectedSeq)
{
PrintFormat("CAS rejected: mirror sequence %.0f is not the expected %I64u",
mirror, expectedSeq);
return false;
}
}
GlobalVariableSet(key, (double)(long)(expectedSeq + 1));
GlobalVariablesFlush();
return ((ulong)(long)GlobalVariableGet(key) == expectedSeq + 1);
}
// R01-H6: true when the peer slot already moved past the sequence this writer swapped from
bool StatePeerAdvanced(const int peerSlot, const ulong expectedSeq)
{
SRiskState peer;
if(!StateReadSlot(peerSlot, peer)) return false;
if(!StateRecordValid(peer)) return false;
if(!StateIdentityMatches(peer)) return false;
return (peer.seq > expectedSeq);
}
// R01-H1: the record must reach the disk before the handle is released, otherwise a
// terminal or power failure silently loses the write while the EA believes it saved.
// R01-H2: the record is read back from the file and compared field by field, so a
// partial or truncated write is detected instead of being trusted.
// R01-H3: the write targets the slot that does NOT hold the newest valid record, so the
// last good archive survives any failed or torn candidate write.
// R01-H6: the sequence is swapped under CAS before the write and re-checked on the peer
// slot afterwards, so two instances in one terminal cannot both commit.
// R01-H7: the candidate is opened with an exclusive write handle (read sharing only), so
// a second terminal cannot interleave its own writer with this record.
// Any failure latches the storage fault and is reported as a failed save.
bool StateSave()
{
if(!g_riskStateValid)
{
g_stateStorageFault = true;
Print("CRITICAL: refusing to persist an invalid risk state");
return false;
}
if(!StatePersistenceEnabled())
{
g_state.checksum = StateChecksum(g_state);
StateMirrorPublish(g_state);
g_stateStorageFault = false;
return true;
}
const ulong expectedSeq = g_state.seq;
const int targetSlot = (g_stateSlotKnown && g_stateSlot == CP_SLOT_A) ? CP_SLOT_B : CP_SLOT_A;
const int peerSlot = (targetSlot == CP_SLOT_A) ? CP_SLOT_B : CP_SLOT_A;
const string slotTag = (targetSlot == CP_SLOT_A ? "A" : "B");
const string name = StateSlotName(targetSlot);
// R01-H6: no writer may advance the sequence from a stale view of the state
if(!StateCasAcquire(expectedSeq))
{
g_stateStorageFault = true;
PrintFormat("CRITICAL: risk state not persisted, the sequence swap on %I64u failed", expectedSeq);
return false;
}
bool ok = false;
do
{
SRiskState next = g_state;
next.seq = expectedSeq + 1;
next.slot = targetSlot;
next.checksum = StateChecksum(next);
const int h = FileOpen(name, FILE_BIN | FILE_WRITE | FILE_COMMON | FILE_SHARE_READ);
if(h == INVALID_HANDLE)
{
PrintFormat("CRITICAL: risk archive slot %s could not be opened for writing (error %d) at %s",
slotTag, GetLastError(), name);
break;
}
ResetLastError();
const bool wrote = FileWriteStruct(h, next);
if(wrote)
FileFlush(h); // R01-H1: push the buffer to the disk, not only to cache
const int writeError = GetLastError();
FileClose(h);
if(!wrote || writeError != 0)
{
PrintFormat("CRITICAL: risk archive slot %s write or flush failed (error %d) at %s",
slotTag, writeError, name);
break;
}
// R01-H2: verify the candidate by reading it back from the file itself
SRiskState verify;
if(!StateReadSlot(targetSlot, verify))
{
PrintFormat("CRITICAL: risk archive slot %s read-back failed at %s", slotTag, name);
break;
}
if(!StateRecordValid(verify) || !StateIdentityMatches(verify) ||
verify.seq != next.seq || verify.checksum != next.checksum)
{
PrintFormat("CRITICAL: risk archive slot %s read-back verification failed at %s", slotTag, name);
break;
}
// R01-H6: the peer slot must not have moved past the sequence we swapped from
if(StatePeerAdvanced(peerSlot, expectedSeq))
{
PrintFormat("CRITICAL: risk sequence advanced past %I64u in the peer slot, the candidate is not authoritative",
expectedSeq);
break;
}
g_state = next;
ok = true;
}
while(false);
if(!ok)
{
g_stateStorageFault = true;
StateMirrorPublish(g_state); // republish the durable sequence, dropping the tentative swap
return false;
}
g_stateSlot = targetSlot;
g_stateSlotKnown = true;
g_stateStorageFault = false;
StateMirrorPublish(g_state);
return true;
}
// R01-H3: raw slot read. False when the slot is absent, short or unreadable.
bool StateReadSlot(const int slot, SRiskState &record)
{
ZeroMemory(record);
const int h = FileOpen(StateSlotName(slot),
FILE_BIN | FILE_READ | FILE_COMMON | FILE_SHARE_READ | FILE_SHARE_WRITE);
if(h == INVALID_HANDLE) return false;
const bool ok = FileReadStruct(h, record);
FileClose(h);
return ok;
}
// Structural validation of a single archive record. Balance drift is deliberately NOT
// a validity test: trading changes the balance by design.
bool StateRecordValid(const SRiskState &s)
{
if(s.magic != CP_STATE_MAGIC) return false;
if(s.version != CP_STATE_VERSION) return false;
if(s.valid != 1) return false;
if(s.seq == 0) return false;
if(s.slot != CP_SLOT_A && s.slot != CP_SLOT_B) return false;
if(s.checksum != StateChecksum(s)) return false;
if(s.b_init <= 0.0) return false;
if(s.e_init <= 0.0) return false;
if(s.day_id <= 0) return false;
if(s.e_day0 <= 0.0) return false;
if(s.provision_time <= 0) return false;
return true;
}
// R01-H4: the record may only be used by the identity that created it. Every component
// is compared, not only the composite hash, so a change of login, server, scope or
// period can never be absorbed by a hash coincidence.
bool StateIdentityMatches(const SRiskState &s)
{
if(s.identity != StateIdentity()) return false;
if(s.login != AccountInfoInteger(ACCOUNT_LOGIN)) return false;
if(s.server_hash != StateIdentityServer()) return false;
if(s.scope_hash != StateIdentityScope()) return false;
if(s.period_hash != StateIdentityPeriod()) return false;
return true;
}
// R01-H8: deterministic recovery. Both slots are validated independently, the highest
// valid sequence wins and an equal sequence resolves to slot A. A record that belongs to
// another identity never authorises entries, so it is reported separately from a
// missing or corrupt archive.
int StateRecover(SRiskState &best, int &bestSlot, ulong &maxSeqSeen)
{
bestSlot = CP_SLOT_A;
maxSeqSeen = 0;
ZeroMemory(best);
SRiskState recA;
SRiskState recB;
const bool okA = StateReadSlot(CP_SLOT_A, recA);
const bool okB = StateReadSlot(CP_SLOT_B, recB);
const bool validA = okA && StateRecordValid(recA);
const bool validB = okB && StateRecordValid(recB);
const bool matchA = validA && StateIdentityMatches(recA);
const bool matchB = validB && StateIdentityMatches(recB);
if(validA && !matchA)
PrintFormat("Archive anomaly: slot A holds a foreign identity (sequence %I64u)", recA.seq);
if(validB && !matchB)
PrintFormat("Archive anomaly: slot B holds a foreign identity (sequence %I64u)", recB.seq);
// Sequence continuity is derived from records of this identity only
if(matchA && recA.seq > maxSeqSeen) maxSeqSeen = recA.seq;
if(matchB && recB.seq > maxSeqSeen) maxSeqSeen = recB.seq;
if(!matchA && !matchB)
return ((validA || validB) ? CP_REC_MISMATCH : CP_REC_NONE);
if(matchA && matchB)
{
if(recA.seq < recB.seq)
{
best = recB;
bestSlot = CP_SLOT_B;
return CP_REC_RESTORED;
}
if(recA.seq == recB.seq)
PrintFormat("Archive anomaly: both slots carry sequence %I64u, slot A is used", recA.seq);
best = recA;
bestSlot = CP_SLOT_A;
return CP_REC_RESTORED;
}
if(matchA)
{
best = recA;
bestSlot = CP_SLOT_A;
return CP_REC_RESTORED;
}
best = recB;
bestSlot = CP_SLOT_B;
return CP_REC_RESTORED;
}
//+------------------------------------------------------------------+
//| Provisioning marker: identity, durability and validation |
//+------------------------------------------------------------------+
// The provisioning authorization belongs to the risk period, not to the chart, so a
// symbol, magic or timeframe change can never hand out a second authorization.
ulong StatePeriodIdentity()
{
return StateHash(StringFormat("%I64d|%I64u|%I64u|%I64u",
AccountInfoInteger(ACCOUNT_LOGIN),
StateIdentityServer(),
StateIdentityScope(),
StateIdentityPeriod()));
}
ulong StateProvisionId()
{
ulong id = StateHash(StringFormat("%I64d|%I64u|%I64u|%I64d",
(long)TimeCurrent(), (ulong)GetMicrosecondCount(),
StatePeriodIdentity(),
(long)AccountInfoInteger(ACCOUNT_LOGIN)));
return (id == 0 ? 1 : id);
}
string StateMarkerName()
{
return StringFormat("CP_PROV_%016I64X.ack", StatePeriodIdentity());
}
string StateLockName()
{
return StringFormat("CP_PROV_%016I64X.lck", StatePeriodIdentity());
}
ulong StateMarkerChecksum(const SProvisionMarker &m)
{
return StateHash(StringFormat("%u|%u|%I64u|%I64d|%I64u|%I64u|%I64u|%I64u|%d|%.10f|%.10f|%I64d|%.10f|%.4f|%I64d",
m.magic, m.version, m.identity, m.login,
m.server_hash, m.scope_hash, m.period_hash, m.prov_id,
m.status, m.b_init, m.e_init, m.day_id, m.e_day0,
m.cfg_fingerprint, m.provision_time));
}
bool StateMarkerValid(const SProvisionMarker &m)
{
if(m.magic != CP_PROV_MAGIC) return false;
if(m.version != CP_PROV_VERSION) return false;
if(m.valid != 1) return false;
if(m.checksum != StateMarkerChecksum(m)) return false;
if(m.identity != StatePeriodIdentity()) return false;
if(m.login != AccountInfoInteger(ACCOUNT_LOGIN)) return false;
if(m.server_hash != StateIdentityServer()) return false;
if(m.scope_hash != StateIdentityScope()) return false;
if(m.period_hash != StateIdentityPeriod()) return false;
if(m.prov_id == 0) return false;
if(m.status != CP_PSTAT_PROVISIONING && m.status != CP_PSTAT_PROVISIONED) return false;
if(m.b_init <= 0.0) return false;
if(m.e_init <= 0.0) return false;
if(m.day_id <= 0) return false;
if(m.e_day0 <= 0.0) return false;
if(m.provision_time <= 0) return false;
return true;
}
// A marker that exists but cannot be validated is reported as CORRUPT, never as absent,
// so a damaged marker can never be mistaken for a first provisioning.
int StateMarkerLoad(SProvisionMarker &m)
{
ZeroMemory(m);
const string name = StateMarkerName();
const int h = FileOpen(name, FILE_BIN | FILE_READ | FILE_COMMON | FILE_SHARE_READ | FILE_SHARE_WRITE);
if(h == INVALID_HANDLE)
{
if(FileIsExist(name, FILE_COMMON))
{
PrintFormat("CRITICAL: provisioning marker %s exists but could not be opened (error %d)",
name, GetLastError());
return CP_MARK_CORRUPT;
}
return CP_MARK_NONE;
}
const bool ok = FileReadStruct(h, m);
FileClose(h);
if(!ok) return CP_MARK_CORRUPT;
if(!StateMarkerValid(m))
{
PrintFormat("CRITICAL: provisioning marker %s failed validation", name);
return CP_MARK_CORRUPT;
}
if(m.status == CP_PSTAT_PROVISIONING) return CP_MARK_PROVISIONING;
if(m.status == CP_PSTAT_PROVISIONED) return CP_MARK_PROVISIONED;
return CP_MARK_CORRUPT;
}
// R01-H1/H2 applied to the marker: flush before close, then read the record back and
// compare every frozen field. A marker that cannot be read back is a failed marker.
bool StateMarkerStore(const SProvisionMarker &src, const string stage)
{
SProvisionMarker m = src;
m.checksum = StateMarkerChecksum(m);
const string name = StateMarkerName();
const int h = FileOpen(name, FILE_BIN | FILE_WRITE | FILE_COMMON | FILE_SHARE_READ);
if(h == INVALID_HANDLE)
{
PrintFormat("CRITICAL: provisioning marker could not be opened for writing (error %d) at %s",
GetLastError(), name);
return false;
}
ResetLastError();
const bool wrote = FileWriteStruct(h, m);
if(wrote)
FileFlush(h);
const int writeError = GetLastError();
FileClose(h);
if(!wrote || writeError != 0)
{
PrintFormat("CRITICAL: provisioning marker write or flush failed in stage %s (error %d) at %s",
stage, writeError, name);
return false;
}
SProvisionMarker verify;
ZeroMemory(verify);
const int rh = FileOpen(name, FILE_BIN | FILE_READ | FILE_COMMON | FILE_SHARE_READ | FILE_SHARE_WRITE);
if(rh == INVALID_HANDLE)
{
PrintFormat("CRITICAL: provisioning marker read-back failed in stage %s (error %d) at %s",
stage, GetLastError(), name);
return false;
}
const bool readBack = FileReadStruct(rh, verify);
FileClose(rh);
if(!readBack || !StateMarkerValid(verify) ||
verify.checksum != m.checksum ||
verify.status != m.status ||
verify.prov_id != m.prov_id ||
verify.b_init != m.b_init ||
verify.e_init != m.e_init ||
verify.day_id != m.day_id ||
verify.e_day0 != m.e_day0 ||
verify.cfg_fingerprint != m.cfg_fingerprint ||
verify.provision_time != m.provision_time)
{
PrintFormat("CRITICAL: provisioning marker read-back verification failed in stage %s at %s",
stage, name);
return false;
}
PrintFormat("Provisioning marker verified: stage '%s', status %s, id %016I64X, baseline %.2f/%.2f, day %I64d anchor %.2f",
stage,
(m.status == CP_PSTAT_PROVISIONED ? "PROVISIONED" : "PROVISIONING"),
m.prov_id, m.b_init, m.e_init, m.day_id, m.e_day0);
return true;
}
// R01-H7: one exclusive writer at a time across terminals. The handle is held for the whole
// decision, so a sibling terminal cannot interleave its own marker or archive write.
int StateLockAcquire()
{
const int h = FileOpen(StateLockName(), FILE_BIN | FILE_WRITE | FILE_COMMON | FILE_SHARE_READ);
if(h == INVALID_HANDLE)
PrintFormat("CRITICAL: the exclusive provisioning lock could not be acquired (error %d) at %s",
GetLastError(), StateLockName());
return h;
}
void StateLockRelease(const int handle)
{
if(handle != INVALID_HANDLE)
FileClose(handle);
}
// The sequence mirror is a coordination cache, but a tentative base must never sit below
// it, otherwise the compare-and-swap would reject a legitimate write after a restart.
ulong StateMirrorSequence()
{
const string key = StateKey("seq");
if(!GlobalVariableCheck(key)) return 0;
const double mirror = GlobalVariableGet(key);
if(mirror <= 0.0) return 0;
return (ulong)(long)mirror;
}
void StateAdoptRestored(const SRiskState &record, const int slot)
{
g_state = record;
g_stateSlot = slot;
g_stateSlotKnown = true;
g_riskStateValid = true;
g_stateStorageFault = false;
}
void StateComputeDailyAnchor(long &dayId, double &eDay0)
{
MqlDateTime now;
TimeToStruct(TimeCurrent(), now);
dayId = (long)now.year * 10000 + (long)now.mon * 100 + (long)now.day;
eDay0 = AccountInfoDouble(ACCOUNT_EQUITY);
if(eDay0 <= 0.0) eDay0 = AccountInfoDouble(ACCOUNT_BALANCE);
}
// The frozen snapshot is authoritative for provisioning and for its resumption. The live
// balance is never consulted here, which is what stops a crashed provisioning from opening
// a second baseline.
void StateApplyMarkerSnapshot(const SProvisionMarker &m, const ulong seqBase)
{
ZeroMemory(g_state);
g_state.magic = CP_STATE_MAGIC;
g_state.version = CP_STATE_VERSION;
g_state.seq = seqBase;
g_state.slot = CP_SLOT_A;
g_state.identity = StateIdentity();
g_state.login = AccountInfoInteger(ACCOUNT_LOGIN);
g_state.server_hash = StateIdentityServer();
g_state.scope_hash = StateIdentityScope();
g_state.period_hash = StateIdentityPeriod();
g_state.b_init = m.b_init;
g_state.e_init = m.e_init;
g_state.day_id = m.day_id;
g_state.e_day0 = m.e_day0;
g_state.daily_halt = 0;
g_state.static_halt = 0;
g_state.target_triggered = 0;
g_state.target_secured = 0;
g_state.cfg_fingerprint = m.cfg_fingerprint;
g_state.provision_time = m.provision_time;
g_state.valid = 1;
g_state.checksum = StateChecksum(g_state);
}
// The archive of a provisioned period must carry the frozen baseline it was created from.
bool StateArchiveMatchesMarker(const SProvisionMarker &m, const SRiskState &s)
{
if(s.b_init != m.b_init || s.e_init != m.e_init || s.provision_time != m.provision_time)
{
PrintFormat("Archive/marker mismatch: archive %.2f/%.2f at %I64d, marker %.2f/%.2f at %I64d",
s.b_init, s.e_init, s.provision_time, m.b_init, m.e_init, m.provision_time);
return false;
}
return true;
}
// Step 3 of the state machine: both slots are built from the frozen snapshot and then read
// back independently, so an incomplete provisioning is detected here and not later.
bool StateProvisionArchives(const ulong seqBase)
{
g_state.seq = seqBase;
g_stateSlot = CP_SLOT_A;
g_stateSlotKnown = false;
g_riskStateValid = true;
g_stateStorageFault = false;
if(!StateSave())
{
Print("CRITICAL: provisioning could not persist archive slot A");
return false;
}
if(!StateSave())
{
Print("CRITICAL: provisioning could not persist archive slot B");
return false;
}
SRiskState recA;
SRiskState recB;
const bool okA = StateReadSlot(CP_SLOT_A, recA) && StateRecordValid(recA) && StateIdentityMatches(recA);
const bool okB = StateReadSlot(CP_SLOT_B, recB) && StateRecordValid(recB) && StateIdentityMatches(recB);
if(!okA || !okB)
{
PrintFormat("CRITICAL: provisioning archive verification failed (slot A %s, slot B %s)",
(okA ? "valid" : "invalid"), (okB ? "valid" : "invalid"));
return false;
}
if(recA.b_init != g_state.b_init || recB.b_init != g_state.b_init)
{
Print("CRITICAL: provisioning archive baseline does not match the frozen snapshot");
return false;
}
if(recA.provision_time != g_state.provision_time || recB.provision_time != g_state.provision_time)
{
Print("CRITICAL: provisioning archive provisioning time does not match the frozen snapshot");
return false;
}
if(recA.day_id != g_state.day_id || recB.day_id != g_state.day_id)
{
Print("CRITICAL: provisioning archive day does not match the frozen snapshot");
return false;
}
PrintFormat("Provisioning archives verified: slot A sequence %I64u, slot B sequence %I64u",
recA.seq, recB.seq);
return true;
}
// Step 4 of the state machine: the marker is committed to PROVISIONED only after the
// archives verify, and only a durable, verified marker enables entries.
bool StateCommitMarker(const SProvisionMarker &base, const SRiskState &snapshot)
{
SProvisionMarker m = base;
m.status = CP_PSTAT_PROVISIONED;
m.b_init = snapshot.b_init;
m.e_init = snapshot.e_init;
m.day_id = snapshot.day_id;
m.e_day0 = snapshot.e_day0;
m.checksum = StateMarkerChecksum(m);
return StateMarkerStore(m, "commit");
}
// The archive itself proves the period was provisioned, so a missing or damaged marker is
// rebuilt from it instead of being treated as a licence to provision again.
bool StateReconstructMarker(const SRiskState &snapshot)
{
SProvisionMarker m;
ZeroMemory(m);
m.magic = CP_PROV_MAGIC;
m.version = CP_PROV_VERSION;
m.identity = StatePeriodIdentity();
m.login = AccountInfoInteger(ACCOUNT_LOGIN);
m.server_hash = StateIdentityServer();
m.scope_hash = StateIdentityScope();
m.period_hash = StateIdentityPeriod();
m.prov_id = StateProvisionId();
m.status = CP_PSTAT_PROVISIONED;
m.b_init = snapshot.b_init;
m.e_init = snapshot.e_init;
m.day_id = snapshot.day_id;
m.e_day0 = snapshot.e_day0;
m.cfg_fingerprint = StateConfigFingerprint();
m.provision_time = snapshot.provision_time;
m.valid = 1;
m.checksum = StateMarkerChecksum(m);
if(!StateMarkerStore(m, "reconstruct"))
return false;
PrintFormat("Provisioning marker reconstructed from the archive: baseline %.2f, provisioned %I64d",
m.b_init, m.provision_time);
return true;
}
int StateFinishRestore(const int slot)
{
PrintFormat("Risk state restored: slot %s, sequence %I64u, balance baseline %.2f, equity baseline %.2f, day %I64d anchor %.2f",
(slot == CP_SLOT_A ? "A" : "B"), g_state.seq,
g_state.b_init, g_state.e_init, g_state.day_id, g_state.e_day0);
// A changed risk configuration invalidates a latched halt, not the baseline
if(g_state.cfg_fingerprint != StateConfigFingerprint() &&
(g_state.daily_halt != 0 || g_state.static_halt != 0 || g_state.target_triggered != 0))
{
g_riskStateValid = false;
Print("CRITICAL: RISK_STATE_INVALID. Risk parameters changed while a halt was latched.");
return CP_INIT_DENIED;
}
return CP_INIT_RESTORED;
}
// Steps 3 and 4 of the state machine, shared by the first provisioning and by the
// resumption of an interrupted one, so both paths consume the same frozen snapshot.
int StateCompleteProvisioning(const SProvisionMarker &marker, const ulong seqBase)
{
StateApplyMarkerSnapshot(marker, seqBase);
if(!StateProvisionArchives(seqBase))
{
g_riskStateValid = false;
Print("Entries stay disabled until the provisioning marker is PROVISIONED and both archive slots verify.");
return CP_INIT_FAILED;
}
if(!StateCommitMarker(marker, g_state))
{
g_riskStateValid = false;
Print("CRITICAL: the provisioning marker could not be committed; entries stay disabled");
return CP_INIT_FAILED;
}
PrintFormat("Provisioning complete: marker PROVISIONED, archives verified at sequence %I64u", g_state.seq);
PrintFormat("New risk period: slot %s, sequence %I64u, initial balance %.2f, static floor %.2f, target balance %.2f",
(g_stateSlot == CP_SLOT_A ? "A" : "B"), g_state.seq, g_state.b_init,
g_state.b_init * (1.0 - InpStaticMaxDdPercent / 100.0),
g_state.b_init * (1.0 + InpEquityGrowthTargetPct / 100.0));
Print("Provisioning is one-shot: set InpResetRiskState=false before the next start.");
return CP_INIT_PROVISIONED;
}
// Step 2 of the state machine: the authorization is consumed by a durable, verified
// PROVISIONING marker before a single archive byte is written.
int StateProvisionFirst(const ulong seqBase)
{
long dayId = 0;
double eDay0 = 0.0;
StateComputeDailyAnchor(dayId, eDay0);
SProvisionMarker marker;
ZeroMemory(marker);
marker.magic = CP_PROV_MAGIC;
marker.version = CP_PROV_VERSION;
marker.identity = StatePeriodIdentity();
marker.login = AccountInfoInteger(ACCOUNT_LOGIN);
marker.server_hash = StateIdentityServer();
marker.scope_hash = StateIdentityScope();
marker.period_hash = StateIdentityPeriod();
marker.prov_id = StateProvisionId();
marker.status = CP_PSTAT_PROVISIONING;
marker.b_init = AccountInfoDouble(ACCOUNT_BALANCE);
marker.e_init = AccountInfoDouble(ACCOUNT_EQUITY);
if(marker.e_init <= 0.0) marker.e_init = marker.b_init;
marker.day_id = dayId;
marker.e_day0 = eDay0;
marker.cfg_fingerprint = StateConfigFingerprint();
marker.provision_time = (long)TimeCurrent();
marker.valid = 1;
marker.checksum = StateMarkerChecksum(marker);
if(marker.b_init <= 0.0 || marker.e_init <= 0.0 || marker.day_id <= 0 || marker.e_day0 <= 0.0)
{
Print("CRITICAL: RISK_STATE_INVALID. The account baseline is not available; provisioning is refused.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
PrintFormat("PROVISIONING AUTHORISED by InpResetRiskState=true: scope '%s', period '%s', sequence base %I64u.",
InpRiskScopeId, InpRiskPeriodId, seqBase);
PrintFormat("Provisioning snapshot frozen: initial balance %.2f, initial equity %.2f, day %I64d anchor %.2f, id %016I64X",
marker.b_init, marker.e_init, marker.day_id, marker.e_day0, marker.prov_id);
if(!StateMarkerStore(marker, "consume"))
{
Print("CRITICAL: RISK_STATE_INVALID. The provisioning marker could not be stored; no archive was written.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
Print("Provisioning authorization consumed and durably stored; entries stay disabled until the archives verify.");
return StateCompleteProvisioning(marker, seqBase);
}
// Recovery decision table of R-01 v1.2
int StateProvisionOrRestoreLocked()
{
SRiskState recovered;
int recoveredSlot = CP_SLOT_A;
ulong maxSeqSeen = 0;
const int recovery = StateRecover(recovered, recoveredSlot, maxSeqSeen);
SProvisionMarker marker;
const int mark = StateMarkerLoad(marker);
ulong seqBase = maxSeqSeen;
const ulong mirrorSeq = StateMirrorSequence();
if(mirrorSeq > seqBase) seqBase = mirrorSeq;
PrintFormat("Provisioning marker %s: %s. Archive recovery: %s, highest sequence %I64u",
StateMarkerName(),
(mark == CP_MARK_PROVISIONED ? "PROVISIONED" :
mark == CP_MARK_PROVISIONING ? "PROVISIONING" :
mark == CP_MARK_CORRUPT ? "CORRUPT (untrusted)" : "ABSENT"),
(recovery == CP_REC_RESTORED ? "RESTORED" :
recovery == CP_REC_MISMATCH ? "IDENTITY_MISMATCH" : "NONE"),
maxSeqSeen);
// --- The risk period is already provisioned ---------------------
if(mark == CP_MARK_PROVISIONED)
{
if(recovery == CP_REC_RESTORED)
{
StateAdoptRestored(recovered, recoveredSlot);
if(!StateArchiveMatchesMarker(marker, g_state))
{
g_riskStateValid = false;
Print("CRITICAL: RISK_STATE_INVALID. The archive does not match the frozen provisioning snapshot.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
if(InpResetRiskState)
Print("WARNING: InpResetRiskState=true ignored: the provisioning authorization is already consumed and the existing archive stays authoritative");
return StateFinishRestore(recoveredSlot);
}
Print("CRITICAL: RISK_STATE_INVALID. The provisioning marker says this risk period is already PROVISIONED but no valid archive remains.");
Print("Provisioning authorization already consumed.");
Print("Existing risk period cannot be reinitialized.");
if(InpResetRiskState)
Print("WARNING: InpResetRiskState=true ignored: the authorization of this risk period was consumed by an earlier provisioning.");
Print("Entries disabled.");
Print("CRITICAL: define a new InpRiskPeriodId and authorise that provisioning deliberately to start a new risk period.");
return CP_INIT_DENIED;
}
// --- The provisioning was interrupted ---------------------------
if(mark == CP_MARK_PROVISIONING)
{
if(recovery == CP_REC_MISMATCH)
{
Print("CRITICAL: RISK_STATE_INVALID. The archive belongs to a different risk identity.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
if(InpResetRiskState)
Print("WARNING: InpResetRiskState=true ignored: the authorization is already consumed and provisioning is resumed, not restarted");
if(recovery == CP_REC_RESTORED)
{
StateAdoptRestored(recovered, recoveredSlot);
if(!StateArchiveMatchesMarker(marker, g_state))
{
g_riskStateValid = false;
Print("CRITICAL: RISK_STATE_INVALID. The archive does not match the frozen provisioning snapshot.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
PrintFormat("Provisioning commit: the archive from the frozen snapshot verifies at sequence %I64u", g_state.seq);
if(!StateCommitMarker(marker, g_state))
{
g_riskStateValid = false;
Print("CRITICAL: the provisioning marker could not be committed; entries stay disabled");
return CP_INIT_FAILED;
}
Print("Provisioning complete: the interrupted provisioning was committed by this start.");
return StateFinishRestore(recoveredSlot);
}
Print("Provisioning resume: the marker holds a consumed authorization whose provisioning never completed.");
PrintFormat("Provisioning resume: the frozen snapshot is reused (initial balance %.2f, initial equity %.2f, day %I64d anchor %.2f).",
marker.b_init, marker.e_init, marker.day_id, marker.e_day0);
Print("Provisioning resume: the live balance is not used as a new baseline.");
return StateCompleteProvisioning(marker, seqBase);
}
// --- The marker is damaged, the archive is trusted --------------
if(mark == CP_MARK_CORRUPT)
{
if(recovery == CP_REC_RESTORED)
{
Print("Provisioning marker is corrupt: it is reconstructed from the valid archive before entries are allowed");
StateAdoptRestored(recovered, recoveredSlot);
if(!StateReconstructMarker(g_state))
{
g_riskStateValid = false;
Print("CRITICAL: RISK_STATE_INVALID. The provisioning marker could not be reconstructed.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
if(InpResetRiskState)
Print("WARNING: InpResetRiskState=true ignored: the existing archive stays authoritative");
return StateFinishRestore(recoveredSlot);
}
Print("CRITICAL: RISK_STATE_INVALID. The provisioning marker is corrupt and no valid archive remains.");
Print("Provisioning authorization already consumed.");
Print("Existing risk period cannot be reinitialized.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
// --- No marker for this risk period -----------------------------
if(recovery == CP_REC_RESTORED)
{
// Installation upgraded from R-01 v1.1: the archive itself proves the period was
// provisioned, so the acknowledgement is rebuilt from it, never re-provisioned.
Print("Provisioning marker absent: it is rebuilt from the valid archive before entries are allowed");
StateAdoptRestored(recovered, recoveredSlot);
if(!StateReconstructMarker(g_state))
{
g_riskStateValid = false;
Print("CRITICAL: RISK_STATE_INVALID. The provisioning marker could not be created.");
Print("Entries disabled.");
return CP_INIT_DENIED;
}
if(InpResetRiskState)
Print("WARNING: InpResetRiskState=true ignored: the provisioning authorization is already consumed and the existing archive stays authoritative");
return StateFinishRestore(recoveredSlot);
}
if(recovery == CP_REC_MISMATCH)
{
Print("CRITICAL: RISK_STATE_INVALID. The archive belongs to a different risk identity.");
Print("CRITICAL: entries are disabled. Repair the archive or start a new risk period.");
return CP_INIT_DENIED;
}
if(!InpResetRiskState)
{
Print("CRITICAL: RISK_STATE_INVALID. No valid archive slot could be recovered.");
Print("CRITICAL: entries are disabled. Repair the archive or set InpResetRiskState=true to start a new period.");
return CP_INIT_DENIED;
}
return StateProvisionFirst(seqBase);
}
int StateProvisionOrRestore()
{
const int lock = StateLockAcquire();
if(lock == INVALID_HANDLE)
{
Print("CRITICAL: RISK_STATE_INVALID. The exclusive provisioning lock could not be acquired; entries are disabled.");
g_riskStateValid = false;
return CP_INIT_DENIED;
}
const int result = StateProvisionOrRestoreLocked();
StateLockRelease(lock);
return result;
}
//+------------------------------------------------------------------+
//| Equity protection: daily loss, static drawdown, growth target |
//+------------------------------------------------------------------+
bool InitializeDailyAnchor()
{
MqlDateTime now;
TimeToStruct(TimeCurrent(), now);
const long dayId = (long)now.year * 10000 + (long)now.mon * 100 + (long)now.day;
if(dayId == g_state.day_id) return true;
const long prevDayId = g_state.day_id;
const double prevDay0 = g_state.e_day0;
const int prevHalt = g_state.daily_halt;
g_state.day_id = dayId;
g_state.e_day0 = AccountInfoDouble(ACCOUNT_EQUITY);
if(g_state.e_day0 <= 0.0)
g_state.e_day0 = AccountInfoDouble(ACCOUNT_BALANCE);
g_state.daily_halt = 0;
// R01-H1/H2: the new anchor is only trusted once it is durable and verified.
// A rejected anchor is rolled back so the next tick retries it instead of
// trading on an anchor that was never stored.
if(!StateSave())
{
g_state.day_id = prevDayId;
g_state.e_day0 = prevDay0;
g_state.daily_halt = prevHalt;
Print("CRITICAL: the daily anchor could not be stored; entries stay disabled");
return false;
}
PrintFormat("New trading day %04d-%02d-%02d: daily loss anchor set to equity %.2f (cap %.2f%%)",
now.year, now.mon, now.day, g_state.e_day0, InpDailyMaxLossPercent);
return true;
}
bool EvaluateEquityGuard()
{
// Fail closed: an unreadable or inconsistent risk state never authorises entries
if(!g_riskStateValid) return false;
// R01-H1/H2: a state that could not be made durable is a failed save, and a failed
// save never authorises entries until a later verified save clears the latch.
if(g_stateStorageFault) return false;
if(g_state.static_halt != 0) return false;
if(g_state.target_triggered != 0) return false;
// The daily anchor must be refreshed BEFORE the daily flag is trusted, otherwise a
// halt latched yesterday would block every future day and never clear itself.
if(!InitializeDailyAnchor()) return false;
if(g_state.daily_halt != 0) return false;
const double equity = AccountInfoDouble(ACCOUNT_EQUITY);
if(equity <= 0.0) return false;
// Static drawdown is measured from the frozen initial balance (C-11)
const double staticFloor = g_state.b_init * (1.0 - InpStaticMaxDdPercent / 100.0);
if(g_state.b_init > 0.0)
{
const double staticDd = (g_state.b_init - equity) / g_state.b_init * 100.0;
if(equity <= staticFloor)
{
g_state.static_halt = 1;
StateSave();
PrintFormat("STATIC DRAWDOWN CAP HIT: %.2f%% of initial balance %.2f (floor %.2f, cap %.2f%%).",
staticDd, g_state.b_init, staticFloor, InpStaticMaxDdPercent);
if(InpCloseOnStaticDd)
CloseOwnPositions("static drawdown cap");
if(InpStopEaOnStaticDd)
{
Print("EA detached after the static drawdown cap. Restart manually to trade again.");
ExpertRemove();
}
return false;
}
}
// Daily loss is measured against the equity recorded at the start of the day
if(g_state.daily_halt == 0 && g_state.e_day0 > 0.0)
{
const double dailyLoss = (g_state.e_day0 - equity) / g_state.e_day0 * 100.0;
if(dailyLoss >= InpDailyMaxLossPercent)
{
g_state.daily_halt = 1;
StateSave();
PrintFormat("DAILY LOSS CAP HIT: %.2f%% (cap %.2f%%). No new trades until the next day.",
dailyLoss, InpDailyMaxLossPercent);
if(InpCloseOnDailyLimit)
CloseOwnPositions("daily loss cap");
}
}
if(g_state.daily_halt != 0) return false;
// TARGET_TRIGGERED is a realised result measured on balance, never on floating
// equity: a temporary spike must not latch the target while the position reverses.
// TARGET_SECURED additionally requires the account to be flat, so the 10 percent
// is only claimed once nothing can give it back (G7).
const double targetBalance = g_state.b_init * (1.0 + InpEquityGrowthTargetPct / 100.0);
const double balance = AccountInfoDouble(ACCOUNT_BALANCE);
if(g_state.target_triggered == 0 && targetBalance > 0.0 && balance >= targetBalance)
{
g_state.target_triggered = 1;
StateSave();
PrintFormat("TARGET TRIGGERED: realised balance %.2f >= target %.2f. No new entries.",
balance, targetBalance);
if(InpCloseOnTarget)
CloseOwnPositions("growth target reached");
}
if(g_state.target_triggered != 0)
{
if(g_state.target_secured == 0 && CountOwnPositions() == 0 && balance >= targetBalance)
{
g_state.target_secured = 1;
StateSave();
PrintFormat("TARGET SECURED: account flat at %.2f, target %.2f.", balance, targetBalance);
}
return false;
}
return true;
}
//+------------------------------------------------------------------+
//| Position helpers restricted to this EA |
//+------------------------------------------------------------------+
int CountOwnPositions()
{
int count = 0;
const int total = PositionsTotal();
for(int i = 0; i < total; i++)
{
const ulong ticket = PositionGetTicket(i);
if(ticket == 0) continue;
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
if((long)PositionGetInteger(POSITION_MAGIC) != (long)InpMagicNumber) continue;
count++;
}
return count;
}
void CloseOwnPositions(const string tag)
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
const ulong ticket = PositionGetTicket(i);
if(ticket == 0) continue;
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
if((long)PositionGetInteger(POSITION_MAGIC) != (long)InpMagicNumber) continue;
if(!g_trade.PositionClose(ticket))
PrintFormat("Close request for #%s failed (%s): %d - %s",
IntegerToString((long)ticket), tag,
g_trade.ResultRetcode(), RetcodeDescription(g_trade.ResultRetcode()));
}
}
//+------------------------------------------------------------------+
//| Volume sizing with margin and symbol constraints |
//+------------------------------------------------------------------+
double CalculateLotSize(const double riskPercent, const double stopDistance)
{
// Risk is measured on equity so an open drawdown cannot inflate the position
double equity = AccountInfoDouble(ACCOUNT_EQUITY);
if(equity <= 0.0) equity = AccountInfoDouble(ACCOUNT_BALANCE);
if(equity <= 0.0 || stopDistance <= 0.0) return 0.0;
const double tickSize = g_tickSize;
if(tickSize <= 0.0 || g_volumeStep <= 0.0) return 0.0;
double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE_LOSS);
if(tickValue <= 0.0)
tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
if(tickValue <= 0.0) return 0.0;
const double riskMoney = equity * riskPercent / 100.0;
const double lossPerLot = (stopDistance / tickSize) * tickValue;
if(lossPerLot <= 0.0) return 0.0;
double lots = riskMoney / lossPerLot;
lots = MathFloor(lots / g_volumeStep + 1e-8) * g_volumeStep;
lots = NormalizeDouble(lots, VolumeDigits());
lots = MathMin(lots, g_volumeMax);
// Free margin alone is not a risk control: cap the absolute volume as well
if(InpMaxLotAbsolute > 0.0 && lots > InpMaxLotAbsolute)
{
lots = MathFloor(InpMaxLotAbsolute / g_volumeStep + 1e-8) * g_volumeStep;
lots = NormalizeDouble(lots, VolumeDigits());
}
// Re-validate the money at risk after step rounding and capping
if(lots > 0.0 && (lots * lossPerLot) > riskMoney * 1.05)
{
lots = MathFloor(riskMoney / lossPerLot / g_volumeStep + 1e-8) * g_volumeStep;
lots = NormalizeDouble(lots, VolumeDigits());
}
if(lots < g_volumeMin)
{
// The requested risk cannot be expressed with the broker minimum volume
if(!InpAllowMinLotOverride)
{
PrintFormat("Entry skipped: computed volume %.4f is below the minimum %.4f and the override is disabled",
lots, g_volumeMin);
return 0.0;
}
lots = g_volumeMin;
}
const double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
const double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
double marginRequired = 0.0;
if(!OrderCalcMargin(ORDER_TYPE_BUY, _Symbol, lots, ask, marginRequired))
return 0.0;
while(marginRequired > freeMargin && lots > g_volumeMin)
{
lots = NormalizeDouble(lots - g_volumeStep, VolumeDigits());
if(lots < g_volumeMin)
return 0.0;
if(!OrderCalcMargin(ORDER_TYPE_BUY, _Symbol, lots, ask, marginRequired))
return 0.0;
}
if(marginRequired > freeMargin)
{
PrintFormat("Not enough free margin: required %.2f, available %.2f",
marginRequired, freeMargin);
return 0.0;
}
return lots;
}
//+------------------------------------------------------------------+
//| True when the symbol currently has an open trading session |
//| Session bounds are published as seconds from the start of the day.|
//| If the broker publishes no session table at all the function |
//| fails open instead of blocking every entry. |
//+------------------------------------------------------------------+
bool IsSessionOpen()
{
MqlDateTime now;
TimeToStruct(TimeCurrent(), now);
const long secondsToday = (long)now.hour * 3600 + (long)now.min * 60 + (long)now.sec;
bool anySession = false;
for(int i = 0; i < 16; i++)
{
datetime from = 0;
datetime to = 0;
if(!SymbolInfoSessionTrade(_Symbol, (ENUM_DAY_OF_WEEK)now.day_of_week, (uint)i, from, to))
break;
anySession = true;
const long start = (long)from;
const long end = (long)to;
if(end > start)
{
if(secondsToday >= start && secondsToday < end) return true;
}
else if(end < start)
{
// Session runs past midnight
if(secondsToday >= start || secondsToday < end) return true;
}
}
return !anySession;
}
//+------------------------------------------------------------------+
//| Broker stop distance validation |
//+------------------------------------------------------------------+
bool StopsAreValid(const int direction, const double entry, const double sl, const double tp)
{
double minDistance = (double)g_stopsLevel * g_point;
const double freezeDistance = (double)g_freezeLevel * g_point;
if(freezeDistance > minDistance) minDistance = freezeDistance;
if(minDistance <= 0.0) return true;
if(direction > 0)
{
if(sl > 0.0 && (entry - sl) < minDistance) return false;
if(tp > 0.0 && (tp - entry) < minDistance) return false;
}
else
{
if(sl > 0.0 && (sl - entry) < minDistance) return false;
if(tp > 0.0 && (entry - tp) < minDistance) return false;
}
return true;
}
//+------------------------------------------------------------------+
//| Risk percentage scaled by signal conviction |
//+------------------------------------------------------------------+
double EffectiveRiskPercent(const double score)
{
const double span = 1.0 - InpMinSignalScore;
double normalized = (span > 0.01) ? (score - InpMinSignalScore) / span : 1.0;
normalized = MathMax(0.0, MathMin(1.0, normalized));
return InpRiskPercentMin + (InpRiskPercentMax - InpRiskPercentMin) * normalized;
}
//+------------------------------------------------------------------+
//| Entry execution |
//+------------------------------------------------------------------+
bool OpenPosition(const int direction, const double score, const SCandle &trigger)
{
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
{
Print("Trading is disabled in the terminal");
return false;
}
if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
{
Print("Trading is disabled for this program");
return false;
}
if((long)AccountInfoInteger(ACCOUNT_TRADE_EXPERT) == 0)
{
Print("Automated trading is disabled on the account");
return false;
}
if((long)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_MODE) != (long)SYMBOL_TRADE_MODE_FULL)
{
Print("Entry skipped: the symbol is not in full trading mode");
return false;
}
if(!IsSessionOpen())
{
Print("Entry skipped: no trading session is open for this symbol right now");
return false;
}
const double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
const double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
if(ask <= 0.0 || bid <= 0.0) return false;
const double atr = AtrValue(1);
if(atr <= 0.0) return false;
const double entry = (direction > 0) ? ask : bid;
const double buffer = atr * InpStopBufferATR;
double sl = 0.0;
double tp = 0.0;
double stopDistance = 0.0;
if(direction > 0)
{
const double structuralStop = trigger.low - buffer;
const double volatilityStop = entry - atr * g_stopAtrMultiplier;
sl = MathMin(structuralStop, volatilityStop);
sl = NormalizePrice(sl);
stopDistance = entry - sl;
tp = NormalizePrice(entry + stopDistance * g_rewardRiskRatio);
}
else
{
const double structuralStop = trigger.high + buffer;
const double volatilityStop = entry + atr * g_stopAtrMultiplier;
sl = MathMax(structuralStop, volatilityStop);
sl = NormalizePrice(sl);
stopDistance = sl - entry;
tp = NormalizePrice(entry - stopDistance * g_rewardRiskRatio);
}
sl = NormalizePrice(sl);
tp = NormalizePrice(tp);
stopDistance = MathAbs(entry - sl);
if(stopDistance <= 0.0)
{
Print("Entry rejected: stop distance is zero after normalization");
return false;
}
if(!StopsAreValid(direction, entry, sl, tp))
{
PrintFormat("Entry rejected: stop distance %.5f is below the broker minimum", stopDistance);
return false;
}
const double riskPercent = EffectiveRiskPercent(score);
const double lots = CalculateLotSize(riskPercent, stopDistance);
if(lots <= 0.0)
{
Print("Entry rejected: position size cannot be calculated");
return false;
}
const bool sent = (direction > 0)
? g_trade.Buy(lots, _Symbol, 0.0, sl, tp, InpTradeComment)
: g_trade.Sell(lots, _Symbol, 0.0, sl, tp, InpTradeComment);
const uint retcode = g_trade.ResultRetcode();
// A market request must be filled, an accepted pending order is not an entry
const bool filled = (retcode == TRADE_RETCODE_DONE || retcode == TRADE_RETCODE_DONE_PARTIAL);
if(!sent || !filled)
{
PrintFormat("Order rejected: %d - %s", retcode, RetcodeDescription(retcode));
return false;
}
g_lastEntryTime = TimeCurrent();
const string side = (direction > 0) ? "BUY" : "SELL";
PrintFormat("%s opened on %s: volume %.2f, risk %.2f%%, score %.2f, SL %.5f, TP %.5f, ATR %.5f",
side, _Symbol, lots, riskPercent, score, sl, tp, atr);
return true;
}
//+------------------------------------------------------------------+
//| Breakeven and ATR trailing for EA-owned positions |
//+------------------------------------------------------------------+
void ManageOpenPositions()
{
if(!InpUseBreakeven && !InpUseAtrTrailing) return;
const double atr = AtrValue(1);
if(atr <= 0.0) return;
const double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
const double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
if(bid <= 0.0 || ask <= 0.0) return;
double minDistance = (double)g_stopsLevel * g_point;
if(minDistance < 10.0 * g_point) minDistance = 10.0 * g_point;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
const ulong ticket = PositionGetTicket(i);
if(ticket == 0) continue;
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
if((long)PositionGetInteger(POSITION_MAGIC) != (long)InpMagicNumber) continue;
const long type = PositionGetInteger(POSITION_TYPE);
const double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
const double currentSl = PositionGetDouble(POSITION_SL);
const double currentTp = PositionGetDouble(POSITION_TP);
double targetSl = currentSl;
if(type == (long)POSITION_TYPE_BUY)
{
if(InpUseBreakeven && bid >= openPrice + atr * InpBreakevenTriggerATR)
{
const double candidate = openPrice + InpBreakevenOffsetPts * g_point;
if(currentSl <= 0.0 || candidate > targetSl) targetSl = candidate;
}
if(InpUseAtrTrailing)
{
const double candidate = bid - atr * InpTrailAtrMultiplier;
if(currentSl <= 0.0 || candidate > targetSl) targetSl = candidate;
}
targetSl = NormalizePrice(targetSl);
if(targetSl <= 0.0) continue;
if(currentSl > 0.0 && targetSl <= currentSl) continue;
if((bid - targetSl) < minDistance) continue;
}
else if(type == (long)POSITION_TYPE_SELL)
{
if(InpUseBreakeven && ask <= openPrice - atr * InpBreakevenTriggerATR)
{
const double candidate = openPrice - InpBreakevenOffsetPts * g_point;
if(currentSl <= 0.0 || candidate < targetSl) targetSl = candidate;
}
if(InpUseAtrTrailing)
{
const double candidate = ask + atr * InpTrailAtrMultiplier;
if(currentSl <= 0.0 || candidate < targetSl) targetSl = candidate;
}
targetSl = NormalizePrice(targetSl);
if(targetSl <= 0.0) continue;
if(currentSl > 0.0 && targetSl >= currentSl) continue;
if((targetSl - ask) < minDistance) continue;
}
else
{
continue;
}
if(MathAbs(targetSl - currentSl) < InpTrailStepPoints * g_point) continue;
if(!g_trade.PositionModify(ticket, targetSl, currentTp))
PrintFormat("Modify request for #%s failed: %d - %s",
IntegerToString((long)ticket),
g_trade.ResultRetcode(),
RetcodeDescription(g_trade.ResultRetcode()));
}
}
//+------------------------------------------------------------------+
//| On-chart status |
//+------------------------------------------------------------------+
void UpdateDashboard()
{
if(!InpShowDashboard) return;
// The chart label is diagnostic only: one refresh per second is enough
static datetime lastRefresh = 0;
const datetime now = TimeCurrent();
if(now == lastRefresh) return;
lastRefresh = now;
const double balance = AccountInfoDouble(ACCOUNT_BALANCE);
const double equity = AccountInfoDouble(ACCOUNT_EQUITY);
const double dailyPct = (g_state.e_day0 > 0.0)
? (equity - g_state.e_day0) / g_state.e_day0 * 100.0
: 0.0;
const double staticDd = (g_state.b_init > 0.0)
? (g_state.b_init - equity) / g_state.b_init * 100.0
: 0.0;
const double targetBalance = g_state.b_init * (1.0 + InpEquityGrowthTargetPct / 100.0);
const double targetProgress = (targetBalance > g_state.b_init)
? (equity - g_state.b_init) / (targetBalance - g_state.b_init) * 100.0
: 0.0;
string status = "ACTIVE";
if(!g_riskStateValid) status = "STOPPED - risk state invalid";
else if(g_stateStorageFault) status = "STOPPED - risk state storage fault";
else if(g_state.static_halt) status = "STOPPED - static drawdown cap";
else if(g_state.daily_halt) status = "PAUSED - daily loss cap";
else if(g_state.target_secured) status = "STOPPED - target secured";
else if(g_state.target_triggered) status = "STOPPED - target triggered, closing";
string text = "";
text += "Candle Pressure EA | " + _Symbol + " " + EnumToString(InpWorkTimeframe) + "\n";
text += "Status: " + status + "\n";
text += StringFormat("Equity %.2f | Balance %.2f\n", equity, balance);
text += StringFormat("Day result %.2f%% (cap %.1f%%)\n", dailyPct, InpDailyMaxLossPercent);
text += StringFormat("Static drawdown %.2f%% (cap %.1f%%)\n", staticDd, InpStaticMaxDdPercent);
text += StringFormat("Target balance %.2f (%.1f%%)\n", targetBalance, targetProgress);
text += StringFormat("Risk archive slot %s | sequence %I64u\n",
(g_stateSlot == CP_SLOT_A ? "A" : "B"), g_state.seq);
text += StringFormat("Open positions %d of %d\n", CountOwnPositions(), InpMaxOpenPositions);
Comment(text);
}
//+------------------------------------------------------------------+
//| Expert initialization |
//+------------------------------------------------------------------+
int OnInit()
{
// --- Input validation ------------------------------------------
if(InpStopAtrMultiplier <= 0.0 || InpRewardRiskRatio <= 0.0 || InpStopBufferATR < 0.0)
{
Print("Invalid input: stop distance and reward to risk must be positive, the stop buffer cannot be negative");
return INIT_PARAMETERS_INCORRECT;
}
if(InpAtrPeriod < 2 || (InpUseAdxFilter && InpAdxPeriod < 2))
{
Print("Invalid input: the ATR and ADX periods must be at least 2");
return INIT_PARAMETERS_INCORRECT;
}
if(InpMinBarsBetweenTrades < 0)
{
Print("Invalid input: the minimum bars between trades cannot be negative");
return INIT_PARAMETERS_INCORRECT;
}
if(InpSweepLookback < 1 || InpSweepDepth < 2)
{
Print("Invalid input: the sweep window must be at least 1 bar and the sweep depth at least 2 bars");
return INIT_PARAMETERS_INCORRECT;
}
if(InpBosConfirmBars < 1)
{
Print("Invalid input: the break of structure confirmation window must be at least 1 bar");
return INIT_PARAMETERS_INCORRECT;
}
if(InpDailyMaxLossPercent <= 0.0 || InpDailyMaxLossPercent > 50.0)
{
Print("Invalid input: daily maximum loss must be between 0 and 50 percent");
return INIT_PARAMETERS_INCORRECT;
}
if(InpStaticMaxDdPercent <= 0.0 || InpStaticMaxDdPercent > 50.0)
{
Print("Invalid input: static maximum drawdown must be between 0 and 50 percent");
return INIT_PARAMETERS_INCORRECT;
}
if(InpEquityGrowthTargetPct <= 0.0 || InpEquityGrowthTargetPct > 1000.0)
{
Print("Invalid input: equity growth target must be between 0 and 1000 percent");
return INIT_PARAMETERS_INCORRECT;
}
if(InpRiskPercentMin <= 0.0 || InpRiskPercentMax < InpRiskPercentMin)
{
Print("Invalid input: risk range is inconsistent");
return INIT_PARAMETERS_INCORRECT;
}
if(InpMinSignalScore < 0.10 || InpMinSignalScore > 1.0)
{
Print("Invalid input: minimum signal score must be between 0.10 and 1.00");
return INIT_PARAMETERS_INCORRECT;
}
if(InpSwingLookback < 3 || InpRangeLookback < 10 || InpZoneLookback < 4)
{
Print("Invalid input: context lookbacks are too small");
return INIT_PARAMETERS_INCORRECT;
}
if(InpHtfTimeframe <= InpWorkTimeframe)
{
Print("Invalid input: the higher timeframe must be larger than the signal timeframe");
return INIT_PARAMETERS_INCORRECT;
}
if(InpMaxOpenPositions < 1)
{
Print("Invalid input: at least one position must be allowed");
return INIT_PARAMETERS_INCORRECT;
}
if(StringLen(InpRiskScopeId) == 0 || StringLen(InpRiskPeriodId) == 0)
{
Print("Invalid input: the risk scope id and the risk period id must not be empty");
return INIT_PARAMETERS_INCORRECT;
}
// --- Instrument recognition -----------------------------------
string symbolName = _Symbol;
StringToUpper(symbolName);
g_isGold = (StringFind(symbolName, "XAU") >= 0 || StringFind(symbolName, "GOLD") >= 0);
g_isSilver = (StringFind(symbolName, "XAG") >= 0 || StringFind(symbolName, "SILVER") >= 0);
g_stopAtrMultiplier = InpStopAtrMultiplier;
g_rewardRiskRatio = InpRewardRiskRatio;
g_rangeLookback = InpRangeLookback;
if(g_isGold && InpUseGoldProfile)
{
g_stopAtrMultiplier = InpGoldStopAtrMult;
g_rewardRiskRatio = InpGoldRewardRisk;
g_rangeLookback = InpGoldRangeLookback;
}
else if(g_isSilver && InpUseSilverProfile)
{
g_stopAtrMultiplier = InpSilverStopAtrMult;
g_rewardRiskRatio = InpSilverRewardRisk;
g_rangeLookback = InpSilverRangeLookback;
}
// --- Symbol geometry ------------------------------------------
g_digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
g_point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
g_tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
g_volumeMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
g_volumeMax = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
g_volumeStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
g_stopsLevel = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
g_freezeLevel = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_FREEZE_LEVEL);
if(g_point <= 0.0 || g_digits <= 0)
{
Print("Symbol geometry is not available yet");
return INIT_FAILED;
}
if(g_tickSize <= 0.0) g_tickSize = g_point;
if(g_volumeStep <= 0.0) g_volumeStep = g_volumeMin;
// A broker can publish a per-order volume limit below the symbol maximum
const double volumeLimit = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_LIMIT);
if(volumeLimit > 0.0 && volumeLimit < g_volumeMax)
g_volumeMax = volumeLimit;
// --- History requirement --------------------------------------
g_historyBars = g_rangeLookback + InpSwingLookback + InpBosConfirmBars
+ InpZoneLookback + InpSweepLookback + InpSweepDepth + 30;
if(g_historyBars < InpRangeLookback + InpSwingLookback + InpBosConfirmBars + 30)
g_historyBars = InpRangeLookback + InpSwingLookback + InpBosConfirmBars + 30;
// --- Indicator handles ----------------------------------------
g_htfEmaHandle = iMA(_Symbol, InpHtfTimeframe, InpHtfEmaPeriod, 0, MODE_EMA, PRICE_CLOSE);
g_atrHandle = iATR(_Symbol, InpWorkTimeframe, InpAtrPeriod);
g_adxHandle = InpUseAdxFilter ? iADX(_Symbol, InpWorkTimeframe, InpAdxPeriod) : INVALID_HANDLE;
if(g_htfEmaHandle == INVALID_HANDLE || g_atrHandle == INVALID_HANDLE)
{
PrintFormat("Failed to create indicator handles, error %d", GetLastError());
return INIT_FAILED;
}
if(InpUseAdxFilter && g_adxHandle == INVALID_HANDLE)
{
PrintFormat("Failed to create the ADX handle, error %d", GetLastError());
return INIT_FAILED;
}
// --- Trade object ---------------------------------------------
g_trade.SetExpertMagicNumber((ulong)InpMagicNumber);
g_trade.SetDeviationInPoints(20);
g_trade.SetTypeFillingBySymbol(_Symbol);
g_trade.SetAsyncMode(false);
// --- Equity baselines and persistent risk state -----------------
const double liveBalance = AccountInfoDouble(ACCOUNT_BALANCE);
if(liveBalance <= 0.0)
{
Print("Account balance is not available yet");
return INIT_FAILED;
}
// R01-H4: make the risk identity explicit in the journal before any state decision
PrintFormat("Risk identity %016I64X: login %I64d, server '%s', scope '%s', period '%s', magic %I64d, %s %s",
StateIdentity(), AccountInfoInteger(ACCOUNT_LOGIN), AccountInfoString(ACCOUNT_SERVER),
InpRiskScopeId, InpRiskPeriodId, InpMagicNumber, _Symbol,
EnumToString(InpWorkTimeframe));
if(!StatePersistenceEnabled())
{
// Tester isolation: every run must start from its own deposit
StateInitFresh();
g_stateSlot = CP_SLOT_A;
g_stateSlotKnown = false;
g_riskStateValid = true;
g_stateStorageFault = false;
StateSave();
Print("Tester mode: risk state is deliberately not persisted between runs.");
}
else
{
// R-01 v1.2 provisioning state machine and recovery decision table
const int initResult = StateProvisionOrRestore();
if(initResult == CP_INIT_FAILED)
return INIT_FAILED;
if(initResult == CP_INIT_DENIED)
{
// The EA stays loaded, but g_riskStateValid keeps every entry path closed
g_riskStateValid = false;
g_stateStorageFault = false;
}
}
if(g_riskStateValid)
{
if(g_state.daily_halt != 0) Print("Restored state: daily loss cap already hit today, trading stays paused");
if(g_state.static_halt != 0) Print("Restored state: static drawdown cap already hit, trading stays stopped");
if(g_state.target_triggered != 0) Print("Restored state: growth target already reached, trading stays stopped");
}
g_lastBarTime = 0;
g_lastEntryTime = 0;
if(g_riskStateValid && !InitializeDailyAnchor())
Print("CRITICAL: the daily anchor could not be stored; entries stay disabled");
// --- Diagnostics ----------------------------------------------
PrintFormat("Candle Pressure EA initialized on %s (%s), higher timeframe %s",
_Symbol, EnumToString(InpWorkTimeframe), EnumToString(InpHtfTimeframe));
if(g_riskStateValid)
PrintFormat("Baselines: initial balance %.2f, initial equity %.2f, target balance %.2f",
g_state.b_init, g_state.e_init,
g_state.b_init * (1.0 + InpEquityGrowthTargetPct / 100.0));
PrintFormat("Hard limits: daily loss %.2f%%, static drawdown %.2f%%",
InpDailyMaxLossPercent, InpStaticMaxDdPercent);
PrintFormat("Stop distance %.2f ATR, reward to risk %.2f, dealing range %d bars",
g_stopAtrMultiplier, g_rewardRiskRatio, g_rangeLookback);
if(g_isGold) Print("Gold profile active");
else if(g_isSilver) Print("Silver profile active");
else Print("No metal profile matched, generic parameters are used");
if((long)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_MODE) != (long)SYMBOL_TRADE_MODE_FULL)
Print("Warning: the symbol is not in full trading mode");
UpdateDashboard();
return INIT_SUCCEEDED;
}
//+------------------------------------------------------------------+
//| Expert deinitialization |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
if(g_htfEmaHandle != INVALID_HANDLE) IndicatorRelease(g_htfEmaHandle);
if(g_atrHandle != INVALID_HANDLE) IndicatorRelease(g_atrHandle);
if(g_adxHandle != INVALID_HANDLE) IndicatorRelease(g_adxHandle);
g_htfEmaHandle = INVALID_HANDLE;
g_atrHandle = INVALID_HANDLE;
g_adxHandle = INVALID_HANDLE;
Comment("");
if(reason == REASON_REMOVE)
Print("Candle Pressure EA removed from the chart");
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
const bool tradingAllowed = EvaluateEquityGuard();
ManageOpenPositions();
UpdateDashboard();
if(!tradingAllowed) return;
// Signals are evaluated once per closed bar
const datetime barTime = iTime(_Symbol, InpWorkTimeframe, 0);
if(barTime == 0) return;
if(barTime == g_lastBarTime) return;
// Gates that can clear inside the same bar must not consume the bar. Marking the bar
// before them discarded every signal that appeared while the spread was wide or a
// position was still open, which is exactly what happens at the daily rollover.
if(CountOwnPositions() >= InpMaxOpenPositions) return;
if(g_lastEntryTime > 0 &&
(TimeCurrent() - g_lastEntryTime) < (long)InpMinBarsBetweenTrades * PeriodSeconds(InpWorkTimeframe))
return;
const double spreadPoints = (SymbolInfoDouble(_Symbol, SYMBOL_ASK) - SymbolInfoDouble(_Symbol, SYMBOL_BID)) / g_point;
if(spreadPoints > InpMaxSpreadPoints)
{
// Throttled because this path is now retried on every tick of the same bar
static datetime lastSpreadLog = 0;
if(TimeCurrent() - lastSpreadLog >= 60)
{
lastSpreadLog = TimeCurrent();
PrintFormat("Entry delayed: spread %.1f points exceeds the limit %.1f, retrying on the next tick",
spreadPoints, InpMaxSpreadPoints);
}
return;
}
// The bar is consumed only once the signal engine actually runs
g_lastBarTime = barTime;
double score = 0.0;
SCandle trigger;
const int direction = DetectSignal(score, trigger);
if(direction == 0) return;
OpenPosition(direction, score, trigger);
}
//+------------------------------------------------------------------+
//| Trade transaction log for EA-owned deals |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
if(trans.type != TRADE_TRANSACTION_DEAL_ADD) return;
if(!HistoryDealSelect(trans.deal)) return;
if((long)HistoryDealGetInteger(trans.deal, DEAL_MAGIC) != (long)InpMagicNumber) return;
if(HistoryDealGetString(trans.deal, DEAL_SYMBOL) != _Symbol) return;
if((long)HistoryDealGetInteger(trans.deal, DEAL_ENTRY) == (long)DEAL_ENTRY_IN) return;
const double net = HistoryDealGetDouble(trans.deal, DEAL_PROFIT)
+ HistoryDealGetDouble(trans.deal, DEAL_SWAP)
+ HistoryDealGetDouble(trans.deal, DEAL_COMMISSION);
if(net != 0.0)
PrintFormat("Deal #%s closed with a net result of %.2f",
IntegerToString((long)trans.deal), net);
}
//+------------------------------------------------------------------+