יירוט פקודות מסחר בתדר גבוה ומנועי סיכון בפחות מ-50 מיקרו-שניות ב-NinjaTrader 8

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using RiskMaster.Core.RiskEngine;

namespace RiskMaster.Interception
{
    public class WpfOrderInterceptor
    {
        private readonly IRiskEvaluator _riskEvaluator;

        public WpfOrderInterceptor(IRiskEvaluator riskEvaluator)
        {
            _riskEvaluator = riskEvaluator ?? throw new ArgumentNullException(nameof(riskEvaluator));
        }

        public void HookChartTrader(DependencyObject rootContainer, string accountId)
        {
            if (rootContainer == null) return;

            // Traverse the WPF Visual Tree to locate Chart Trader action buttons
            int childCount = VisualTreeHelper.GetChildrenCount(rootContainer);
            for (int i = 0; i < childCount; i++)
            {
                DependencyObject child = VisualTreeHelper.GetChild(rootContainer, i);
                
                if (child is Button button)
                {
                    string buttonName = button.Name ?? string.Empty;
                    // Match Buy Market, Sell Market, Buy Ask, Sell Bid controls
                    if (buttonName.Contains("Buy") || buttonName.Contains("Sell") || buttonName.Contains("Flatten"))
                    {
                        // Attach tunneling preview handler: fires BEFORE NinjaTrader button click
                        button.PreviewMouseDown -= OnOrderButtonPreviewMouseDown;
                        button.PreviewMouseDown += OnOrderButtonPreviewMouseDown;
                    }
                }

                // Recursively traverse child branches
                HookChartTrader(child, accountId);
            }
        }

        private void OnOrderButtonPreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            if (sender is Button button)
            {
                string actionType = button.Name;
                
                // Evaluate active account constraints in under 50 microseconds
                RiskEvaluationResult result = _riskEvaluator.EvaluateOrderAttempt(actionType);
                
                if (!result.IsAllowed)
                {
                    // Mark event as handled: aborts event pipeline before NinjaTrader sees the click
                    e.Handled = true;
                    
                    // Trigger auditory warning and render non-blocking visual banner
                    RiskNotificationManager.ShowRejectionBanner(result.ViolationReason);
                }
            }
        }
    }
}

using System;
using System.Runtime.CompilerServices;

namespace RiskMaster.Core.RiskEngine
{
    // Stack-allocated struct: zero heap allocation, zero GC overhead
    public readonly struct TickEvaluationResult
    {
        public readonly double CurrentUnrealizedPnL;
        public readonly double PeakEquityHighWaterMark;
        public readonly double CurrentTrailingDrawdown;
        public readonly bool IsTrailingLimitBreached;

        public TickEvaluationResult(double pnl, double highWaterMark, double drawdown, bool breached)
        {
            CurrentUnrealizedPnL = pnl;
            PeakEquityHighWaterMark = highWaterMark;
            CurrentTrailingDrawdown = drawdown;
            IsTrailingLimitBreached = breached;
        }
    }

    public class FastDrawdownCalculator
    {
        private double _realizedDailyPnL;
        private double _sessionHighWaterMark;
        private double _maxAllowedTrailingDrawdown;
        private readonly object _syncRoot = new object();

        public void InitializeSession(double initialBalance, double maxTrailingDrawdown)
        {
            lock (_syncRoot)
            {
                _realizedDailyPnL = 0.0;
                _sessionHighWaterMark = initialBalance;
                _maxAllowedTrailingDrawdown = maxTrailingDrawdown;
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public TickEvaluationResult ProcessPriceTick(double positionQuantity, double openPrice, double currentBidAskPrice, double pointValue)
        {
            // Pure primitive arithmetic: executed in under 20 nanoseconds directly on CPU registers
            double unrealizedPnL = (currentBidAskPrice - openPrice) * positionQuantity * pointValue;
            double currentTotalEquity = _realizedDailyPnL + unrealizedPnL;

            // Inlined peak water mark tracking
            if (currentTotalEquity > _sessionHighWaterMark)
            {
                _sessionHighWaterMark = currentTotalEquity;
            }

            double currentDrawdown = _sessionHighWaterMark - currentTotalEquity;
            bool isBreached = currentDrawdown >= _maxAllowedTrailingDrawdown;

            return new TickEvaluationResult(unrealizedPnL, _sessionHighWaterMark, currentDrawdown, isBreached);
        }
    }
}

using System;
using System.Threading;
using NinjaTrader.Cbi;

namespace RiskMaster.Core.RiskEngine
{
    public class LiquidationMutex
    {
        private const int STATE_NORMAL = 0;
        private const int STATE_LIQUIDATING = 1;
        private const int STATE_LOCKED_OUT = 2;

        private int _executionState = STATE_NORMAL;
        private readonly object _orderDispatchLock = new object();

        public bool TryExecuteEmergencyLiquidation(Account account, string breachReason)
        {
            if (account == null) throw new ArgumentNullException(nameof(account));

            // Atomic CAS: transitions from STATE_NORMAL to STATE_LIQUIDATING
            // Returns the original value. If original was not STATE_NORMAL, another thread won the race.
            int originalState = Interlocked.CompareExchange(ref _executionState, STATE_LIQUIDATING, STATE_NORMAL);
            
            if (originalState != STATE_NORMAL)
            {
                // Liquidation is already in progress or completed; silently ignore redundant invocation
                return false;
            }

            lock (_orderDispatchLock)
            {
                try
                {
                    // 1. Cancel all working orders to avoid fills during position flattening
                    foreach (Order workingOrder in account.Orders)
                    {
                        if (workingOrder.OrderState == OrderState.Working || workingOrder.OrderState == OrderState.Accepted)
                        {
                            account.Cancel(new[] { workingOrder });
                        }
                    }

                    // 2. Flatten all active market positions
                    account.Flatten(account.Positions);

                    // 3. Transition to permanently locked state for remainder of the session
                    Interlocked.Exchange(ref _executionState, STATE_LOCKED_OUT);
                    
                    return true;
                }
                catch (Exception ex)
                {
                    // Reset to normal only on unexpected exception to permit emergency retry
                    Interlocked.Exchange(ref _executionState, STATE_NORMAL);
                    throw new InvalidOperationException("Emergency liquidation encountered a platform error", ex);
                }
            }
        }
    }
}