forex-scalping.com

Code: Select all

void CalculateAbsoluteStopsFromVWAP(int index) 
{
    // 1. Data Integrity Check
    // A VWAP of 0.0 means the array is corrupted or deals didn't process correctly
    if (ActiveTrades[index].vwap_price <= 0.0) 
    {
        PrintFormat("CRITICAL: Invalid VWAP (%f) for Order %I64u", 
                    ActiveTrades[index].vwap_price, ActiveTrades[index].order_ticket);
        return;
    }

    double vwap = ActiveTrades[index].vwap_price;
    ENUM_POSITION_TYPE posType = ActiveTrades[index].pos_type; 
    
    // 2. Fractional Tick Scaling
    // Safely scales pips to points regardless of the broker's decimal structure
    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
    double pipMultiplier = (digits == 3 || digits == 5) ? 10.0 : 1.0;
    
    // Convert the struct's intended pip limits into raw price distances
    double slDistance = ActiveTrades[index].target_sl_pips * pipMultiplier * point;
    double tpDistance = ActiveTrades[index].target_tp_pips * pipMultiplier * point;

    double rawSL = 0.0;
    double rawTP = 0.0;

    // 3. Directional Application
    // Buys subtract SL and add TP. Sells add SL and subtract TP.
    if (posType == POSITION_TYPE_BUY) 
    {
        if (slDistance > 0) rawSL = vwap - slDistance;
        if (tpDistance > 0) rawTP = vwap + tpDistance;
    }
    else if (posType == POSITION_TYPE_SELL) 
    {
        if (slDistance > 0) rawSL = vwap + slDistance;
        if (tpDistance > 0) rawTP = vwap - tpDistance;
    }

    // 4. Floating-Point Sterilization
    // OrderSend will reject un-normalized doubles with Error 130/10016 instantly.
    ActiveTrades[index].target_sl = (rawSL > 0.0) ? NormalizeDouble(rawSL, digits) : 0.0;
    ActiveTrades[index].target_tp = (rawTP > 0.0) ? NormalizeDouble(rawTP, digits) : 0.0;
    
    PrintFormat("Order %I64u VWAP Sweep Complete -> VWAP: %.*f | Hard SL: %.*f | Hard TP: %.*f", 
                ActiveTrades[index].order_ticket, 
                digits, vwap, 
                digits, ActiveTrades[index].target_sl, 
                digits, ActiveTrades[index].target_tp);
}

Code: Select all

enum ENUM_ORDER_STATE 
{
    // ... previous states ...
    STATE_EMERGENCY_LIQUIDATING  // Disaster stop hit, async close dispatched
};

struct TradeContext 
{
    // ... previous variables ...
    double disaster_sl_pips;     // E.g., 15.0 pips (well outside normal scalping range)
};

Code: Select all

void CheckVirtualDisasterStops() 
{
    // 1. Grab the absolute latest memory tick (bypasses potential OnTick variable lag)
    MqlTick latestTick;
    if (!SymbolInfoTick(_Symbol, latestTick)) return; 

    // Calculate conversion multipliers once per tick, not per array iteration
    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
    double pipMultiplier = (digits == 3 || digits == 5) ? 10.0 : 1.0;

    for (int i = 0; i < ArraySize(ActiveTrades); i++) 
    {
        // 2. State Filter: Only evaluate vulnerable, partially or fully filled positions
        if ((ActiveTrades[i].state == STATE_ENTRY_PENDING || ActiveTrades[i].state == STATE_FILLED_NO_STOPS) 
             && ActiveTrades[i].filled_volume > 0.0) 
        {
            double vwap = ActiveTrades[i].vwap_price;
            double disasterDist = ActiveTrades[i].disaster_sl_pips * pipMultiplier * point;
            
            bool triggerLiquidation = false;

            // 3. Directional VWAP vs. Real-Time Tick Check
            if (ActiveTrades[i].pos_type == POSITION_TYPE_BUY) 
            {
                // Buy stops trigger on the BID
                if (latestTick.bid <= (vwap - disasterDist)) triggerLiquidation = true;
            }
            else if (ActiveTrades[i].pos_type == POSITION_TYPE_SELL) 
            {
                // Sell stops trigger on the ASK
                if (latestTick.ask >= (vwap + disasterDist)) triggerLiquidation = true;
            }

            // 4. Execute Emergency Protocol
            if (triggerLiquidation) 
            {
                PrintFormat("CRITICAL: Flash crash detected. VWAP: %f | Tick: %f/%f. Firing Emergency Close.", 
                            vwap, latestTick.bid, latestTick.ask);
                
                ExecuteEmergencyLiquidation(i, latestTick);
            }
        }
    }
}

Code: Select all

void ExecuteEmergencyLiquidation(int index, const MqlTick &latestTick) 
{
    MqlTradeRequest request = {};
    MqlTradeResult result = {};
    
    request.action       = TRADE_ACTION_DEAL;
    request.position     = ActiveTrades[index].position_ticket;
    request.symbol       = _Symbol;
    // CRITICAL: Close only what has been filled so far
    request.volume       = ActiveTrades[index].filled_volume;  
    request.deviation    = 50; // Wide deviation permitted during a flash crash
    request.magic        = ActiveTrades[index].magic_number;

    if (ActiveTrades[index].pos_type == POSITION_TYPE_BUY) 
    {
        request.type = ORDER_TYPE_SELL;
        request.price = latestTick.bid;
    }
    else 
    {
        request.type = ORDER_TYPE_BUY;
        request.price = latestTick.ask;
    }

    // Lock the state so OnTradeTransaction ignores subsequent HISTORY_ADD sweeps
    ActiveTrades[index].state = STATE_EMERGENCY_LIQUIDATING;

    if (!OrderSendAsync(request, result)) 
    {
        PrintFormat("Failed to dispatch async emergency liquidation! Error: %d", GetLastError());
        // Failsafe: Revert state to allow the next tick to retry the liquidation
        ActiveTrades[index].state = STATE_FILLED_NO_STOPS; 
    }
    else 
    {
        // Store the new request ID so OnTradeTransaction can track the close
        ActiveTrades[index].request_id = result.request_id;
    }
}

Code: Select all

void ExecuteEmergencyLiquidation(int index, const MqlTick &latestTick) 
{
    // ==========================================
    // STEP 1: CANCEL THE REMAINING WORKING ORDER
    // ==========================================
    // This stops the bleeding and prevents new volume from filling
    
    MqlTradeRequest cancelRequest = {};
    MqlTradeResult  cancelResult  = {};
    
    cancelRequest.action = TRADE_ACTION_REMOVE;
    cancelRequest.order  = ActiveTrades[index].order_ticket;
    
    // Dispatch the cancel. We do not check for failure here because the 
    // order may have fully filled a millisecond ago, which would cause this to fail.
    OrderSendAsync(cancelRequest, cancelResult);


    // ==========================================
    // STEP 2: LIQUIDATE THE HELD POSITION
    // ==========================================
    
    MqlTradeRequest closeRequest = {};
    MqlTradeResult  closeResult  = {};
    
    closeRequest.action       = TRADE_ACTION_DEAL;
    closeRequest.position     = ActiveTrades[index].position_ticket;
    closeRequest.symbol       = _Symbol;
    closeRequest.volume       = ActiveTrades[index].filled_volume;  
    closeRequest.deviation    = 50; // Extreme deviation permitted to guarantee exit
    closeRequest.magic        = ActiveTrades[index].magic_number;

    if (ActiveTrades[index].pos_type == POSITION_TYPE_BUY) 
    {
        closeRequest.type  = ORDER_TYPE_SELL;
        closeRequest.price = latestTick.bid;
    }
    else 
    {
        closeRequest.type  = ORDER_TYPE_BUY;
        closeRequest.price = latestTick.ask;
    }

    // Lock the state to prevent the standard architecture from interfering
    ActiveTrades[index].state = STATE_EMERGENCY_LIQUIDATING;

    if (!OrderSendAsync(closeRequest, closeResult)) 
    {
        PrintFormat("CRITICAL: Failed to dispatch liquidation! Error: %d", GetLastError());
        // Failsafe: unlock state so the next OnTick loop tries again
        ActiveTrades[index].state = STATE_FILLED_NO_STOPS; 
    }
    else 
    {
        // Store the close request ID to track its success in OnTradeTransaction
        ActiveTrades[index].request_id = closeResult.request_id;
    }
}

Code: Select all

if (trans.type == TRADE_TRANSACTION_REQUEST) 
{
    int index = FindTradeByRequestId(result.request_id);
    
    // If the cancel request failed because the order finished filling 
    // immediately before our cancel arrived (Error 10013: Invalid Request), ignore it.
    if (result.retcode == TRADE_RETCODE_INVALID) 
    {
        Print("Notice: Cancel request rejected. Order likely already fully filled or closed.");
        return; 
    }

    if (index >= 0 && ActiveTrades[index].state == STATE_EMERGENCY_LIQUIDATING) 
    {
        if (result.retcode == TRADE_RETCODE_DONE || result.retcode == TRADE_RETCODE_PLACED) 
        {
            Print("Emergency Liquidation successful.");
            // Optional: Remove the trade from your ActiveTrades array here
        }
        else 
        {
            PrintFormat("Emergency Liquidation failed! Retcode: %d. Re-queuing.", result.retcode);
            // Revert state to allow OnTick to fire another close attempt
            ActiveTrades[index].state = STATE_FILLED_NO_STOPS; 
        }
        return;
    }
    
    // ... standard retry logic for normal operations ...
}