Trading

Reference

Trading

The order-routing surface: the trading provider and service, the order/position/account model, all order enums, trading events, risk validation, commission models, bracket presets, and the ATM advanced-trade-management types.

On this page

Provider & service — TradeStrike.Pipeline.Trading

An ITradingProvider is one connected brokerage; the host aggregates providers behind an ITradingService and fans out a single TradingEvent stream. Both expose the same place / cancel / modify / flatten verbs.

Type Members
ITradingProvider : IDisposable ProviderKey, Capabilities, bool ReportsCommission, IsRunning, Accounts, OpenOrders, Positions; event Action<TradingEvent>? EventEmitted; Task<bool> StartAsync(ct), Task StopAsync(ct), Task<OrderId> PlaceAsync(OrderRequest, AccountId, ct), Task<bool> CancelAsync(OrderId, ct), Task<bool> ModifyAsync(OrderId, OrderModification, ct), Task<bool> FlattenAsync(AccountId, string? instrument = null, ct).
ITradingService : IDisposable Accounts, OpenOrders, Positions, Providers; Account? GetAccount(AccountId), Order? GetOrder(OrderId), TradingProviderCapabilities GetCapabilities(AccountId); event Action<TradingEvent>? EventEmitted; void AddProvider(ITradingProvider), bool RemoveProvider(string providerKey); same PlaceAsync / CancelAsync / ModifyAsync / FlattenAsync verbs.
TradingProviderCapabilities [Flags] enum: None, PlaceOrders, CancelOrders, ModifyOrders, FlattenPositions, AccountDiscovery, PositionStream, FillsStream, Brackets, AssetBalances, Full.
TradingProviderKeys static: const char VenueQualifierSeparator, string VenueOf(string providerKey), string Compose(string venue, string qualifier), bool BelongsToVenue(string providerKey, string venue).
IBracketLegSplitController bool CanSplit(OrderId), bool SplitLeg(OrderId, decimal quantity, int widenTicks = 0).

Orders & enums

Build an OrderRequest (optionally with a BracketSpec) and submit it; the resulting Order carries its state and fills. OrderRequest.Validate() throws on malformed requests — call it before placing.

Type Members
OrderRequest record (string Instrument, OrderSide Side, OrderType Type, decimal Quantity, decimal? LimitPrice = null, decimal? StopPrice = null, TimeInForce TimeInForce = Day, BracketSpec? Bracket = null, string? OcoGroupId = null, string? ClientTag = null, ...); init InstrumentKey, InstrumentVenue, OriginId; void Validate().
BracketSpec record (decimal? StopLossPrice, decimal? TakeProfitPrice); void Validate(OrderSide entrySide).
OrderModification record (decimal? NewQuantity = null, decimal? NewLimitPrice = null, decimal? NewStopPrice = null, TimeInForce? NewTimeInForce = null).
Order record (OrderId Id, AccountId AccountId, OrderRequest Request, OrderRequest OriginalRequest, OrderState State, decimal FilledQuantity, decimal AverageFillPrice, string? BrokerOrderId, string? RejectReason, DateTime CreatedUtc, DateTime UpdatedUtc); IsTerminal, RemainingQuantity; static Pending(id, accountId, request).
Fill record (OrderId OrderId, decimal Quantity, decimal Price, decimal Commission, DateTime TimestampUtc, string? FeeCurrency = null).
OrderId readonly record struct: Guid Value; static New(), bool TryParse(string?, out OrderId).
OrderSide enum: Buy, Sell.
OrderType enum: Market, Limit, Stop, StopLimit.
TimeInForce enum: Day, Gtc, Ioc, Fok.
OrderState enum: Pending, Working, PartiallyFilled, Filled, Cancelled, Rejected, Expired, Stale.

Accounts & positions

Type Members
Account record (AccountId Id, string DisplayName, string Currency, decimal CashValue, decimal RealizedPnL, decimal UnrealizedPnL, decimal MarginUsed, decimal BuyingPower, DateTime UpdatedUtc); init IsSnapshot, AccountMetrics? Metrics; Mode, Equity; static NewSim(...).
AccountId readonly record struct: string ProviderKey, string ProviderAccountId, AccountMode Mode; static None; IsEmpty, bool TryParse(string?, out AccountId).
AccountMode enum: Live, Paper, Sim.
AccountBalance record: string Asset, decimal Total, decimal Available, decimal Reserved; static Create(asset, total, available).
AccountMetrics record of nullable broker metrics: TotalCashBalance, GrossRealizedPnL, TotalCommissions, MaintenanceMargin, ExcessBuyMargin/ExcessSellMargin, UsedBuyingPower, DailyLossLimit, DrawdownPercentUsed, TrailingDrawdownFloor, NetQuantity, OpenPositions, FilledBuys/FilledSells, WorkingBuys/WorkingSells, …
Position record (AccountId AccountId, string Instrument, decimal Quantity, decimal AverageEntryPrice, decimal LastPrice, decimal UnrealizedPnL, decimal RealizedPnLSession, DateTime OpenedUtc, DateTime UpdatedUtc, decimal Multiplier = 1m); IsLong/IsShort/IsFlat; ApplyFill(side, qty, price, time), MarkToMarket(price, time); static Empty(...).

Trading events

The provider/service stream a single abstract TradingEvent hierarchy. TimestampUtc and a monotonic Sequence are on the base; switch on the concrete type to react.

Type Carries
TradingEvent (abstract) DateTime TimestampUtc, long Sequence.
AccountSnapshotEvent Account Account.
AccountRemovedEvent AccountId AccountId.
OrderUpdateEvent Order Order.
FillEvent AccountId AccountId, Fill Fill.
PositionUpdateEvent Position Position.
BalanceSnapshotEvent AccountId AccountId, IReadOnlyList<AccountBalance> Balances.
ConnectionStateEvent string ProviderKey, bool Connected, string? Reason.

ATM — TradeStrike.Pipeline.Trading.Atm

An AtmStrategy describes a multi-bracket exit plan (per-bracket stop/target, auto-breakeven, auto-trail, optional time exit). The host's ATM engine consumes it; plugins build and validate strategies and place/cancel/modify through an IAtmOrderGateway.

Type Members
AtmStrategy record (string Name, AtmParameterUnit Unit, IReadOnlyList<AtmBracket> Brackets, AtmStopStrategy StopStrategy, AtmTimeExit? TimeExit = null); decimal TotalQuantity, void Validate().
AtmBracket record (decimal Quantity, decimal StopLoss, decimal ProfitTarget); bool IsRunner, Validate(int index).
AtmStopStrategy record (AtmStopOrderType StopOrderType, decimal StopLimitOffsetTicks, AtmAutoBreakeven? AutoBreakeven, AtmAutoTrail? AutoTrail); static StaticMarket, Validate().
AtmAutoBreakeven record (decimal ProfitTrigger, decimal Plus); Validate().
AtmAutoTrail record (IReadOnlyList<AtmAutoTrailStep> Steps); const int MaxSteps = 3, Validate().
AtmAutoTrailStep record (decimal ProfitTrigger, decimal StopLoss, decimal Frequency); Validate(int index).
AtmTimeExit record (TimeSpan CloseAt, string TimeZoneId); Validate().
AtmParameterUnit enum: Ticks, Currency, Percent, Price.
AtmStopOrderType enum: StopMarket, StopLimit, Simulated.
AtmEntryQuantity static: decimal Resolve(AtmStrategy?, decimal requestedQuantity).
IAtmOrderGateway void Place(OrderRequest), void Cancel(OrderId), void Modify(OrderId, OrderModification).
IAtmStrategyStore IReadOnlyList<AtmStrategy> Load(), void Save(...), event EventHandler? Changed.
IAtmDefaultsStore Load(), Save(...), string? GetDefault(string instrument), void SetDefault(string instrument, string? strategyName).
IPositionManagementRegistry IDisposable Claim(...), IDisposable? TryClaim(...), bool IsClaimed(...), event Action? Changed.
ManagedInstrument readonly record struct (string? CanonicalKey, string NativeSymbol).
IDynamicStopLevelSource decimal? CurrentLevel, string Description — feed a trailing stop from an indicator.

Bracket presets — TradeStrike.Pipeline.Trading.Brackets

A reusable stop/target offset preset (in price or ticks) plus the math to turn it into absolute bracket prices for a given entry and side.

Type Members
BracketPreset record (string name, BracketOffsetUnit unit, decimal? stopLossOffset, decimal? takeProfitOffset); init Name, Unit, StopLossOffset, TakeProfitOffset.
BracketOffsetUnit enum: Price, Ticks.
BracketPriceResult readonly record struct (decimal? StopLossPrice, decimal? TakeProfitPrice).
BracketPresetMath static: BracketPriceResult ComputeBracketPrices(decimal entryPrice, OrderSide side, BracketPreset preset, decimal tickSize).
IBracketPresetStore IReadOnlyList<BracketPreset> Load(), void Save(IReadOnlyList<BracketPreset> presets).

Risk validation — TradeStrike.Pipeline.Trading.Risk

An IRiskValidator inspects an order against RiskLimits and a RiskSnapshot and returns a RiskRejection (one of the typed subtypes) or null to allow it.

Type Members
IRiskValidator RiskRejection? Validate(OrderRequest, AccountId, RiskSnapshot), RiskRejection? ValidateModification(OrderRequest currentOrder, decimal newQuantity, AccountId, RiskSnapshot).
RiskLimits record: decimal? MaxPositionSize, MaxDailyRealizedLoss, int? MaxOpenOrders, MaxOrderQuantity, MaxTotalLoss, DailyProfitLock, int? MaxConsecutiveLosers.
RiskSnapshot record (Account Account, Position? CurrentPosition, int OpenOrderCount, AccountRiskState? RiskState = null).
AccountRiskState record (int ConsecutiveLosers, DateOnly TradingDate); static ForDate(DateOnly).
RiskRejection (abstract) string Reason; subtypes PositionSizeExceeded, DailyLossLimitHit, OpenOrderCountExceeded, OrderQuantityExceeded, TotalLossLimitHit, DailyProfitTargetReached, ConsecutiveLossLimitHit, VenueNotConnected.
IRiskLimitsRegistry RiskLimits? GetLimits(AccountId), event Action<AccountId>? LimitsChanged.
IRiskLimitsStore IReadOnlyDictionary<AccountId,RiskLimits> Load(), void Save(...).
IAccountRiskStateRegistry AccountRiskState GetState(AccountId), event Action<AccountId>? StateChanged.
IRiskTradeOutcomeSink void OnTradeClosed(AccountId, decimal realizedPnLDelta, DateTime timestampUtc).

Commissions — TradeStrike.Pipeline.Trading.Commissions

An ICommissionModel turns a CommissionContext (symbol, qty, price, side, liquidity) into a CommissionResult. RateCommissionModel covers the common rate-based cases.

Type Members
ICommissionModel CommissionResult Compute(in CommissionContext ctx).
RateCommissionModel RateCommissionModel(CommissionRate rate); CommissionRate Rate, Compute(in ctx).
CommissionModels static: readonly ICommissionModel Zero, ICommissionModel Flat(decimal perUnit).
CommissionRate record (CommissionBasis basis, decimal value, decimal minFee = 0m, decimal maxFee = 0m, decimal? makerValue = null, decimal? takerValue = null, CommissionAccrual accrual = PerSide); static Zero.
CommissionContext readonly record struct (string Symbol, decimal Quantity, decimal Price, decimal Multiplier, OrderSide Side, Liquidity Liquidity, string Venue, decimal PriorOrderRawCommission = 0m, string? InstrumentKey = null).
CommissionResult readonly record struct (decimal Amount, decimal CumulativeRawCommission); static Zero.
CommissionBasis enum: PerUnit, PerOrder, PercentNotional, BasisPoints.
CommissionAccrual enum: PerSide, PerRound.
Liquidity enum: Unknown, Maker, Taker.

Price feed — TradeStrike.Pipeline.Trading.Sim

The price source the simulated/paper trading engine subscribes to. Plugins rarely implement this; it is documented here because TickQuote appears in sim and ATM flows.

Type Members
IPriceFeed IDisposable Subscribe(string instrument, Action<TickQuote> handler), TickQuote? GetLastTick(string instrument).
TickQuote readonly record struct (DateTime TimestampUtc, decimal Bid, decimal Ask, decimal Last); HasSpread, Mid; init ContinuousFromPrior, BidSize, AskSize, LastSize; static AtPrice(...).
← BackProviders