forex-scalping.com

Code: Select all

public interface IExecutionProvider
{
    Task<ExecutionResult> SendMarketOrderAsync(string symbol, TradeDirection direction, double volume, double requestedPrice);
    Task<ExecutionResult> ClosePositionAsync(string positionId);
    event EventHandler<ConnectionStatusEventArgs> OnConnectionChanged;
}

public record ExecutionResult(bool IsSuccess, string PositionId, double FilledPrice, double Volume, string ErrorCode);
public enum TradeDirection { Buy, Sell }

Code: Select all

public class MockEcnProvider : IExecutionProvider
{
    private readonly double _simulateLatencyMs;
    private readonly double _dropProbability;
    private readonly double _maxSlippagePips;
    private readonly Random _rng = new();

    public MockEcnProvider(double simulateLatencyMs = 50, double dropProbability = 0.05, double maxSlippagePips = 1.5)
    {
        _simulateLatencyMs = simulateLatencyMs;
        _dropProbability = dropProbability;
        _maxSlippagePips = maxSlippagePips;
    }

    public async Task<ExecutionResult> SendMarketOrderAsync(string symbol, TradeDirection direction, double volume, double requestedPrice)
    {
        // 1. Simulate Network Latency
        await Task.Delay(TimeSpan.FromMilliseconds(_simulateLatencyMs + _rng.Next(-10, 20)));

        // 2. Simulate Transient Network Drop
        if (_rng.NextDouble() < _dropProbability)
        {
            throw new TimeoutException("Broker API failed to respond within the timeout period.");
        }

        // 3. Simulate Slippage (Worse price on entry)
        double slippageApplied = _rng.NextDouble() * _maxSlippagePips;
        double pipValue = 0.0001; // Assuming 5-digit broker standard pair
        
        double filledPrice = direction == TradeDirection.Buy 
            ? requestedPrice + (slippageApplied * pipValue)
            : requestedPrice - (slippageApplied * pipValue);

        // 4. Simulate Rejections (e.g., Liquidity provider rejected)
        if (volume > 10.0 && _rng.NextDouble() < 0.1) 
        {
             return new ExecutionResult(false, string.Empty, 0, 0, "ERR_LIQUIDITY_REJECTED");
        }

        string mockPositionId = Guid.NewGuid().ToString("N");
        return new ExecutionResult(true, mockPositionId, Math.Round(filledPrice, 5), volume, string.Empty);
    }
    
    public Task<ExecutionResult> ClosePositionAsync(string positionId)
    {
        // Implementation mirrors SendMarketOrderAsync for exit slippage and drops
        throw new NotImplementedException();
    }
    
    public event EventHandler<ConnectionStatusEventArgs>? OnConnectionChanged;
}

Code: Select all

public enum ExecutionState
{
    Idle,
    Routing,
    Reconciling,
    InPosition
}

public class OrderManager
{
    private ExecutionState _currentState = ExecutionState.Idle;
    private readonly SemaphoreSlim _executionLock = new(1, 1);
    private readonly IExecutionProvider _brokerApi;
    
    // Stored locally before network transmission
    private string _pendingClientOrderId; 

    public OrderManager(IExecutionProvider brokerApi)
    {
        _brokerApi = brokerApi;
        _brokerApi.OnConnectionRestored += async (s, e) => await ReconcileStateAsync();
    }
}