forex-scalping.com

Code: Select all

using System;
using System.Diagnostics;
using System.Threading;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class LatencyMeter : Robot
    {
        [Parameter("Number of Tests", DefaultValue = 10)]
        public int NumberOfTests { get; set; }

        [Parameter("Distance (Pips)", DefaultValue = 100)]
        public double DistancePips { get; set; }

        protected override void OnStart()
        {
            Print("--- Starting cTrader Broker Latency Test ---");
            
            long minLatency = long.MaxValue;
            long maxLatency = 0;
            long totalLatency = 0;
            int successfulTests = 0;
            
            for (int i = 0; i < NumberOfTests; i++)
            {
                // Calculate safe price far below the market
                double safePrice = Symbol.Ask - (DistancePips * Symbol.PipSize);
                
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                
                // Synchronous method blocks until the broker server responds
                TradeResult result = PlaceLimitOrder(TradeType.Buy, SymbolName, Symbol.VolumeInUnitsMin, safePrice, "LatencyTest");
                
                stopwatch.Stop();
                long latency = stopwatch.ElapsedMilliseconds;
                
                if (result.IsSuccessful)
                {
                    successfulTests++;
                    totalLatency += latency;
                    
                    if (latency < minLatency) minLatency = latency;
                    if (latency > maxLatency) maxLatency = latency;
                    
                    Print("Test {0} Latency: {1} ms", i + 1, latency);
                    
                    // Clean up: Cancel the pending order
                    TradeResult cancelResult = CancelPendingOrder(result.PendingOrder);
                    if (!cancelResult.IsSuccessful)
                    {
                        Print("Warning: Failed to cancel test order.");
                    }
                }
                else
                {
                    Print("Test {0} Failed. Error: {1}", i + 1, result.Error);
                }
                
                // Pause briefly between pings so we don't spam the API
                Thread.Sleep(500); 
            }
            
            // Calculate and print final statistics
            if (successfulTests > 0)
            {
                double avgLatency = (double)totalLatency / successfulTests;
                
                Print("=====================================");
                Print("cTRADER LATENCY TEST RESULTS ({0}/{1} successful)", successfulTests, NumberOfTests);
                Print("Average Latency: {0:F1} ms", avgLatency);
                Print("Minimum Latency: {0} ms", minLatency);
                Print("Maximum Latency: {0} ms", maxLatency);
                Print("=====================================");
            }
            else
            {
                Print("All test attempts failed. Check margin or distance parameters.");
            }
            
            // Stop the cBot automatically when the test is finished
            Stop();
        }
    }
}

Code: Select all

// Fire the order asynchronously and move to the next line immediately
ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, Symbol.VolumeInUnitsMin, tradeResult => 
{
    // This block executes independently once the server replies
    if (tradeResult.IsSuccessful)
    {
        Print("SUCCESS: Broker confirmed Async execution! Position ID: {0}", tradeResult.Position.Id);
    }
    else
    {
        Print("FAILED: Broker rejected execution. Error: {0}", tradeResult.Error);
    }
});

Print("Request dispatched. The cBot is free to process other data.");

Code: Select all

using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class StrictSlippageExecution : Robot
    {
        protected override void OnStart()
        {
            // Define your execution parameters
            double targetVolume = 500000; // e.g., 5 standard lots
            double maxAllowedSlippagePips = 0.5; // Half a pip max slippage
            double expectedEntryPrice = Symbol.Ask;

            // Fire the asynchronous Market Range order
            ExecuteMarketRangeOrderAsync(
                TradeType.Buy, 
                SymbolName, 
                targetVolume, 
                maxAllowedSlippagePips, 
                expectedEntryPrice, 
                "StrictScalp", 
                null, // No initial SL
                null, // No initial TP
                tradeResult => 
            {
                // Callback triggers when the server responds
                if (tradeResult.IsSuccessful)
                {
                    double filledVolume = tradeResult.Position.VolumeInUnits;

                    // Trap the partial fill
                    if (filledVolume < targetVolume)
                    {
                        double missedVolume = targetVolume - filledVolume;
                        
                        Print("WARNING: Partial Fill Detected!");
                        Print("Requested: {0} | Filled: {1} | Missed: {2}", targetVolume, filledVolume, missedVolume);
                        Print("Average Fill Price: {0}", tradeResult.Position.EntryPrice);

                        // Decision Matrix for Partial Fills:
                        // Option A: Adjust risk management for the smaller position size
                        // Option B: Close the position immediately if it breaks your minimum size rules
                        // Option C: Re-fire a new async order for the 'missedVolume' (Dangerous if market is running)
                    }
                    else
                    {
                        Print("SUCCESS: Order fully filled at {0}", tradeResult.Position.EntryPrice);
                    }
                }
                else
                {
                    // If the entire book moved beyond your max allowed slippage before the packet arrived
                    Print("ORDER FAILED: Market moved beyond max slippage of {0} pips. Error: {1}", maxAllowedSlippagePips, tradeResult.Error);
                }
            });

            Print("Order routed with max slippage constraints. Listening for server callback...");
        }
    }
}

Code: Select all

using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class StrictVolumeFilter : Robot
    {
        protected override void OnStart()
        {
            double targetVolume = 500000;          // Intended 5 lots
            double minimumRequiredVolume = 200000; // Minimum 2 lots required to justify the trade
            double maxAllowedSlippage = 0.5;

            // 1. Dispatch the initial asynchronous entry
            ExecuteMarketRangeOrderAsync(TradeType.Buy, SymbolName, targetVolume, maxAllowedSlippage, Symbol.Ask, "ScalpEntry", null, null, entryResult => 
            {
                if (entryResult.IsSuccessful)
                {
                    double filledVolume = entryResult.Position.VolumeInUnits;

                    // 2. Trap the micro-fill
                    if (filledVolume < minimumRequiredVolume)
                    {
                        Print("WARNING: Micro-fill detected ({0}). Threshold is {1}. Initiating emergency flatten.", filledVolume, minimumRequiredVolume);

                        // 3. Dispatch the asynchronous exit immediately
                        ClosePositionAsync(entryResult.Position, closeResult => 
                        {
                            if (closeResult.IsSuccessful)
                            {
                                Print("Position flattened successfully. Spread/commission absorbed as a scratch trade.");
                            }
                            else
                            {
                                // CRITICAL: The broker rejected the close request (e.g., market closed, liquidity gap)
                                Print("FATAL: Failed to close micro-fill. Error: {0}. Position is orphaned!", closeResult.Error);
                            }
                        });
                    }
                    else
                    {
                        // The fill was partial, but large enough to meet your minimum threshold
                        Print("SUCCESS: Viable volume filled ({0}). Managing position normally.", filledVolume);
                        
                        // Proceed with normal Stop Loss / Take Profit management here
                    }
                }
            });
            
            Print("Entry order dispatched. Thread released.");
        }
    }
}

Code: Select all

using System;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class DynamicCostFilter : Robot
    {
        [Parameter("Minimum Acceptable Profit ($)", DefaultValue = 25.0)]
        public double MinimumAcceptableProfit { get; set; }

        [Parameter("Strategy Target (Pips)", DefaultValue = 5.0)]
        public double StrategyTargetPips { get; set; }

        protected override void OnStart()
        {
            // Firing the async entry
            ExecuteMarketRangeOrderAsync(TradeType.Buy, SymbolName, 500000, 0.5, Symbol.Ask, "ScalpEntry", null, null, entryResult => 
            {
                if (entryResult.IsSuccessful)
                {
                    var position = entryResult.Position;
                    
                    // 1. Instant Liquidation Cost
                    // NetProfit instantly combines the spread gap and round-trip commissions
                    double instantLiquidationCost = Math.Abs(position.NetProfit);
                    
                    // 2. Calculate the monetary value of 1 pip for this specific filled volume
                    // cTrader's Symbol.PipValue represents the value of 1 pip for 1 unit of volume
                    double positionPipValue = Symbol.PipValue * position.VolumeInUnits;
                    
                    // 3. Calculate Exact Break-Even Distance
                    double spreadPips = Symbol.Spread / Symbol.PipSize;
                    double commissionPips = Math.Abs(position.Commissions) / positionPipValue;
                    double breakEvenPips = spreadPips + commissionPips;
                    
                    // 4. Calculate Expected Monetary Return at your target
                    // (Target Pips - Spread) * Pip Value - Commissions
                    double expectedNetProfit = ((StrategyTargetPips - spreadPips) * positionPipValue) - Math.Abs(position.Commissions);
                    
                    Print("--- EXECUTION METRICS ---");
                    Print("Filled Volume: {0}", position.VolumeInUnits);
                    Print("Instant Drag (Spread + Comm): {0:C}", instantLiquidationCost);
                    Print("Distance to Break-Even: {0:F2} pips", breakEvenPips);
                    Print("Expected Net Return at {0} pips: {1:C}", StrategyTargetPips, expectedNetProfit);

                    // 5. The Decision Matrix
                    if (expectedNetProfit < MinimumAcceptableProfit)
                    {
                        Print("ABORT: Expected return ({0:C}) fails mathematical threshold ({1:C}). Flattening immediately.", expectedNetProfit, MinimumAcceptableProfit);
                        
                        ClosePositionAsync(position, closeResult => 
                        {
                            if(!closeResult.IsSuccessful)
                            {
                                Print("FATAL: Flatten failed! Error: {0}", closeResult.Error);
                            }
                        });
                    }
                    else
                    {
                        Print("HOLD: Trade is mathematically viable. Applying risk management.");
                        // Proceed to set dynamic Stop Loss and Take Profit
                    }
                }
            });
        }
    }
}

Code: Select all

//@version=5
strategy("Realized Execution Slippage Monitor", overlay=true, calc_on_every_tick=true, currency=currency.USD)

// Track state variables for the signal and slippage math
var float signalPrice = na
var float totalSlippagePips = 0.0
var int tradeCount = 0

// Determine the correct pip multiplier (Forex vs Metals like Silver)
isForex = syminfo.type == "forex"
// For Forex, a pip is usually 10 ticks (e.g., 1.00010). For metals, it depends on the broker's decimal precision.
pipMultiplier = isForex ? 10 : 1 

// 1. Define a dummy trigger condition (Replace with your actual entry logic)
// Using a simple rapid crossover for high-frequency testing
triggerCondition = ta.crossover(ta.sma(close, 5), ta.sma(close, 10))

// 2. Capture the exact market price the millisecond the signal fires
if (triggerCondition and strategy.position_size == 0)
    signalPrice := close
    strategy.entry("Scalp_Long", strategy.long)

// 3. Catch the broker's confirmed fill and calculate the drag
if (strategy.position_size > 0 and strategy.position_size[1] == 0)
    // Get the actual fill price reported back from the broker API
    fillPrice = strategy.opentrades.entry_price(strategy.opentrades - 1)
    
    // Calculate the slippage in raw pips (Fill Price - Signal Price)
    // Positive slippage means you got a worse price (drag)
    rawSlippage = (fillPrice - signalPrice) / (syminfo.mintick * pipMultiplier)
    
    totalSlippagePips += rawSlippage
    tradeCount += 1
    
    avgSlippage = totalSlippagePips / tradeCount
    
    // Log the exact execution metrics to the Pine Logs console
    log.info("--- EXECUTION REPORT ---")
    log.info("Intended Price: {0}", signalPrice)
    log.info("Actual Fill: {0}", fillPrice)
    log.info("Trade Drag: {0} pips", rawSlippage)
    log.info("Average Broker Drag: {0} pips", avgSlippage)
    
    // Reset signal state
    signalPrice := na

// 4. Flatten the position quickly to test the next iteration
if (strategy.position_size > 0 and ta.crossunder(ta.sma(close, 5), ta.sma(close, 10)))
    strategy.close("Scalp_Long")