forex-scalping.com

Code: Select all

public async Task TryEnterMarketAsync(string symbol, TradeDirection direction, double volume)
{
    await _executionLock.WaitAsync();
    try
    {
        if (_currentState != ExecutionState.Idle) return;

        _currentState = ExecutionState.Routing;
        _pendingClientOrderId = Guid.NewGuid().ToString("N"); // Idempotency key

        // Attempt execution
        var result = await _brokerApi.SendMarketOrderAsync(symbol, direction, volume, _pendingClientOrderId);

        if (result.IsSuccess)
        {
            _currentState = ExecutionState.InPosition;
            // Map broker's server-side Position ID to your local state
        }
        else
        {
            _currentState = ExecutionState.Idle; // Rejected by broker cleanly
        }
    }
    catch (TimeoutException) // Or HttpRequestException, SocketException
    {
        // The network dropped. The order might be sitting on the broker's server.
        _currentState = ExecutionState.Reconciling;
        
        // At this point, the execution lock is released, but _currentState prevents 
        // new trades until ReconcileStateAsync() clears it.
    }
    finally
    {
        _executionLock.Release();
    }
}

Code: Select all

private async Task ReconcileStateAsync()
{
    if (_currentState != ExecutionState.Reconciling) return;

    await _executionLock.WaitAsync();
    try
    {
        // 1. Query the broker's open positions
        var openPositions = await _brokerApi.GetOpenPositionsAsync();

        // 2. Search for the orphaned ID
        var ghostPosition = openPositions.FirstOrDefault(p => p.ClientOrderId == _pendingClientOrderId);

        if (ghostPosition != null)
        {
            // Scenario A: The order executed on the server before the network drop.
            // Action: Adopt the position and resume management.
            _currentState = ExecutionState.InPosition;
            AttachStopLossAndTakeProfit(ghostPosition); 
        }
        else
        {
            // 3. Query order history (did it execute and immediately hit a stop/take profit?)
            var history = await _brokerApi.GetHistoricalTradesAsync(TimeSpan.FromMinutes(5));
            var hitHistory = history.Any(h => h.ClientOrderId == _pendingClientOrderId);

            if (hitHistory)
            {
                // Scenario B: Order executed and closed while we were disconnected.
                _currentState = ExecutionState.Idle;
            }
            else
            {
                // Scenario C: The order never reached the matching engine.
                // Action: Safe to revert to Idle. 
                _currentState = ExecutionState.Idle;
                _pendingClientOrderId = null;
            }
        }
    }
    catch (Exception)
    {
        // Connection still unstable. Remain in Reconciling state and try again later.
    }
    finally
    {
        _executionLock.Release();
    }
}

Code: Select all

using Polly;
using Polly.Retry;
using Polly.Timeout;
using System.Net.Sockets;

public class OrderManager
{
    private ExecutionState _currentState = ExecutionState.Idle;
    private readonly SemaphoreSlim _executionLock = new(1, 1);
    private readonly IExecutionProvider _brokerApi;
    private string _pendingClientOrderId; 
    
    // The cached Polly V8 Resilience Pipeline
    private readonly ResiliencePipeline _reconciliationPipeline;

    public OrderManager(IExecutionProvider brokerApi)
    {
        _brokerApi = brokerApi;
        
        // 1. Build the fault-tolerance pipeline
        _reconciliationPipeline = new ResiliencePipelineBuilder()
            .AddRetry(new RetryStrategyOptions
            {
                // Target only transient transport or API exceptions
                ShouldHandle = new PredicateBuilder()
                    .Handle<TimeoutException>()
                    .Handle<HttpRequestException>()
                    .Handle<SocketException>(),
                
                MaxRetryAttempts = 5,
                Delay = TimeSpan.FromMilliseconds(500),
                BackoffType = DelayBackoffType.Exponential,
                UseJitter = true, // Critical: Scatters retry exact-timing to avoid rate-limiting
                
                OnRetry = args => 
                {
                    // Log the retry for your telemetry pipeline (e.g., to MS SQL / local log)
                    Console.WriteLine($"[WARNING] Broker unstable. Reconciliation attempt {args.AttemptNumber} in {args.RetryDelay.TotalMilliseconds:N0}ms");
                    return ValueTask.CompletedTask;
                }
            })
            // 2. Wrap the entire retry block in an absolute timeout
            .AddTimeout(TimeSpan.FromSeconds(30)) 
            .Build();

        _brokerApi.OnConnectionRestored += async (s, e) => await ReconcileStateAsync(CancellationToken.None);
    }
}

Code: Select all

private async Task ReconcileStateAsync(CancellationToken cancellationToken)
{
    if (_currentState != ExecutionState.Reconciling) return;

    await _executionLock.WaitAsync(cancellationToken);
    try
    {
        // Execute the broker queries through the Polly pipeline
        await _reconciliationPipeline.ExecuteAsync(async ct => 
        {
            // 1. Query the broker's open positions (passing Polly's cancellation token)
            var openPositions = await _brokerApi.GetOpenPositionsAsync(ct);
            var ghostPosition = openPositions.FirstOrDefault(p => p.ClientOrderId == _pendingClientOrderId);

            if (ghostPosition != null)
            {
                // Scenario A: Ghost order is live.
                _currentState = ExecutionState.InPosition;
                AttachStopLossAndTakeProfit(ghostPosition); 
            }
            else
            {
                // 2. Query order history for instant stop-outs
                var history = await _brokerApi.GetHistoricalTradesAsync(TimeSpan.FromMinutes(5), ct);
                var hitHistory = history.Any(h => h.ClientOrderId == _pendingClientOrderId);

                if (hitHistory || !hitHistory) 
                {
                    // Scenarios B & C: It closed quickly, or never reached the engine.
                    _currentState = ExecutionState.Idle;
                    _pendingClientOrderId = null;
                }
            }
        }, cancellationToken);
    }
    catch (TimeoutRejectedException)
    {
        // The overall 30-second pipeline timeout breached. The broker is completely dark.
        // Fallback action: Trigger an emergency alert to your phone / email.
        Console.WriteLine("CRITICAL: Reconciliation failed. Broker API unreachable for 30s.");
    }
    finally
    {
        _executionLock.Release();
    }
}

Code: Select all

using Polly;
using Polly.CircuitBreaker;

public class OrderManager
{
    private readonly ResiliencePipeline<ExecutionResult> _executionPipeline;
    private readonly IExecutionProvider _brokerApi;
    private ExecutionState _currentState = ExecutionState.Idle;

    public OrderManager(IExecutionProvider brokerApi)
    {
        _brokerApi = brokerApi;

        _executionPipeline = new ResiliencePipelineBuilder<ExecutionResult>()
            .AddCircuitBreaker(new CircuitBreakerStrategyOptions<ExecutionResult>
            {
                // 1. Define what counts as a failure
                ShouldHandle = new PredicateBuilder<ExecutionResult>()
                    .HandleResult(result => !result.IsSuccess && IsHardRejection(result.ErrorCode))
                    .Handle<TimeoutException>(),

                // 2. Configure the "3 Consecutive" trigger
                FailureRatio = 1.0, 
                MinimumThroughput = 3, 
                SamplingDuration = TimeSpan.FromMinutes(2), 
                
                // 3. Define the cooldown period (e.g., bypassing Tier-1 news volatility)
                BreakDuration = TimeSpan.FromMinutes(15),

                // 4. Telemetry hooks
                OnOpened = args => 
                {
                    string reason = args.Outcome.Exception?.Message ?? args.Outcome.Result?.ErrorCode;
                    Console.WriteLine($"[EMERGENCY] Circuit tripped! Execution halted for 15m. Reason: {reason}");
                    // Fire webhook / push notification to your phone here
                    return ValueTask.CompletedTask;
                },
                OnClosed = args =>
                {
                    Console.WriteLine("[INFO] Circuit closed. Resuming normal execution.");
                    return ValueTask.CompletedTask;
                }
            })
            .Build();
    }

    private static bool IsHardRejection(string errorCode)
    {
        // Differentiate critical structural rejections from benign ones
        string[] hardErrors = { 
            "ERR_OFF_QUOTES",        // Liquidity provider rejected
            "ERR_INVALID_STOPS",     // Stop inside freeze level
            "ERR_NOT_ENOUGH_MONEY"   // Margin exhaustion
        };
        return hardErrors.Contains(errorCode);
    }
}

Code: Select all

public async Task TryEnterMarketAsync(string symbol, TradeDirection direction, double volume)
{
    // Await your semaphore lock here as previously defined...
    
    try
    {
        _currentState = ExecutionState.Routing;
        string pendingClientOrderId = Guid.NewGuid().ToString("N");

        // Route through the Circuit Breaker
        var result = await _executionPipeline.ExecuteAsync(async ct =>
        {
            return await _brokerApi.SendMarketOrderAsync(symbol, direction, volume, pendingClientOrderId);
        }, CancellationToken.None);

        if (result.IsSuccess)
        {
            _currentState = ExecutionState.InPosition;
        }
        else
        {
            // It failed, but the circuit hasn't tripped yet (e.g., attempt 1 or 2)
            _currentState = ExecutionState.Idle; 
        }
    }
    catch (BrokenCircuitException)
    {
        // The circuit is open. The execution was blocked locally.
        _currentState = ExecutionState.Idle;
        Console.WriteLine($"[BLOCKED] Trade on {symbol} aborted. Circuit breaker is currently active.");
    }
    catch (TimeoutException)
    {
        // Transition to Reconciling state as previously architected
        _currentState = ExecutionState.Reconciling;
    }
    finally
    {
        // Release semaphore lock...
    }
}