forex-scalping.com

Code: Select all

//@version=5
strategy("CPI Execution Reality", overlay=true, slippage=40, commission_type=strategy.commission.cash_per_contract, commission_value=2.0)

// --- Desk Rule Inputs ---
newsTime = input.session("0830-0835", "News Window (EST)")
timeStopBars = input.int(3, "Time Stop (Bars/Minutes)")
riskPerTrade = input.float(2.0, "Standard Risk (%)")
halfSizeNews = input.bool(true, "Half Size for News Print?")

// --- Time & Sizing Logic ---
// Convert chart time to EST to catch the CPI print accurately
inNewsWindow = not na(time(timeframe.period, newsTime, "America/New_York"))

// Halve the risk if trading inside the news window
actualRisk = inNewsWindow and halfSizeNews ? (riskPerTrade / 2) : riskPerTrade
qty = (strategy.equity * (actualRisk / 100)) / close 

// --- Simulated M1 Signal ---
// Replace this with your actual edge/trigger logic
volatilitySpike = ta.atr(14) > ta.sma(ta.atr(14), 50) * 1.5
longSignal = inNewsWindow and close > open and volatilitySpike
shortSignal = inNewsWindow and close < open and volatilitySpike

// --- Execution ---
if longSignal and strategy.position_size == 0
    strategy.entry("CPI_Long", strategy.long, qty=qty)

if shortSignal and strategy.position_size == 0
    strategy.entry("CPI_Short", strategy.short, qty=qty)

// --- Hard Time Stop Management ---
var int barsInTrade = 0
if strategy.position_size != 0
    barsInTrade += 1
else
    barsInTrade := 0

if barsInTrade >= timeStopBars
    strategy.close_all(comment="Time Stop - Flat")

Code: Select all

//@version=5
strategy("Institutional Execution Reality & Audit", overlay=true, calc_on_every_tick=true, max_labels_count=50, max_lines_count=50, slippage=40, commission_type=strategy.commission.cash_per_contract, commission_value=2.0)

// =========================================================================
// 1. DESK PARAMETERS & CONFIGURATION
// =========================================================================
var string G_RISK  = "Risk & Sizing (Desk Rules)"
var string G_EXEC  = "Execution & Time Constraints"

riskPerTradePct    = input.float(1.0, "Standard Risk (%)", step=0.1, group=G_RISK)
newsRiskModifier   = input.float(0.5, "News Risk Multiplier (e.g., 0.5 = Half Size)", step=0.1, group=G_RISK)
minStopDistance    = input.float(10.0, "Minimum Stop Distance (Ticks)", group=G_RISK)

newsSession        = input.session("0830-0835", "High-Impact Release Window (EST)", group=G_EXEC)
hardTimeStop       = input.int(3, "Hard Time Stop (Minutes/Bars)", group=G_EXEC)
maxSpreadTolerated = input.float(5.0, "Max Acceptable Spread Blowout (Ticks)", group=G_EXEC)

// =========================================================================
// 2. TYPES & STATE MANAGEMENT
// =========================================================================
// Custom type to manage the lifecycle and audit of a single trade
type ExecutionState
    float intendedEntry
    float actualFill
    float stopLoss
    int   entryBarIndex
    float spreadAtClick
    bool  isActive

var ExecutionState currentTrade = ExecutionState.new(na, na, na, na, na, false)

// =========================================================================
// 3. CORE LOGIC & MICROSTRUCTURE SIZING
// =========================================================================
// Timezone conversion to catch the exact print regardless of local exchange time
inNewsWindow = not na(time(timeframe.period, newsSession, "America/New_York"))

// Dynamic Risk Sizing Method
method calculatePositionSize(float riskPct, float stopDistanceTicks) =>
    adjustedRisk = inNewsWindow ? (riskPct * newsRiskModifier) : riskPct
    riskAmount   = (strategy.equity * (adjustedRisk / 100))
    tickValue    = syminfo.mintick * syminfo.pointvalue
    qty          = riskAmount / math.max(stopDistanceTicks * tickValue, 1e-5)
    math.floor(qty)

// Simulated Spread Blowout (Since Pine lacks historical Bid/Ask)
// We use a fraction of the M1 ATR to simulate the spread widening exactly at 08:30:00
simulatedSpread = ta.atr(5) * 0.2 
spreadViolated  = (simulatedSpread / syminfo.mintick) > maxSpreadTolerated

// =========================================================================
// 4. SIGNAL GENERATION (REPLACE WITH RAW PRICE ACTION LOGIC)
// =========================================================================
// Mock setup: 1-minute liquidity sweep and structural shift
bullishSweep = low < ta.lowest(low[1], 10) and close > open
bearishSweep = high > ta.highest(high[1], 10) and close < open

longTrigger  = inNewsWindow and bullishSweep and not spreadViolated
shortTrigger = inNewsWindow and bearishSweep and not spreadViolated

// =========================================================================
// 5. EXECUTION & AUDITING
// =========================================================================
float slDistanceTicks = math.max(ta.atr(14) / syminfo.mintick, minStopDistance)

if longTrigger and not currentTrade.isActive
    currentTrade.intendedEntry := close
    currentTrade.spreadAtClick := simulatedSpread / syminfo.mintick
    currentTrade.stopLoss      := close - (slDistanceTicks * syminfo.mintick)
    currentTrade.entryBarIndex := bar_index
    currentTrade.isActive      := true
    
    qty = calculatePositionSize(riskPerTradePct, slDistanceTicks)
    strategy.entry("Desk_Long", strategy.long, qty=qty)

if shortTrigger and not currentTrade.isActive
    currentTrade.intendedEntry := close
    currentTrade.spreadAtClick := simulatedSpread / syminfo.mintick
    currentTrade.stopLoss      := close + (slDistanceTicks * syminfo.mintick)
    currentTrade.entryBarIndex := bar_index
    currentTrade.isActive      := true
    
    qty = calculatePositionSize(riskPerTradePct, slDistanceTicks)
    strategy.entry("Desk_Short", strategy.short, qty=qty)

// Update actual fill price on the next tick/bar
if currentTrade.isActive and currentTrade.entryBarIndex == bar_index[1]
    currentTrade.actualFill := strategy.opentrades.entry_price(strategy.opentrades - 1)

// =========================================================================
// 6. HARD EXITS & TIME STOPS
// =========================================================================
barsHeld = currentTrade.isActive ? (bar_index - currentTrade.entryBarIndex) : 0

if currentTrade.isActive
    // Time Stop
    if barsHeld >= hardTimeStop
        strategy.close_all(comment="Time Stop")
        currentTrade.isActive := false
    // Hard Stop Loss
    else
        strategy.exit("Risk_Out", from_entry="Desk_Long", stop=currentTrade.stopLoss)
        strategy.exit("Risk_Out", from_entry="Desk_Short", stop=currentTrade.stopLoss)
        if strategy.position_size == 0
            currentTrade.isActive := false

// =========================================================================
// 7. DASHBOARD: THE FILL LOG
// =========================================================================
var table auditTable = table.new(position.bottom_right, 2, 5, bgcolor=color.new(color.black, 20), border_width=1, border_color=color.gray)

if barstate.islast
    table.cell(auditTable, 0, 0, "LAST AUDIT", text_color=color.white, text_halign=text.align_left)
    table.cell(auditTable, 1, 0, "VALUE", text_color=color.white, text_halign=text.align_right)
    
    table.cell(auditTable, 0, 1, "Intended Entry", text_color=color.gray, text_halign=text.align_left)
    table.cell(auditTable, 1, 1, str.tostring(currentTrade.intendedEntry, format.mintick), text_color=color.white, text_halign=text.align_right)
    
    table.cell(auditTable, 0, 2, "Actual Fill (w/ Slip)", text_color=color.gray, text_halign=text.align_left)
    table.cell(auditTable, 1, 2, str.tostring(currentTrade.actualFill, format.mintick), text_color=color.white, text_halign=text.align_right)
    
    slipTicks = math.abs(currentTrade.intendedEntry - currentTrade.actualFill) / syminfo.mintick
    slipColor = slipTicks > 10 ? color.red : color.green
    table.cell(auditTable, 0, 3, "Slippage INCURRED", text_color=color.gray, text_halign=text.align_left)
    table.cell(auditTable, 1, 3, str.tostring(slipTicks) + " Ticks", text_color=slipColor, text_halign=text.align_right)
    
    table.cell(auditTable, 0, 4, "Spread at Click", text_color=color.gray, text_halign=text.align_left)
    table.cell(auditTable, 1, 4, str.tostring(currentTrade.spreadAtClick, "#.#") + " Ticks", text_color=color.white, text_halign=text.align_right)

Code: Select all

//+------------------------------------------------------------------+
//|                                     CPI_Execution_Audit_MT5.mq5  |
//|                    Institutional Market Microstructure Framework |
//+------------------------------------------------------------------+
#property strict
#include <Trade\Trade.mqh>

// --- DESK PARAMETERS ---
input int    NewsHourServerTime = 15;      // Server Time Hour for Print (e.g., 15 for 08:30 EST on EET)
input int    NewsMinuteStart    = 30;
input int    NewsMinuteEnd      = 35;
input double RiskPercent        = 1.0;     // Standard Risk (%)
input double NewsRiskModifier   = 0.5;     // 0.5 = Half Size
input int    MaxSpreadPoints    = 50;      // Max Acceptable Spread Blowout (Points)
input int    HardTimeStopBars   = 3;       // Time Stop (M1 Bars)
input int    MinStopDistancePts = 100;     // Minimum SL (Points)
input ulong  SlippageTolerance  = 40;      // Max allowed deviation (Points)

CTrade trade;
int    entryBarTime = 0;

int OnInit() {
    trade.SetExpertMagicNumber(1001);
    trade.SetDeviationInPoints(SlippageTolerance);
    
    // NDD/ECN brokers generally require Market Execution
    trade.SetTypeFilling(ORDER_FILLING_FOK); 
    return(INIT_SUCCEEDED);
}

void OnTick() {
    // 1. Time Constraints
    MqlDateTime dt;
    TimeCurrent(dt);
    bool inNewsWindow = (dt.hour == NewsHourServerTime && dt.min >= NewsMinuteStart && dt.min <= NewsMinuteEnd);

    // 2. Microstructure & Spread Filter
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
    int currentSpread = (int)MathRound((ask - bid) / _Point);
    bool spreadViolated = (currentSpread > MaxSpreadPoints);

    // 3. Hard Time Stop Management
    if(PositionsTotal() > 0) {
        if(PositionSelect(_Symbol)) {
            int currentBarTime = (int)iTime(_Symbol, PERIOD_M1, 0);
            int barsHeld = (currentBarTime - entryBarTime) / 60; // 60s per M1 bar
            
            if(barsHeld >= HardTimeStopBars) {
                trade.PositionClose(_Symbol);
                Print("DESK RULE: Hard Time Stop Triggered. Position Flattened.");
            }
        }
        return; // Suspend new signal checks while exposed
    }

    // 4. Signal Engine (Replace with your specific PA sweep logic)
    bool longTrigger = inNewsWindow && !spreadViolated; // Mock trigger

    // 5. Execution & Audit Trail
    if(longTrigger) {
        double intendedEntry = ask;
        double stopLoss = intendedEntry - (MinStopDistancePts * _Point);
        
        // Dynamic Risk Sizing
        double activeRisk = RiskPercent * NewsRiskModifier;
        double riskAmount = AccountInfoDouble(ACCOUNT_BALANCE) * (activeRisk / 100.0);
        double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
        double pointValue = tickValue / (SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE) / _Point);
        double volume = NormalizeDouble(riskAmount / (MinStopDistancePts * pointValue), 2);

        // Ping the timer for latency tracking
        uint startMS = GetTickCount();
        
        if(trade.Buy(volume, _Symbol, intendedEntry, stopLoss, 0, "CPI_Long")) {
            uint execTime = GetTickCount() - startMS;
            entryBarTime = (int)iTime(_Symbol, PERIOD_M1, 0);
            
            // Audit Log: Query the actual deal history to find true fill
            ulong dealTicket = trade.ResultDeal();
            if(HistoryDealSelect(dealTicket)) {
                double actualFill = HistoryDealGetDouble(dealTicket, DEAL_PRICE);
                int slippagePts = (int)MathRound(MathAbs(actualFill - intendedEntry) / _Point);
                
                Print("\n================ CPI FILL LOG AUDIT ================");
                PrintFormat("Intent (Click): %.5f | Actual Fill: %.5f", intendedEntry, actualFill);
                PrintFormat("Spread at Click: %d pts | Slippage Incurred: %d pts", currentSpread, slippagePts);
                PrintFormat("Broker Latency: %d ms", execTime);
                Print("====================================================");
            }
        } else {
            PrintFormat("Ticket Rejected. Spread: %d. Broker Code: %d", currentSpread, trade.ResultRetcode());
        }
    }
}

Code: Select all

//+------------------------------------------------------------------+
//| MT4 EXECUTION & AUDIT BLOCK (Place inside OnTick)                |
//+------------------------------------------------------------------+

// 1. Spread Check (Native MT4)
int currentSpread = (int)MarketInfo(Symbol(), MODE_SPREAD);
bool spreadViolated = (currentSpread > MaxSpreadPoints);

// ... (Time Check & Sizing logic remains procedurally similar to MT5) ...

if(longTrigger) {
    double intendedEntry = Ask;
    double stopLoss = intendedEntry - (MinStopDistancePts * Point);
    
    // Ping the timer
    uint startMS = GetTickCount();
    
    // Execute
    int ticket = OrderSend(Symbol(), OP_BUY, volume, intendedEntry, SlippageTolerance, stopLoss, 0, "CPI_Long", 1001, 0, Blue);
    
    // Calculate Latency
    uint execTime = GetTickCount() - startMS;

    if(ticket > 0) {
        entryBarTime = (int)Time[0]; // Anchor time stop
        
        // Audit Log: Select order to get true open price
        if(OrderSelect(ticket, SELECT_BY_TICKET)) {
            double actualFill = OrderOpenPrice();
            int slippagePts = (int)MathRound(MathAbs(actualFill - intendedEntry) / Point);
            
            Print("\n================ CPI FILL LOG AUDIT ================");
            PrintFormat("Intent: %.5f | Actual Fill: %.5f", intendedEntry, actualFill);
            PrintFormat("Spread at Click: %d pts | Slippage Incurred: %d pts", currentSpread, slippagePts);
            PrintFormat("Broker Latency: %d ms", execTime);
            Print("====================================================");
        }
    } else {
        PrintFormat("Ticket Rejected. Spread: %d. Broker Code: %d", currentSpread, GetLastError());
    }
}