forex-scalping.com

Code: Select all

//@version=5
indicator("PineConnector HA/VWAP Execution", overlay=true, calc_on_every_tick=true)

// =========================================================================
// 1. PINECONNECTOR CREDENTIALS & SIZING
// =========================================================================
grp_pc = "PineConnector Settings"
in_licenseID = input.string("1234567890", title="License ID", group=grp_pc)
in_brokerSymbol = input.string("EURUSD", title="Broker Ticker (e.g. EURUSD.m)", group=grp_pc)
in_tradeLots = input.float(0.1, title="Trade Size (Lots)", step=0.01, group=grp_pc)

grp_filters = "Filter Settings"
stdevMult = input.float(2.0, title="VWAP StDev Multiplier", group=grp_filters)
stopBuffer = input.float(2.0, title="Stop Buffer (Pips/Ticks)", group=grp_filters)
sessionDelay = input.int(30, title="Minutes to Block After Open", group=grp_filters)

grp_hvn = "Volume Profile"
hvnBinSize = input.int(10, title="Price Bin Size (Ticks)", group=grp_hvn)
hvnBlockZone = input.float(5.0, title="HVN Block Zone (Pips)", group=grp_hvn)

// =========================================================================
// 2. BACKGROUND HEIKIN ASHI ENGINE
// =========================================================================
var float haOpen = na
haClose = (open + high + low + close) / 4.0
haOpen := na(haOpen[1]) ? (open + close) / 2.0 : (haOpen[1] + haClose[1]) / 2.0
haHigh = math.max(high, math.max(haOpen, haClose))
haLow = math.min(low, math.min(haOpen, haClose))

isHAUp = haClose > haOpen
noLowerWick = isHAUp and (haOpen == haLow)

isHADown = haClose < haOpen
noUpperWick = isHADown and (haOpen == haHigh)

// =========================================================================
// 3. INSTITUTIONAL VWAP & SESSION TIMING
// =========================================================================
var float cumVol = 0.
var float cumVolPrice = 0.
var float cumVolPrice2 = 0.
var int sessionStartTime = na

isNewSession = timeframe.change("D") 

if isNewSession
    cumVol := 0.
    cumVolPrice := 0.
    cumVolPrice2 := 0.
    sessionStartTime := time

cumVol += volume
cumVolPrice += close * volume
cumVolPrice2 += volume * math.pow(close, 2)

vwapBase = cumVolPrice / cumVol
variance = (cumVolPrice2 / cumVol) - math.pow(vwapBase, 2)
vwapStDev = math.sqrt(math.max(0, variance))

upperVwapBand = vwapBase + (vwapStDev * stdevMult)
lowerVwapBand = vwapBase - (vwapStDev * stdevMult)

minutesSinceOpen = (time - sessionStartTime) / 60000
timeFilterPass = minutesSinceOpen >= sessionDelay

// =========================================================================
// 4. VOLUME PROFILE (POC) ARRAY ENGINE
// =========================================================================
var priceBins = array.new_float(0)
var volBins = array.new_float(0)
var float sessionPOC = na

if isNewSession
    array.clear(priceBins)
    array.clear(volBins)
    sessionPOC := na

tickSize = syminfo.mintick
binRounding = tickSize * hvnBinSize
currentBinPrice = math.round(close / binRounding) * binRounding

int binIndex = array.indexof(priceBins, currentBinPrice)
if binIndex == -1
    array.push(priceBins, currentBinPrice)
    array.push(volBins, volume)
else
    array.set(volBins, binIndex, array.get(volBins, binIndex) + volume)

if array.size(volBins) > 0
    maxVolIndex = array.indexof(volBins, array.max(volBins))
    sessionPOC := array.get(priceBins, maxVolIndex)

// =========================================================================
// 5. SIGNAL LOGIC
// =========================================================================
overextendedLong = close >= upperVwapBand
overextendedShort = close <= lowerVwapBand

hvnBufferTicks = hvnBlockZone * tickSize * 10 
blockLongHVN = (close < sessionPOC) and (close >= sessionPOC - hvnBufferTicks)
blockShortHVN = (close > sessionPOC) and (close <= sessionPOC + hvnBufferTicks)

validLongSignal = noLowerWick and not overextendedLong and not blockLongHVN and timeFilterPass
validShortSignal = noUpperWick and not overextendedShort and not blockShortHVN and timeFilterPass

// =========================================================================
// 6. CUSTOM STATE MACHINE & PINECONNECTOR ALERTS
// =========================================================================
var int currentPos = 0      
var float currentStop = na
bufferTicks = stopBuffer * tickSize * 10

// ─── ENTRIES ─────────────────────────────────────────────────────────────
if currentPos == 0
    if validLongSignal
        currentPos := 1
        currentStop := low - bufferTicks
        
        // Construct standard PineConnector String
        // Format: LicenseID,buy,EURUSD,vol_lots=0.1,sl_price=1.1000
        pcLong = in_licenseID + ',buy,' + in_brokerSymbol + ',vol_lots=' + str.tostring(in_tradeLots) + ',sl_price=' + str.tostring(currentStop)
        alert(pcLong, alert.freq_once_per_bar) 
        
    else if validShortSignal
        currentPos := -1
        currentStop := high + bufferTicks
        
        // Construct standard PineConnector String
        pcShort = in_licenseID + ',sell,' + in_brokerSymbol + ',vol_lots=' + str.tostring(in_tradeLots) + ',sl_price=' + str.tostring(currentStop)
        alert(pcShort, alert.freq_once_per_bar)

// ─── TRAILING STOPS & EXITS ──────────────────────────────────────────────
if currentPos == 1
    if noLowerWick 
        currentStop := math.max(currentStop, low - bufferTicks) 
        
    if low <= currentStop 
        // Force exit via TradingView when trailing stop is hit
        pcExitLong = in_licenseID + ',closelong,' + in_brokerSymbol
        alert(pcExitLong, alert.freq_all)
        
        currentPos := 0
        currentStop := na

if currentPos == -1
    if noUpperWick
        currentStop := math.min(currentStop, high + bufferTicks) 
        
    if high >= currentStop
        // Force exit via TradingView when trailing stop is hit
        pcExitShort = in_licenseID + ',closeshort,' + in_brokerSymbol
        alert(pcExitShort, alert.freq_all)
        
        currentPos := 0
        currentStop := na

plot(currentPos != 0 ? currentStop : na, color=color.new(color.fuchsia, 0), style=plot.style_linebr, linewidth=2, title="Trailing Stop")

Code: Select all

//+------------------------------------------------------------------+
//|                                     Institutional_HA_VWAP.mq4    |
//|                    HA Wick + VWAP + HVN Session Execution        |
//+------------------------------------------------------------------+
#property copyright "Algorithmic Architecture"
#property link      ""
#property version   "1.00"
#property strict

//--- Inputs
input double LotSize = 0.1;
input int    MagicNumber = 88888;
input int    Slippage = 3;

input string _1 = "--- VWAP Settings ---";
input double StDevMult = 2.0;           // VWAP StDev Band Multiplier
input int    SessionDelayMinutes = 30;  // Minutes to Block After Open

input string _2 = "--- Volume Profile (HVN) ---";
input double HvnBinSizePips = 1.0;      // Price Bin Size (Pips)
input double HvnBlockZonePips = 5.0;    // Block trades firing into POC within this distance

input string _3 = "--- Trailing Stop ---";
input double StopBufferPips = 2.0;      // Buffer below HA Real Low (Pips)

//--- Global Variables
datetime lastBarTime;
datetime sessionStartTime;

// HA State
double prevHaOpen = 0;
double prevHaClose = 0;

// VWAP State
double cumVol = 0;
double cumVolPrice = 0;
double cumVolPrice2 = 0;

// HVN Arrays
double priceBins[];
long   volBins[];
double sessionPOC = 0;

double pipSize;
int    pipMult;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    // Configure pip sizing for 4/5 digit brokers
    pipMult = (Digits == 3 || Digits == 5) ? 10 : 1;
    pipSize = Point * pipMult;
    
    lastBarTime = 0;
    sessionStartTime = 0;
    
    ArrayResize(priceBins, 0);
    ArrayResize(volBins, 0);

    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // Only execute logic on the close of a bar to prevent repainting
    if(Time[0] == lastBarTime) return;
    
    // --- 1. SESSION RESET DETECTION ---
    if(TimeDay(Time[0]) != TimeDay(lastBarTime)) 
    {
        cumVol = 0;
        cumVolPrice = 0;
        cumVolPrice2 = 0;
        sessionStartTime = Time[0];
        
        ArrayResize(priceBins, 0);
        ArrayResize(volBins, 0);
        sessionPOC = 0;
        
        // Reset HA Engine base
        prevHaOpen = Open[1];
        prevHaClose = Close[1];
    }
    
    // --- 2. BACKGROUND HEIKIN ASHI ENGINE ---
    // Calculate HA values for the recently closed candle (Index 1)
    double haClose = (Open[1] + High[1] + Low[1] + Close[1]) / 4.0;
    double haOpen  = (prevHaOpen + prevHaClose) / 2.0;
    
    // Initialize first bar of EA if needed
    if(prevHaOpen == 0) haOpen = (Open[1] + Close[1]) / 2.0; 
    
    double haHigh  = MathMax(High[1], MathMax(haOpen, haClose));
    double haLow   = MathMin(Low[1], MathMin(haOpen, haClose));
    
    // Evaluate Wicks
    bool isHAUp = haClose > haOpen;
    // Normalize floats for exact equality check in MQL4
    bool noLowerWick = isHAUp && (NormalizeDouble(haOpen - haLow, Digits) == 0);
    
    bool isHADown = haClose < haOpen;
    bool noUpperWick = isHADown && (NormalizeDouble(haHigh - haOpen, Digits) == 0);
    
    // Save state for next bar
    prevHaOpen = haOpen;
    prevHaClose = haClose;
    
    // --- 3. INSTITUTIONAL VWAP CALCULATION ---
    double tickVol = (double)Volume[1];
    
    cumVol += tickVol;
    cumVolPrice += Close[1] * tickVol;
    cumVolPrice2 += tickVol * MathPow(Close[1], 2);
    
    double vwapBase = cumVolPrice / cumVol;
    double variance = (cumVolPrice2 / cumVol) - MathPow(vwapBase, 2);
    double vwapStDev = MathSqrt(MathMax(0, variance));
    
    double upperVwapBand = vwapBase + (vwapStDev * StDevMult);
    double lowerVwapBand = vwapBase - (vwapStDev * StDevMult);
    
    // --- 4. VOLUME PROFILE (POC) BINNING ---
    double binRounding = pipSize * HvnBinSizePips;
    double currentBinPrice = MathRound(Close[1] / binRounding) * binRounding;
    
    int binIndex = -1;
    for(int i = 0; i < ArraySize(priceBins); i++) {
        if(NormalizeDouble(MathAbs(priceBins[i] - currentBinPrice), Digits) < Point) {
            binIndex = i;
            break;
        }
    }
    
    if(binIndex == -1) {
        int newSize = ArraySize(priceBins) + 1;
        ArrayResize(priceBins, newSize);
        ArrayResize(volBins, newSize);
        priceBins[newSize-1] = currentBinPrice;
        volBins[newSize-1] = (long)tickVol;
    } else {
        volBins[binIndex] += (long)tickVol;
    }
    
    long maxVol = -1;
    for(int i = 0; i < ArraySize(volBins); i++) {
        if(volBins[i] > maxVol) {
            maxVol = volBins[i];
            sessionPOC = priceBins[i];
        }
    }
    
    // --- 5. SIGNAL FILTERS ---
    int minutesSinceOpen = (int)((Time[0] - sessionStartTime) / 60);
    bool timeFilterPass = minutesSinceOpen >= SessionDelayMinutes;
    
    bool overextendedLong = Close[1] >= upperVwapBand;
    bool overextendedShort = Close[1] <= lowerVwapBand;
    
    double hvnBufferPrice = HvnBlockZonePips * pipSize;
    bool blockLongHVN = (Close[1] < sessionPOC) && (Close[1] >= sessionPOC - hvnBufferPrice);
    bool blockShortHVN = (Close[1] > sessionPOC) && (Close[1] <= sessionPOC + hvnBufferPrice);
    
    bool validLongSignal = noLowerWick && !overextendedLong && !blockLongHVN && timeFilterPass;
    bool validShortSignal = noUpperWick && !overextendedShort && !blockShortHVN && timeFilterPass;
    
    // --- 6. EXECUTION & TRAILING STOP MANAGEMENT ---
    bool hasOpenLong = false;
    bool hasOpenShort = false;
    double slBuffer = StopBufferPips * pipSize;
    
    for(int i = OrdersTotal() - 1; i >= 0; i--) 
    {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) 
        {
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) 
            {
                if(OrderType() == OP_BUY) 
                {
                    hasOpenLong = true;
                    // HA Flat-Bottom Trail logic
                    if(noLowerWick) 
                    {
                        double newStop = NormalizeDouble(Low[1] - slBuffer, Digits);
                        // Only modify if new stop is better and respects broker StopLevel
                        if(newStop > OrderStopLoss() && (Bid - newStop) > MarketInfo(Symbol(), MODE_STOPLEVEL) * Point) 
                        {
                            bool mod = OrderModify(OrderTicket(), OrderOpenPrice(), newStop, OrderTakeProfit(), 0, clrFuchsia);
                        }
                    }
                }
                else if(OrderType() == OP_SELL) 
                {
                    hasOpenShort = true;
                    // HA Flat-Top Trail logic
                    if(noUpperWick) 
                    {
                        double newStop = NormalizeDouble(High[1] + slBuffer, Digits);
                        if((newStop < OrderStopLoss() || OrderStopLoss() == 0) && (newStop - Ask) > MarketInfo(Symbol(), MODE_STOPLEVEL) * Point) 
                        {
                            bool mod = OrderModify(OrderTicket(), OrderOpenPrice(), newStop, OrderTakeProfit(), 0, clrFuchsia);
                        }
                    }
                }
            }
        }
    }
    
    // --- ENTRY LOGIC ---
    if(!hasOpenLong && !hasOpenShort) 
    {
        if(validLongSignal) 
        {
            double initialSL = NormalizeDouble(Low[1] - slBuffer, Digits);
            int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, Slippage, initialSL, 0, "HA VWAP Long", MagicNumber, 0, clrBlue);
        }
        else if(validShortSignal) 
        {
            double initialSL = NormalizeDouble(High[1] + slBuffer, Digits);
            int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, Slippage, initialSL, 0, "HA VWAP Short", MagicNumber, 0, clrRed);
        }
    }
    
    lastBarTime = Time[0];
}

Code: Select all

using System;
using System.Linq;
using System.Collections.Generic;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class Institutional_HA_VWAP : Robot
    {
        // --- 1. SETTINGS & INPUTS ---
        [Parameter("Trade Size (Lots)", DefaultValue = 0.1, Group = "Risk Management", MinValue = 0.01)]
        public double LotSize { get; set; }

        [Parameter("VWAP StDev Multiplier", DefaultValue = 2.0, Group = "Institutional VWAP")]
        public double StDevMult { get; set; }

        [Parameter("Minutes to Block After Open", DefaultValue = 30, Group = "Institutional VWAP")]
        public int SessionDelayMinutes { get; set; }

        [Parameter("Price Bin Size (Pips)", DefaultValue = 1.0, Group = "Volume Profile (HVN)")]
        public double HvnBinSizePips { get; set; }

        [Parameter("HVN Block Zone (Pips)", DefaultValue = 5.0, Group = "Volume Profile (HVN)")]
        public double HvnBlockZonePips { get; set; }

        [Parameter("Stop Buffer (Pips)", DefaultValue = 2.0, Group = "Trailing Stop")]
        public double StopBufferPips { get; set; }

        // --- INTERNAL STATE ---
        private const string BotLabel = "HA_VWAP_Execute";
        
        // HA State
        private double _prevHaOpen;
        private double _prevHaClose;

        // VWAP State
        private double _cumVol;
        private double _cumVolPrice;
        private double _cumVolPrice2;
        private DateTime _sessionStartTime;

        // Volume Profile State (C# Dictionary is vastly superior to MQL arrays for this)
        private Dictionary<double, long> _volumeProfile = new Dictionary<double, long>();
        private double _sessionPOC;

        protected override void OnStart()
        {
            // Initialization if needed
        }

        protected override void OnBar()
        {
            // In cTrader OnBar(), Bars.Last(1) is the candle that just closed. 
            // Bars.Last(0) is the newly opened, incomplete candle.
            var closedBar = Bars.Last(1);
            var previousClosedBar = Bars.Last(2);

            // --- 1. SESSION RESET DETECTION (Daily Reset) ---
            if (closedBar.OpenTime.Date != previousClosedBar.OpenTime.Date || _sessionStartTime == default)
            {
                _cumVol = 0;
                _cumVolPrice = 0;
                _cumVolPrice2 = 0;
                _sessionStartTime = closedBar.OpenTime;

                _volumeProfile.Clear();
                _sessionPOC = 0;

                // Reset HA base to the previous day's close
                _prevHaOpen = previousClosedBar.Open;
                _prevHaClose = previousClosedBar.Close;
            }

            // --- 2. BACKGROUND HEIKIN ASHI ENGINE ---
            double haClose = (closedBar.Open + closedBar.High + closedBar.Low + closedBar.Close) / 4.0;
            double haOpen = (_prevHaOpen + _prevHaClose) / 2.0;
            
            // Failsafe for very first bar computation
            if (_prevHaOpen == 0) haOpen = (closedBar.Open + closedBar.Close) / 2.0;

            double haHigh = Math.Max(closedBar.High, Math.Max(haOpen, haClose));
            double haLow = Math.Min(closedBar.Low, Math.Min(haOpen, haClose));

            // Wick Math (Rounded to broker digits to prevent floating point false-positives)
            bool isHAUp = haClose > haOpen;
            bool noLowerWick = isHAUp && Math.Round(haOpen - haLow, Symbol.Digits) == 0;

            bool isHADown = haClose < haOpen;
            bool noUpperWick = isHADown && Math.Round(haHigh - haOpen, Symbol.Digits) == 0;

            // Save state for next bar iteration
            _prevHaOpen = haOpen;
            _prevHaClose = haClose;

            // --- 3. INSTITUTIONAL VWAP CALCULATION ---
            long tickVol = (long)closedBar.TickVolume;
            
            _cumVol += tickVol;
            _cumVolPrice += closedBar.Close * tickVol;
            _cumVolPrice2 += tickVol * Math.Pow(closedBar.Close, 2);

            double vwapBase = _cumVolPrice / _cumVol;
            double variance = (_cumVolPrice2 / _cumVol) - Math.Pow(vwapBase, 2);
            double vwapStDev = Math.Sqrt(Math.Max(0, variance));

            double upperVwapBand = vwapBase + (vwapStDev * StDevMult);
            double lowerVwapBand = vwapBase - (vwapStDev * StDevMult);

            // --- 4. C# LINQ VOLUME PROFILE (POC) ---
            double binRounding = HvnBinSizePips * Symbol.PipSize;
            double currentBinPrice = Math.Round(closedBar.Close / binRounding) * binRounding;
            currentBinPrice = Math.Round(currentBinPrice, Symbol.Digits);

            if (_volumeProfile.ContainsKey(currentBinPrice))
                _volumeProfile[currentBinPrice] += tickVol;
            else
                _volumeProfile[currentBinPrice] = tickVol;

            // Extract the Point of Control instantly using LINQ
            _sessionPOC = _volumeProfile.OrderByDescending(kvp => kvp.Value).First().Key;

            // --- 5. SIGNAL FILTERS ---
            TimeSpan timeSinceOpen = closedBar.OpenTime - _sessionStartTime;
            bool timeFilterPass = timeSinceOpen.TotalMinutes >= SessionDelayMinutes;

            bool overextendedLong = closedBar.Close >= upperVwapBand;
            bool overextendedShort = closedBar.Close <= lowerVwapBand;

            double hvnBufferPrice = HvnBlockZonePips * Symbol.PipSize;
            bool blockLongHVN = (closedBar.Close < _sessionPOC) && (closedBar.Close >= _sessionPOC - hvnBufferPrice);
            bool blockShortHVN = (closedBar.Close > _sessionPOC) && (closedBar.Close <= _sessionPOC + hvnBufferPrice);

            bool validLongSignal = noLowerWick && !overextendedLong && !blockLongHVN && timeFilterPass;
            bool validShortSignal = noUpperWick && !overextendedShort && !blockShortHVN && timeFilterPass;

            // --- 6. EXECUTION & TRAILING STOP MANAGEMENT ---
            var existingPosition = Positions.Find(BotLabel, SymbolName);
            double slBufferPrice = StopBufferPips * Symbol.PipSize;

            if (existingPosition != null)
            {
                // TRAILING STOP: Flat-Bottom / Flat-Top anchored trail
                if (existingPosition.TradeType == TradeType.Buy && noLowerWick)
                {
                    double newStop = Math.Round(closedBar.Low - slBufferPrice, Symbol.Digits);
                    // Only modify if the new trail is higher than the old stop
                    if (existingPosition.StopLoss == null || newStop > existingPosition.StopLoss)
                    {
                        ModifyPosition(existingPosition, newStop, existingPosition.TakeProfit);
                    }
                }
                else if (existingPosition.TradeType == TradeType.Sell && noUpperWick)
                {
                    double newStop = Math.Round(closedBar.High + slBufferPrice, Symbol.Digits);
                    // Only modify if the new trail is lower than the old stop
                    if (existingPosition.StopLoss == null || newStop < existingPosition.StopLoss)
                    {
                        ModifyPosition(existingPosition, newStop, existingPosition.TakeProfit);
                    }
                }
            }
            else
            {
                // ENTRY LOGIC
                double volumeInUnits = Symbol.QuantityToVolumeInUnits(LotSize);

                if (validLongSignal)
                {
                    double initialSL_Price = Math.Round(closedBar.Low - slBufferPrice, Symbol.Digits);
                    // cTrader ExecuteMarketOrder requires SL in Pips, not absolute price
                    double slPips = Math.Round((Symbol.Ask - initialSL_Price) / Symbol.PipSize, 1);
                    
                    ExecuteMarketOrder(TradeType.Buy, SymbolName, volumeInUnits, BotLabel, slPips, null);
                }
                else if (validShortSignal)
                {
                    double initialSL_Price = Math.Round(closedBar.High + slBufferPrice, Symbol.Digits);
                    double slPips = Math.Round((initialSL_Price - Symbol.Bid) / Symbol.PipSize, 1);
                    
                    ExecuteMarketOrder(TradeType.Sell, SymbolName, volumeInUnits, BotLabel, slPips, null);
                }
            }
        }
    }
}