546 lines
20 KiB
C#
546 lines
20 KiB
C#
// File: NT8StrategyBase.cs
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using NinjaTrader.Cbi;
|
|
using NinjaTrader.Data;
|
|
using NinjaTrader.Gui;
|
|
using NinjaTrader.Gui.Chart;
|
|
using NinjaTrader.Gui.Tools;
|
|
using NinjaTrader.NinjaScript;
|
|
using NinjaTrader.NinjaScript.Indicators;
|
|
using NinjaTrader.NinjaScript.Strategies;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using NT8.Adapters.NinjaTrader;
|
|
using NT8.Core.Common.Interfaces;
|
|
using NT8.Core.Common.Models;
|
|
using NT8.Core.Execution;
|
|
using NT8.Core.Logging;
|
|
using NT8.Core.Risk;
|
|
using NT8.Core.Sizing;
|
|
using SdkPosition = NT8.Core.Common.Models.Position;
|
|
using SdkOrderSide = NT8.Core.Common.Models.OrderSide;
|
|
using SdkOrderType = NT8.Core.Common.Models.OrderType;
|
|
using OmsOrderRequest = NT8.Core.OMS.OrderRequest;
|
|
using OmsOrderSide = NT8.Core.OMS.OrderSide;
|
|
using OmsOrderType = NT8.Core.OMS.OrderType;
|
|
using OmsOrderState = NT8.Core.OMS.OrderState;
|
|
using OmsOrderStatus = NT8.Core.OMS.OrderStatus;
|
|
|
|
namespace NinjaTrader.NinjaScript.Strategies
|
|
{
|
|
/// <summary>
|
|
/// Base class for strategies that integrate NT8 SDK components.
|
|
/// </summary>
|
|
public abstract class NT8StrategyBase : Strategy
|
|
{
|
|
private readonly object _lock = new object();
|
|
|
|
protected IStrategy _sdkStrategy;
|
|
protected IRiskManager _riskManager;
|
|
protected IPositionSizer _positionSizer;
|
|
protected NT8ExecutionAdapter _executionAdapter;
|
|
protected ILogger _logger;
|
|
|
|
protected StrategyConfig _strategyConfig;
|
|
protected RiskConfig _riskConfig;
|
|
protected SizingConfig _sizingConfig;
|
|
|
|
private bool _sdkInitialized;
|
|
private AccountInfo _lastAccountInfo;
|
|
private SdkPosition _lastPosition;
|
|
private MarketSession _currentSession;
|
|
private int _ordersSubmittedToday;
|
|
private DateTime _lastBarTime;
|
|
private bool _killSwitchTriggered;
|
|
private ExecutionCircuitBreaker _circuitBreaker;
|
|
|
|
#region User-Configurable Properties
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Enable SDK", GroupName = "SDK", Order = 1)]
|
|
public bool EnableSDK { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Daily Loss Limit", GroupName = "Risk", Order = 1)]
|
|
public double DailyLossLimit { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Max Trade Risk", GroupName = "Risk", Order = 2)]
|
|
public double MaxTradeRisk { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Max Positions", GroupName = "Risk", Order = 3)]
|
|
public int MaxOpenPositions { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Risk Per Trade", GroupName = "Sizing", Order = 1)]
|
|
public double RiskPerTrade { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Min Contracts", GroupName = "Sizing", Order = 2)]
|
|
public int MinContracts { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Max Contracts", GroupName = "Sizing", Order = 3)]
|
|
public int MaxContracts { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Kill Switch (Flatten + Stop)", GroupName = "Emergency Controls", Order = 1)]
|
|
public bool EnableKillSwitch { get; set; }
|
|
|
|
[NinjaScriptProperty]
|
|
[Display(Name = "Verbose Logging", GroupName = "Debug", Order = 1)]
|
|
public bool EnableVerboseLogging { get; set; }
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Create the SDK strategy instance.
|
|
/// </summary>
|
|
protected abstract IStrategy CreateSdkStrategy();
|
|
|
|
/// <summary>
|
|
/// Configure strategy-specific values after initialization.
|
|
/// </summary>
|
|
protected abstract void ConfigureStrategyParameters();
|
|
|
|
protected override void OnStateChange()
|
|
{
|
|
if (State == State.SetDefaults)
|
|
{
|
|
Description = "SDK-integrated strategy base";
|
|
// Name intentionally not set - this is an abstract base class
|
|
Calculate = Calculate.OnBarClose;
|
|
EntriesPerDirection = 1;
|
|
EntryHandling = EntryHandling.AllEntries;
|
|
IsExitOnSessionCloseStrategy = true;
|
|
ExitOnSessionCloseSeconds = 30;
|
|
IsFillLimitOnTouch = false;
|
|
MaximumBarsLookBack = MaximumBarsLookBack.TwoHundredFiftySix;
|
|
OrderFillResolution = OrderFillResolution.Standard;
|
|
Slippage = 0;
|
|
StartBehavior = StartBehavior.WaitUntilFlat;
|
|
TimeInForce = TimeInForce.Gtc;
|
|
TraceOrders = false;
|
|
RealtimeErrorHandling = RealtimeErrorHandling.StopCancelClose;
|
|
StopTargetHandling = StopTargetHandling.PerEntryExecution;
|
|
BarsRequiredToTrade = 20;
|
|
|
|
EnableSDK = true;
|
|
DailyLossLimit = 1000.0;
|
|
MaxTradeRisk = 200.0;
|
|
MaxOpenPositions = 3;
|
|
RiskPerTrade = 100.0;
|
|
MinContracts = 1;
|
|
MaxContracts = 10;
|
|
EnableKillSwitch = false;
|
|
EnableVerboseLogging = false;
|
|
_killSwitchTriggered = false;
|
|
}
|
|
else if (State == State.DataLoaded)
|
|
{
|
|
if (EnableSDK)
|
|
{
|
|
try
|
|
{
|
|
InitializeSdkComponents();
|
|
_sdkInitialized = true;
|
|
Print(string.Format("[SDK] {0} initialized successfully", Name));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Print(string.Format("[SDK ERROR] Initialization failed: {0}", ex.Message));
|
|
Log(string.Format("[SDK ERROR] {0}", ex.ToString()), LogLevel.Error);
|
|
_sdkInitialized = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnBarUpdate()
|
|
{
|
|
// Kill switch check — must be first
|
|
if (EnableKillSwitch)
|
|
{
|
|
if (!_killSwitchTriggered)
|
|
{
|
|
_killSwitchTriggered = true;
|
|
Print(string.Format("[SDK] KILL SWITCH ACTIVATED at {0} — flattening all positions.", Time[0]));
|
|
try
|
|
{
|
|
ExitLong("KillSwitch");
|
|
ExitShort("KillSwitch");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Print(string.Format("[SDK] Kill switch flatten error: {0}", ex.Message));
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (!_sdkInitialized || _sdkStrategy == null)
|
|
{
|
|
if (CurrentBar == 0)
|
|
Print(string.Format("[SDK] Not initialized: sdkInit={0}, strategy={1}", _sdkInitialized, _sdkStrategy != null));
|
|
return;
|
|
}
|
|
|
|
if (CurrentBar < BarsRequiredToTrade)
|
|
{
|
|
if (CurrentBar == 0)
|
|
Print(string.Format("[SDK] Waiting for bars: current={0}, required={1}", CurrentBar, BarsRequiredToTrade));
|
|
return;
|
|
}
|
|
|
|
if (Time[0] == _lastBarTime)
|
|
return;
|
|
|
|
_lastBarTime = Time[0];
|
|
|
|
// Log first processable bar and every 100th bar.
|
|
if (CurrentBar == BarsRequiredToTrade || CurrentBar % 100 == 0)
|
|
{
|
|
Print(string.Format("[SDK] Processing bar {0}: {1} O={2:F2} H={3:F2} L={4:F2} C={5:F2}",
|
|
CurrentBar,
|
|
Time[0].ToString("yyyy-MM-dd HH:mm"),
|
|
Open[0],
|
|
High[0],
|
|
Low[0],
|
|
Close[0]));
|
|
}
|
|
|
|
try
|
|
{
|
|
var barData = ConvertCurrentBar();
|
|
var context = BuildStrategyContext();
|
|
|
|
StrategyIntent intent;
|
|
lock (_lock)
|
|
{
|
|
intent = _sdkStrategy.OnBar(barData, context);
|
|
}
|
|
|
|
if (intent != null)
|
|
{
|
|
Print(string.Format("[SDK] Intent generated: {0} {1} @ {2}", intent.Side, intent.Symbol, intent.EntryType));
|
|
ProcessStrategyIntent(intent, context);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_logger != null)
|
|
_logger.LogError("OnBarUpdate failed: {0}", ex.Message);
|
|
|
|
Print(string.Format("[SDK ERROR] OnBarUpdate: {0}", ex.Message));
|
|
Log(string.Format("[SDK ERROR] {0}", ex.ToString()), LogLevel.Error);
|
|
}
|
|
}
|
|
|
|
protected override void OnOrderUpdate(
|
|
Order order,
|
|
double limitPrice,
|
|
double stopPrice,
|
|
int quantity,
|
|
int filled,
|
|
double averageFillPrice,
|
|
NinjaTrader.Cbi.OrderState orderState,
|
|
DateTime time,
|
|
ErrorCode errorCode,
|
|
string nativeError)
|
|
{
|
|
if (!_sdkInitialized || _executionAdapter == null || order == null)
|
|
return;
|
|
|
|
if (string.IsNullOrEmpty(order.Name) || !order.Name.StartsWith("SDK_"))
|
|
return;
|
|
|
|
// Record NT8 rejections in circuit breaker
|
|
if (orderState == NinjaTrader.Cbi.OrderState.Rejected && _circuitBreaker != null)
|
|
{
|
|
var reason = string.Format("{0} {1}", errorCode, nativeError ?? string.Empty);
|
|
_circuitBreaker.RecordOrderRejection(reason);
|
|
Print(string.Format("[SDK] Order rejected by NT8: {0}", reason));
|
|
}
|
|
|
|
_executionAdapter.ProcessOrderUpdate(
|
|
order.OrderId,
|
|
order.Name,
|
|
orderState.ToString(),
|
|
filled,
|
|
averageFillPrice,
|
|
(int)errorCode,
|
|
nativeError);
|
|
}
|
|
|
|
protected override void OnExecutionUpdate(
|
|
Execution execution,
|
|
string executionId,
|
|
double price,
|
|
int quantity,
|
|
MarketPosition marketPosition,
|
|
string orderId,
|
|
DateTime time)
|
|
{
|
|
if (!_sdkInitialized || _executionAdapter == null || execution == null || execution.Order == null)
|
|
return;
|
|
|
|
if (string.IsNullOrEmpty(execution.Order.Name) || !execution.Order.Name.StartsWith("SDK_"))
|
|
return;
|
|
|
|
_executionAdapter.ProcessExecution(orderId, executionId, price, quantity, time);
|
|
}
|
|
|
|
private void InitializeSdkComponents()
|
|
{
|
|
_logger = new BasicLogger(Name);
|
|
|
|
Print(string.Format("[SDK] Initializing with: DailyLoss={0:C}, TradeRisk={1:C}, MaxPos={2}",
|
|
DailyLossLimit,
|
|
MaxTradeRisk,
|
|
MaxOpenPositions));
|
|
|
|
_riskConfig = new RiskConfig(DailyLossLimit, MaxTradeRisk, MaxOpenPositions, true);
|
|
_sizingConfig = new SizingConfig(
|
|
SizingMethod.FixedDollarRisk,
|
|
MinContracts,
|
|
MaxContracts,
|
|
RiskPerTrade,
|
|
new Dictionary<string, object>());
|
|
|
|
_strategyConfig = new StrategyConfig(
|
|
Name,
|
|
Instrument.MasterInstrument.Name,
|
|
new Dictionary<string, object>(),
|
|
_riskConfig,
|
|
_sizingConfig);
|
|
|
|
_riskManager = new BasicRiskManager(_logger);
|
|
_positionSizer = new BasicPositionSizer(_logger);
|
|
_circuitBreaker = new ExecutionCircuitBreaker(
|
|
NullLogger<ExecutionCircuitBreaker>.Instance,
|
|
failureThreshold: 3,
|
|
timeout: TimeSpan.FromSeconds(30));
|
|
_executionAdapter = new NT8ExecutionAdapter();
|
|
|
|
_sdkStrategy = CreateSdkStrategy();
|
|
if (_sdkStrategy == null)
|
|
throw new InvalidOperationException("CreateSdkStrategy returned null");
|
|
|
|
_sdkStrategy.Initialize(_strategyConfig, null, _logger);
|
|
ConfigureStrategyParameters();
|
|
|
|
_ordersSubmittedToday = 0;
|
|
_lastBarTime = DateTime.MinValue;
|
|
_lastAccountInfo = null;
|
|
_lastPosition = null;
|
|
_currentSession = null;
|
|
}
|
|
|
|
private BarData ConvertCurrentBar()
|
|
{
|
|
return NT8DataConverter.ConvertBar(
|
|
Instrument.MasterInstrument.Name,
|
|
Time[0],
|
|
Open[0],
|
|
High[0],
|
|
Low[0],
|
|
Close[0],
|
|
(long)Volume[0],
|
|
(int)BarsPeriod.Value);
|
|
}
|
|
|
|
private StrategyContext BuildStrategyContext()
|
|
{
|
|
var customData = new Dictionary<string, object>();
|
|
customData.Add("CurrentBar", CurrentBar);
|
|
customData.Add("BarsRequiredToTrade", BarsRequiredToTrade);
|
|
customData.Add("OrdersToday", _ordersSubmittedToday);
|
|
|
|
return NT8DataConverter.ConvertContext(
|
|
Instrument.MasterInstrument.Name,
|
|
Time[0],
|
|
BuildPositionInfo(),
|
|
BuildAccountInfo(),
|
|
BuildSessionInfo(),
|
|
customData);
|
|
}
|
|
|
|
private AccountInfo BuildAccountInfo()
|
|
{
|
|
var accountInfo = NT8DataConverter.ConvertAccount(100000.0, 250000.0, 0.0, 0.0, DateTime.UtcNow);
|
|
_lastAccountInfo = accountInfo;
|
|
return accountInfo;
|
|
}
|
|
|
|
private SdkPosition BuildPositionInfo()
|
|
{
|
|
var p = NT8DataConverter.ConvertPosition(
|
|
Instrument.MasterInstrument.Name,
|
|
Position.Quantity,
|
|
Position.AveragePrice,
|
|
0.0,
|
|
0.0,
|
|
DateTime.UtcNow);
|
|
|
|
_lastPosition = p;
|
|
return p;
|
|
}
|
|
|
|
private MarketSession BuildSessionInfo()
|
|
{
|
|
if (_currentSession != null && _currentSession.SessionStart.Date == Time[0].Date)
|
|
return _currentSession;
|
|
|
|
var sessionStart = Time[0].Date.AddHours(9).AddMinutes(30);
|
|
var sessionEnd = Time[0].Date.AddHours(16);
|
|
var isRth = Time[0].Hour >= 9 && Time[0].Hour < 16;
|
|
var sessionName = isRth ? "RTH" : "ETH";
|
|
|
|
_currentSession = NT8DataConverter.ConvertSession(sessionStart, sessionEnd, isRth, sessionName);
|
|
return _currentSession;
|
|
}
|
|
|
|
private void ProcessStrategyIntent(StrategyIntent intent, StrategyContext context)
|
|
{
|
|
if (EnableVerboseLogging)
|
|
Print(string.Format("[SDK] Validating intent: {0} {1}", intent.Side, intent.Symbol));
|
|
|
|
var riskDecision = _riskManager.ValidateOrder(intent, context, _riskConfig);
|
|
if (!riskDecision.Allow)
|
|
{
|
|
if (EnableVerboseLogging)
|
|
Print(string.Format("[SDK] Risk REJECTED: {0}", riskDecision.RejectReason));
|
|
if (_logger != null)
|
|
_logger.LogWarning("Intent rejected by risk manager: {0}", riskDecision.RejectReason);
|
|
return;
|
|
}
|
|
|
|
if (EnableVerboseLogging)
|
|
Print(string.Format("[SDK] Risk approved"));
|
|
|
|
var sizingResult = _positionSizer.CalculateSize(intent, context, _sizingConfig);
|
|
if (EnableVerboseLogging)
|
|
{
|
|
Print(string.Format("[SDK] Position size: {0} contracts (min={1}, max={2})",
|
|
sizingResult.Contracts,
|
|
MinContracts,
|
|
MaxContracts));
|
|
}
|
|
|
|
if (sizingResult.Contracts < MinContracts)
|
|
{
|
|
if (EnableVerboseLogging)
|
|
Print(string.Format("[SDK] Size too small: {0} < {1}", sizingResult.Contracts, MinContracts));
|
|
return;
|
|
}
|
|
|
|
var request = new OmsOrderRequest();
|
|
request.Symbol = intent.Symbol;
|
|
request.Side = MapOrderSide(intent.Side);
|
|
request.Type = MapOrderType(intent.EntryType);
|
|
request.Quantity = sizingResult.Contracts;
|
|
request.LimitPrice = intent.LimitPrice.HasValue ? (decimal?)intent.LimitPrice.Value : null;
|
|
request.StopPrice = null;
|
|
|
|
if (EnableVerboseLogging)
|
|
{
|
|
Print(string.Format("[SDK] Submitting order: {0} {1} {2} @ {3}",
|
|
request.Side,
|
|
request.Quantity,
|
|
request.Symbol,
|
|
request.Type));
|
|
}
|
|
|
|
SubmitOrderToNT8(request, intent);
|
|
_ordersSubmittedToday++;
|
|
}
|
|
|
|
private void SubmitOrderToNT8(OmsOrderRequest request, StrategyIntent intent)
|
|
{
|
|
// Circuit breaker gate
|
|
if (_circuitBreaker != null && !_circuitBreaker.ShouldAllowOrder())
|
|
{
|
|
var state = _circuitBreaker.GetState();
|
|
Print(string.Format("[SDK] Circuit breaker OPEN — order blocked: {0}", state.Reason));
|
|
if (_logger != null)
|
|
_logger.LogWarning("Circuit breaker blocked order: {0}", state.Reason);
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
var orderName = string.Format("SDK_{0}_{1}", intent.Symbol, DateTime.Now.Ticks);
|
|
_executionAdapter.SubmitOrder(request, orderName);
|
|
|
|
if (request.Side == OmsOrderSide.Buy)
|
|
{
|
|
if (request.Type == OmsOrderType.Market)
|
|
EnterLong(request.Quantity, orderName);
|
|
else if (request.Type == OmsOrderType.Limit && request.LimitPrice.HasValue)
|
|
EnterLongLimit(request.Quantity, (double)request.LimitPrice.Value, orderName);
|
|
else if (request.Type == OmsOrderType.StopMarket && request.StopPrice.HasValue)
|
|
EnterLongStopMarket(request.Quantity, (double)request.StopPrice.Value, orderName);
|
|
}
|
|
else if (request.Side == OmsOrderSide.Sell)
|
|
{
|
|
if (request.Type == OmsOrderType.Market)
|
|
EnterShort(request.Quantity, orderName);
|
|
else if (request.Type == OmsOrderType.Limit && request.LimitPrice.HasValue)
|
|
EnterShortLimit(request.Quantity, (double)request.LimitPrice.Value, orderName);
|
|
else if (request.Type == OmsOrderType.StopMarket && request.StopPrice.HasValue)
|
|
EnterShortStopMarket(request.Quantity, (double)request.StopPrice.Value, orderName);
|
|
}
|
|
|
|
if (intent.StopTicks > 0)
|
|
SetStopLoss(orderName, CalculationMode.Ticks, (int)intent.StopTicks, false);
|
|
|
|
if (intent.TargetTicks.HasValue && intent.TargetTicks.Value > 0)
|
|
SetProfitTarget(orderName, CalculationMode.Ticks, (int)intent.TargetTicks.Value);
|
|
|
|
if (_circuitBreaker != null)
|
|
_circuitBreaker.OnSuccess();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_circuitBreaker != null)
|
|
_circuitBreaker.OnFailure();
|
|
|
|
Print(string.Format("[SDK] SubmitOrderToNT8 failed: {0}", ex.Message));
|
|
if (_logger != null)
|
|
_logger.LogError("SubmitOrderToNT8 failed: {0}", ex.Message);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private static OmsOrderSide MapOrderSide(SdkOrderSide side)
|
|
{
|
|
if (side == SdkOrderSide.Buy)
|
|
return OmsOrderSide.Buy;
|
|
return OmsOrderSide.Sell;
|
|
}
|
|
|
|
private static OmsOrderType MapOrderType(SdkOrderType type)
|
|
{
|
|
if (type == SdkOrderType.Market)
|
|
return OmsOrderType.Market;
|
|
if (type == SdkOrderType.Limit)
|
|
return OmsOrderType.Limit;
|
|
if (type == SdkOrderType.StopLimit)
|
|
return OmsOrderType.StopLimit;
|
|
return OmsOrderType.StopMarket;
|
|
}
|
|
|
|
protected OmsOrderStatus GetSdkOrderStatus(string orderName)
|
|
{
|
|
if (_executionAdapter == null)
|
|
return null;
|
|
return _executionAdapter.GetOrderStatus(orderName);
|
|
}
|
|
}
|
|
}
|
|
|