nt8-sdk/docs/API_REFERENCE.md

NT8 SDK - API Reference

Version: 0.2.0
Last Updated: February 15, 2026

---

Table of Contents

• Core Interfaces
• Risk Management
• Position Sizing
• Order Management
• Data Models
• Enumerations

---

Core Interfaces

IStrategy

Namespace: NT8.Core.Common.Interfaces

Defines the contract for trading strategy implementations.

public interface IStrategy
{
    StrategyMetadata Metadata { get; }
    
    void Initialize(
        StrategyConfig config,
        IMarketDataProvider dataProvider,
        ILogger logger);
    
    StrategyIntent? OnBar(BarData bar, StrategyContext context);
    
    StrategyIntent? OnTick(TickData tick, StrategyContext context);
    
    Dictionary<string, object> GetParameters();
    
    void SetParameters(Dictionary<string, object> parameters);
}

Properties:

Property	Type	Description
Metadata	StrategyMetadata	Strategy metadata (name, version, etc.)

Methods:

Initialize

Initializes the strategy with configuration and dependencies.

Parameters:

• config (StrategyConfig) - Strategy configuration
• dataProvider (IMarketDataProvider) - Market data provider
• logger (ILogger) - Logging interface

Example:

public void Initialize(StrategyConfig config, IMarketDataProvider dataProvider, ILogger logger)
{
    _config = config;
    _dataProvider = dataProvider;
    _logger = logger;
    
    LoadParameters(config.Parameters);
    
    _logger.LogInformation("Strategy initialized: {0}", Metadata.Name);
}

---

OnBar

Processes new bar data and generates trading intent if conditions are met.

Parameters:

• bar (BarData) - New bar data
• context (StrategyContext) - Current strategy context

Returns: StrategyIntent? - Trading intent or null

Example:

public StrategyIntent? OnBar(BarData bar, StrategyContext context)
{
    if (bar.Close > _threshold && context.CurrentPosition.Quantity == 0)
    {
        return new StrategyIntent(
            Symbol: bar.Symbol,
            Side: OrderSide.Buy,
            EntryType: OrderType.Market,
            LimitPrice: null,
            StopTicks: 8,
            TargetTicks: 16,
            Confidence: 0.75,
            Reason: "Breakout above threshold",
            Metadata: new()
        );
    }
    
    return null;
}

---

OnTick

Processes tick data (optional for high-frequency strategies).

Parameters:

• tick (TickData) - Tick data
• context (StrategyContext) - Current strategy context

Returns: StrategyIntent? - Trading intent or null

Default Implementation: Returns null

---

GetParameters / SetParameters

Get/Set strategy parameters for serialization.

Returns: Dictionary<string, object> - Parameter dictionary

Example:

public Dictionary<string, object> GetParameters()
{
    return new Dictionary<string, object>
    {
        ["StopTicks"] = _stopTicks,
        ["TargetTicks"] = _targetTicks,
        ["Threshold"] = _threshold
    };
}

public void SetParameters(Dictionary<string, object> parameters)
{
    if (parameters.TryGetValue("StopTicks", out var stop))
        _stopTicks = (int)stop;
    
    if (parameters.TryGetValue("TargetTicks", out var target))
        _targetTicks = (int)target;
}

---

Risk Management

IRiskManager

Namespace: NT8.Core.Risk

Validates trading intents against risk parameters.

public interface IRiskManager
{
    RiskDecision ValidateOrder(
        StrategyIntent intent,
        StrategyContext context,
        RiskConfig config);
    
    void OnFill(OrderFill fill);
    
    void OnPnLUpdate(double netPnL, double dayPnL);
    
    Task<bool> EmergencyFlatten(string reason);
    
    RiskStatus GetRiskStatus();
}

Methods:

ValidateOrder

Validates order intent against all risk parameters.

Parameters:

• intent (StrategyIntent) - Trading intent to validate
• context (StrategyContext) - Current context
• config (RiskConfig) - Risk configuration

Returns: RiskDecision - Validation result

Example:

var decision = riskManager.ValidateOrder(intent, context, riskConfig);

if (decision.Allow)
{
    // Proceed with order
    Console.WriteLine($"Order approved: Risk Level={decision.RiskLevel}");
}
else
{
    // Order rejected
    Console.WriteLine($"Order rejected: {decision.RejectReason}");
}

---

OnFill

Updates risk state after order fill.

Parameters:

• fill (OrderFill) - Fill information

Example:

var fill = new OrderFill(
    OrderId: orderId,
    Symbol: "ES",
    Quantity: 2,
    FillPrice: 4200.0,
    FillTime: DateTime.UtcNow,
    Commission: 4.50,
    ExecutionId: Guid.NewGuid().ToString()
);

riskManager.OnFill(fill);

---

OnPnLUpdate

Updates risk state with current P&L.

Parameters:

• netPnL (double) - Net P&L
• dayPnL (double) - Daily P&L

Example:

riskManager.OnPnLUpdate(netPnL: 500.0, dayPnL: -150.0);

---

EmergencyFlatten

Triggers emergency position flatten.

Parameters:

• reason (string) - Reason for emergency flatten

Returns: Task<bool> - Success indicator

Example:

var success = await riskManager.EmergencyFlatten("Connection lost");
if (success)
{
    Console.WriteLine("All positions flattened");
}

---

GetRiskStatus

Returns current risk system status.

Returns: RiskStatus - Current status

Example:

var status = riskManager.GetRiskStatus();

Console.WriteLine($"Trading Enabled: {status.TradingEnabled}");
Console.WriteLine($"Daily P&L: {status.DailyPnL:C}");
Console.WriteLine($"Open Positions: {status.OpenPositions}");

---

BasicRiskManager

Namespace: NT8.Core.Risk

Implements Tier 1 risk controls.

Features:

• Daily loss limits with auto-halt
• Per-trade risk caps
• Position count limits
• Emergency flatten

Constructor:

public BasicRiskManager(ILogger<BasicRiskManager> logger)

Example:

var riskManager = new BasicRiskManager(logger);

var config = new RiskConfig(
    DailyLossLimit: 1000,
    MaxTradeRisk: 200,
    MaxOpenPositions: 3,
    EmergencyFlattenEnabled: true
);

var decision = riskManager.ValidateOrder(intent, context, config);

---

AdvancedRiskManager

Namespace: NT8.Core.Risk

Implements Tier 2-3 risk controls.

Additional Features:

• Weekly rolling loss limits
• Trailing drawdown protection
• Cross-strategy exposure limits
• Correlation-based limits
• Time-based trading windows
• Risk modes and cooldown periods

Constructor:

public AdvancedRiskManager(
    IRiskManager basicRiskManager,
    ILogger<AdvancedRiskManager> logger)

Example:

var advancedRiskManager = new AdvancedRiskManager(
    new BasicRiskManager(logger),
    logger
);

var advancedConfig = new AdvancedRiskConfig(
    // Tier 1
    dailyLossLimit: 1000,
    maxTradeRisk: 200,
    maxOpenPositions: 3,
    
    // Tier 2
    weeklyLossLimit: 3000,
    trailingDrawdownLimit: 0.15,
    
    // Tier 3
    maxCrossStrategyExposure: 50000,
    correlationThreshold: 0.7,
    tradingHours: new[] { "09:30-16:00" }
);

var decision = advancedRiskManager.ValidateOrder(intent, context, advancedConfig);

---

Position Sizing

IPositionSizer

Namespace: NT8.Core.Sizing

Calculates position sizes for trading intents.

public interface IPositionSizer
{
    SizingResult CalculateSize(
        StrategyIntent intent,
        StrategyContext context,
        SizingConfig config);
    
    SizingMetadata GetMetadata();
}

Methods:

CalculateSize

Calculates position size based on sizing method.

Parameters:

• intent (StrategyIntent) - Trading intent
• context (StrategyContext) - Current context
• config (SizingConfig) - Sizing configuration

Returns: SizingResult - Calculated size

Example:

var config = new SizingConfig(
    Method: SizingMethod.FixedDollarRisk,
    MinContracts: 1,
    MaxContracts: 10,
    RiskPerTrade: 200,
    MethodParameters: new()
);

var result = sizer.CalculateSize(intent, context, config);

Console.WriteLine($"Contracts: {result.Contracts}");
Console.WriteLine($"Risk Amount: {result.RiskAmount:C}");

---

BasicPositionSizer

Namespace: NT8.Core.Sizing

Implements basic sizing methods.

Methods:

• Fixed contracts
• Fixed dollar risk

Constructor:

public BasicPositionSizer(ILogger<BasicPositionSizer> logger)

Example:

var sizer = new BasicPositionSizer(logger);

// Fixed contracts
var fixedConfig = new SizingConfig(
    Method: SizingMethod.FixedContracts,
    MinContracts: 1,
    MaxContracts: 5,
    RiskPerTrade: 200,
    MethodParameters: new() { ["contracts"] = 2 }
);

var result = sizer.CalculateSize(intent, context, fixedConfig);

---

AdvancedPositionSizer

Namespace: NT8.Core.Sizing

Implements advanced sizing methods.

Methods:

• Optimal-f (Ralph Vince)
• Volatility-adjusted (ATR/StdDev)
• Dollar-risk override with rounding

Constructor:

public AdvancedPositionSizer(ILogger<AdvancedPositionSizer> logger)

Example - Optimal-f:

var optimalFConfig = new SizingConfig(
    Method: SizingMethod.OptimalF,
    MinContracts: 1,
    MaxContracts: 10,
    RiskPerTrade: 500,
    MethodParameters: new()
    {
        ["historicalTrades"] = tradeHistory,
        ["riskOfRuinThreshold"] = 0.01,
        ["confidenceLevel"] = 0.95
    }
);

var result = sizer.CalculateSize(intent, context, optimalFConfig);

Example - Volatility-Adjusted:

var volConfig = new SizingConfig(
    Method: SizingMethod.VolatilityAdjusted,
    MinContracts: 1,
    MaxContracts: 10,
    RiskPerTrade: 300,
    MethodParameters: new()
    {
        ["atr"] = 15.5,
        ["normalATR"] = 12.0,
        ["volatilityWindow"] = 14,
        ["regime"] = "Normal"
    }
);

var result = sizer.CalculateSize(intent, context, volConfig);

---

OptimalFCalculator

Namespace: NT8.Core.Sizing

Calculates optimal-f (Ralph Vince method).

Methods:

CalculateOptimalF

public OptimalFResult CalculateOptimalF(
    List<TradeResult> trades,
    double capital,
    double riskOfRuinThreshold)

Parameters:

• trades - Historical trade results
• capital - Trading capital
• riskOfRuinThreshold - Maximum acceptable risk of ruin

Returns: OptimalFResult - Optimal-f calculation result

Example:

var calculator = new OptimalFCalculator(logger);

var trades = new List<TradeResult>
{
    new TradeResult(250, DateTime.Now.AddDays(-10)),
    new TradeResult(-100, DateTime.Now.AddDays(-9)),
    new TradeResult(300, DateTime.Now.AddDays(-8)),
    // ... more trades
};

var result = calculator.CalculateOptimalF(
    trades: trades,
    capital: 50000,
    riskOfRuinThreshold: 0.01
);

Console.WriteLine($"Optimal-f: {result.OptimalF}");
Console.WriteLine($"Recommended Contracts: {result.Contracts}");
Console.WriteLine($"Risk of Ruin: {result.RiskOfRuin:P}");

---

VolatilityAdjustedSizer

Namespace: NT8.Core.Sizing

Calculates volatility-adjusted position sizes.

Methods:

CalculateATRSize

public int CalculateATRSize(
    double targetRisk,
    double atr,
    double normalATR,
    double tickValue,
    int minContracts,
    int maxContracts)

Parameters:

• targetRisk - Target risk amount
• atr - Current ATR
• normalATR - Historical normal ATR
• tickValue - Tick value for symbol
• minContracts - Minimum contracts
• maxContracts - Maximum contracts

Returns: int - Calculated contracts

Example:

var sizer = new VolatilityAdjustedSizer(logger);

var contracts = sizer.CalculateATRSize(
    targetRisk: 300,
    atr: 18.5,
    normalATR: 15.0,
    tickValue: 12.50,
    minContracts: 1,
    maxContracts: 10
);

Console.WriteLine($"ATR-Adjusted Size: {contracts} contracts");

---

Order Management

IOrderManager

Namespace: NT8.Core.OMS

Manages complete order lifecycle.

public interface IOrderManager
{
    Task<string> SubmitOrderAsync(OrderRequest request);
    
    Task<bool> ModifyOrderAsync(string orderId, OrderModification modification);
    
    Task<bool> CancelOrderAsync(string orderId, string reason);
    
    OrderStatus? GetOrderStatus(string orderId);
    
    List<OrderStatus> GetActiveOrders();
    
    Task<string> FlattenPosition(string symbol, string reason);
    
    void SubscribeToOrderUpdates(Action<OrderStatus> callback);
    
    void UnsubscribeFromOrderUpdates(Action<OrderStatus> callback);
}

Methods:

SubmitOrderAsync

Submits new order.

Parameters:

• request (OrderRequest) - Order details

Returns: Task<string> - Order ID

Example:

var request = new OrderRequest(
    Symbol: "ES",
    Side: OrderSide.Buy,
    Quantity: 2,
    Type: OrderType.Market,
    LimitPrice: null,
    StopPrice: null,
    Tif: TimeInForce.Gtc,
    StrategyId: "MyStrategy",
    Metadata: new()
);

var orderId = await orderManager.SubmitOrderAsync(request);
Console.WriteLine($"Order submitted: {orderId}");

---

ModifyOrderAsync

Modifies working order.

Parameters:

• orderId (string) - Order ID
• modification (OrderModification) - Modification details

Returns: Task<bool> - Success indicator

Example:

var modification = new OrderModification(
    NewQuantity: 3,
    NewLimitPrice: 4205.0,
    NewStopPrice: null,
    Reason: "Adjust position size"
);

var success = await orderManager.ModifyOrderAsync(orderId, modification);

---

CancelOrderAsync

Cancels order.

Parameters:

• orderId (string) - Order ID
• reason (string) - Cancellation reason

Returns: Task<bool> - Success indicator

Example:

var success = await orderManager.CancelOrderAsync(orderId, "Market conditions changed");

---

GetOrderStatus

Retrieves order status.

Parameters:

• orderId (string) - Order ID

Returns: OrderStatus? - Order status or null

Example:

var status = orderManager.GetOrderStatus(orderId);

if (status != null)
{
    Console.WriteLine($"State: {status.State}");
    Console.WriteLine($"Filled: {status.FilledQuantity}/{status.Quantity}");
    
    if (status.FillPrice.HasValue)
    {
        Console.WriteLine($"Fill Price: {status.FillPrice:F2}");
    }
}

---

GetActiveOrders

Returns all active orders.

Returns: List<OrderStatus> - Active orders

Example:

var activeOrders = orderManager.GetActiveOrders();

Console.WriteLine($"Active Orders: {activeOrders.Count}");

foreach (var order in activeOrders)
{
    Console.WriteLine($"{order.OrderId}: {order.Symbol} {order.Side} {order.Quantity}");
}

---

FlattenPosition

Emergency position flatten.

Parameters:

• symbol (string) - Symbol to flatten
• reason (string) - Flatten reason

Returns: Task<string> - Flatten order ID

Example:

var orderId = await orderManager.FlattenPosition("ES", "Emergency stop");
Console.WriteLine($"Flatten order submitted: {orderId}");

---

SubscribeToOrderUpdates / UnsubscribeFromOrderUpdates

Subscribe to real-time order updates.

Parameters:

• callback (Action<OrderStatus>) - Callback function

Example:

void OnOrderUpdate(OrderStatus status)
{
    Console.WriteLine($"Order {status.OrderId} updated: {status.State}");
    
    if (status.State == OrderState.Filled)
    {
        Console.WriteLine($"Filled at {status.FillPrice:F2}");
    }
}

// Subscribe
orderManager.SubscribeToOrderUpdates(OnOrderUpdate);

// Later... unsubscribe
orderManager.UnsubscribeFromOrderUpdates(OnOrderUpdate);

---

Data Models

StrategyIntent

Namespace: NT8.Core.Common.Models

Represents a strategy's trading intent.

public record StrategyIntent(
    string Symbol,
    OrderSide Side,
    OrderType EntryType,
    double? LimitPrice,
    int StopTicks,
    int? TargetTicks,
    double Confidence,
    string Reason,
    Dictionary<string, object> Metadata
)
{
    public string IntentId { get; init; }
    public DateTime Timestamp { get; init; }
    public bool IsValid();
}

Properties:

Property	Type	Description
Symbol	string	Instrument symbol
Side	OrderSide	Buy/Sell/Flat
EntryType	OrderType	Market/Limit/Stop/StopLimit
LimitPrice	double?	Limit price (null for market)
StopTicks	int	Stop loss in ticks
TargetTicks	int?	Profit target in ticks
Confidence	double	Signal confidence (0.0-1.0)
Reason	string	Trade reason (human-readable)
Metadata	Dictionary	Additional strategy-specific data
IntentId	string	Unique identifier (auto-generated)
Timestamp	DateTime	Creation timestamp (auto-generated)

---

StrategyContext

Namespace: NT8.Core.Common.Models

Context information available to strategies.

public record StrategyContext(
    string Symbol,
    DateTime CurrentTime,
    Position CurrentPosition,
    AccountInfo Account,
    MarketSession Session,
    Dictionary<string, object> CustomData
);

---

RiskDecision

Namespace: NT8.Core.Risk

Risk validation result.

public record RiskDecision(
    bool Allow,
    string? RejectReason,
    StrategyIntent? ModifiedIntent,
    RiskLevel RiskLevel,
    Dictionary<string, object> RiskMetrics
);

Properties:

Property	Type	Description
Allow	bool	Whether order is allowed
RejectReason	string?	Reason if rejected
ModifiedIntent	StrategyIntent?	Modified intent (if applicable)
RiskLevel	RiskLevel	Risk level classification
RiskMetrics	Dictionary	Detailed risk metrics

---

SizingResult

Namespace: NT8.Core.Sizing

Position sizing calculation result.

public record SizingResult(
    int Contracts,
    double RiskAmount,
    SizingMethod Method,
    Dictionary<string, object> Calculations
);

Properties:

Property	Type	Description
Contracts	int	Calculated contract quantity
RiskAmount	double	Actual risk amount
Method	SizingMethod	Sizing method used
Calculations	Dictionary	Detailed calculation breakdown

---

OrderStatus

Namespace: NT8.Core.OMS

Current order status.

public record OrderStatus(
    string OrderId,
    string Symbol,
    OrderSide Side,
    int Quantity,
    int FilledQuantity,
    OrderState State,
    DateTime SubmitTime,
    DateTime? FillTime,
    double? FillPrice,
    string? RejectReason,
    Dictionary<string, object> Metadata
);

Properties:

Property	Type	Description
OrderId	string	Unique order identifier
Symbol	string	Instrument symbol
Side	OrderSide	Buy/Sell
Quantity	int	Total quantity
FilledQuantity	int	Filled quantity
State	OrderState	Current state
SubmitTime	DateTime	Submission timestamp
FillTime	DateTime?	Fill timestamp (if filled)
FillPrice	double?	Fill price (if filled)
RejectReason	string?	Rejection reason (if rejected)
Metadata	Dictionary	Additional order data

---

Enumerations

OrderSide

public enum OrderSide
{
    Buy = 1,
    Sell = -1,
    Flat = 0
}

OrderType

public enum OrderType
{
    Market,
    Limit,
    StopMarket,
    StopLimit
}

OrderState

public enum OrderState
{
    Pending,
    Working,
    PartiallyFilled,
    Filled,
    Cancelled,
    Rejected
}

TimeInForce

public enum TimeInForce
{
    Gtc,  // Good Till Canceled
    Ioc,  // Immediate Or Cancel
    Fok,  // Fill Or Kill
    Day   // Good For Day
}

SizingMethod

public enum SizingMethod
{
    FixedContracts,
    FixedDollarRisk,
    OptimalF,
    VolatilityAdjusted
}

RiskLevel

public enum RiskLevel
{
    Low,
    Medium,
    High,
    Critical
}

RoundingMode

public enum RoundingMode
{
    Floor,
    Ceiling,
    Nearest
}

---

For more information, see the main README or examples