The contracts a footprint / volume-profile / DOM plugin consumes: the per-bar orderflow model in TradeStrike.Pipeline.OrderFlow, and the live Level-2 / Level-3 market-depth surface in TradeStrike.Pipeline.MarketDepth.

Orderflow — TradeStrike.Pipeline.OrderFlow

The per-bar orderflow model footprint-class indicators read, plus the volume-profile-window seam a drawing tool requests. Add using TradeStrike.Pipeline.OrderFlow; to reach these types.

OrderFlowBar

A readonly record struct: the OHLCV Bar plus parallel per-price-level bid/ask volume and trade-print counts. Prices are discretized to integer ticks; level i sits at (LowTicks + i) × TickSize + PriceOffset. Designed for allocation-free reads in tight render loops.

Constructors. Three overloads, additive:

OrderFlowBar.cs// Full-fidelity: bid/ask/trade-count arrays + running-delta extremes (validated).
public OrderFlowBar(Bar bar, long lowTicks, double tickSize,
    long[] bidVolumes, long[] askVolumes, long[] tradeCounts,
    long localDeltaHigh, long localDeltaLow,
    long[]? bidTradeCounts = null, long[]? askTradeCounts = null,
    OrderFlowBarStats? stats = null, double priceOffset = 0);

// Defaults the running-delta extremes to 0 (empty / no-tick bars).
public OrderFlowBar(Bar bar, long lowTicks, double tickSize,
    long[] bidVolumes, long[] askVolumes, long[] tradeCounts);

// Volume-only: every level's TradeCount = 0 (seeding, fixtures).
public OrderFlowBar(Bar bar, long lowTicks, double tickSize,
    long[] bidVolumes, long[] askVolumes);

OrderFlowLevel — one price row, a readonly record struct returned by GetLevel / TryGetLevelAtPrice:

OrderFlowBarStats

A readonly record struct of per-bar quantities that can only be computed during tick aggregation (they depend on tick order). Carried by OrderFlowBar.Stats; null when no tick aggregator ran.

OrderFlowBarStats.cspublic readonly record struct OrderFlowBarStats(
    long RunningDeltaMax,
    long RunningDeltaMin,
    long AskVolumeSinceHigh,
    long BidVolumeSinceHigh,
    long AskVolumeSinceLow,
    long BidVolumeSinceLow,
    double VolumePerSecond,
    bool? LastTickIsBid = null,
    long FirstTickVolume = 0,
    System.TimeSpan? TradeSpan = null);

OrderFlowResolution

Backfill granularity an orderflow consumer requests. Coarser = far less data = faster backfill, at the cost of aggressor fidelity. The value round-trips by name, so the numeric assignments are free to change.

OrderFlowWindowRequest

An immutable readonly record struct describing the volume-at-price profile a tool wants for a time window. Value equality makes it double as the host's cache key — same window + parameters resolve to the same cached profile; dragging an anchor produces a distinct key and a fresh build.

OrderFlowWindowRequest.cspublic readonly record struct OrderFlowWindowRequest(
    DateTime FromUtc,
    DateTime ToUtcExclusive,
    OrderFlowResolution Resolution,
    int TickAggregation,
    double ValueAreaPercentage,
    bool EnableSmoothing,
    int SmoothingPeriod,
    int HighVolumeNodeCount,
    int LowVolumeNodeCount,
    int HighVolumeRegionSize,
    int LowVolumeRegionSize);

bool HasWindow — true only when ToUtcExclusive > FromUtc.

VolumeProfileWindow

A finished volume-at-price profile for one window, a plain sealed record free of engine types so a contracts-only drawing tool can render it. Produced host-side and handed back via IOrderFlowWindowSource.

VolumeProfileWindow.cspublic sealed record VolumeProfileWindow(
    IReadOnlyList<VolumeProfileBin> Bins,
    double BucketStep,
    double MaxVolume,
    double MaxAbsDelta,
    double TotalVolume,
    double Poc,
    double ValueAreaHigh,
    double ValueAreaLow,
    double HighPrice,
    double LowPrice,
    IReadOnlyList<double> HighVolumeNodePrices,
    IReadOnlyList<double> LowVolumeNodePrices,
    DateTime FromUtc,
    DateTime ToUtcExclusive);

bool IsEmpty — true when the window enclosed no traded volume. Each row is a VolumeProfileBin (readonly record struct):

IOrderFlowWindowSource

Host-provided seam that resolves an OrderFlowWindowRequest to a VolumeProfileWindow. Surfaced to drawing tools through IDrawingToolRenderContext.OrderFlowWindows.

IOrderFlowWindowSource.cspublic interface IOrderFlowWindowSource
{
    // Returns the cached profile when ready, or null while a build is in flight.
    // On a cache miss, kicks an async build and repaints when done. Never blocks.
    VolumeProfileWindow? GetOrRequest(in OrderFlowWindowRequest request);
}

Call it from the synchronous render loop: it returns immediately, so a tool paints a "calculating" placeholder on null and the real profile on the next frame after the async build completes.

Market depth — TradeStrike.Pipeline.MarketDepth

The live order-book surface. A provider may offer aggregated Level-2 (IMarketDepthFeed), per-order Level-3 / MBO (IMarketByOrderFeed), or both; the OrderBook unifies whichever arrives. Add using TradeStrike.Pipeline.MarketDepth;.

IMarketDepthFeed

Live aggregated Level-2 depth feed. Emits DepthUpdate per price-level change. Events may arrive on any thread; the feed reference-counts per instrument so subscribers share one upstream connection.

IMarketDepthFeed.cspublic interface IMarketDepthFeed : IDisposable
{
    IDisposable Subscribe(string instrumentId, Action<DepthUpdate> onUpdate);
    event Action? SubscriptionReset;   // drop state; default no-op
}

SubscriptionReset fires when consumers must drop all depth state (typically a connection loss). Disposing the token from Subscribe unsubscribes; the upstream sub is torn down when the last subscriber drops.

IMarketByOrderFeed

Live Market-By-Order (Level-3) feed. Emits MboEvent per resting-order lifecycle event (Add / Modify / Cancel). MboEvent.OrderId must be the venue's exchange-supplied id, stable across Modify (including a price move).

IMarketByOrderFeed.cspublic interface IMarketByOrderFeed : IDisposable
{
    IDisposable Subscribe(string instrumentId, Action<MboEvent> onEvent);
    event Action? SubscriptionReset;   // clear book on connection loss; default no-op
}

IOrderBook

Read-only view onto a live OrderBook — the surface exposed via IIndicatorContext.OrderBook. The mutation API stays on the concrete OrderBook; indicator code only reads. Callers that need a frozen copy use OrderBookSnapshot.Capture.

OrderBook

The concrete sealed class OrderBook : IOrderBook for one instrument. Accepts both aggregated L2 and per-order MBO events into a unified per-level surface. Not internally synchronised — feed code holds the lock.

OrderBookSnapshot

Immutable, render-safe copy of a book at one moment — flat Bids / Asks arrays (index 0 = top of book) so iteration is allocation-free and rows match visual ladder order. Per-order detail is dropped; each row is aggregated only.

PriceLevel

One price level inside an OrderBook (a sealed class). Carries the aggregated Size and, when MBO-fed, an ordered per-order queue. A level constructed only from L2 reports OrderCount == 0.

OrderBookEntry

One resting order in an MBO-mode book (a sealed class; identity is OrderId).

DepthUpdate

One aggregated Level-2 depth event, a readonly record struct passed by value. Feed sources pass SequenceNumber = 0; the framework's sequencer stamps it during fan-out.

DepthUpdate.cspublic readonly record struct DepthUpdate(
    long SequenceNumber,
    DateTime ExchangeTimestampUtc,
    string InstrumentId,
    Side Side,
    DepthAction Action,
    double Price,
    long Size);

DepthAction

Kind of update a DepthUpdate carries (an enum : byte).

MboEvent

One Market-By-Order event, a readonly record struct passed by value. Carries the individual resting order's identity, price, size and queue priority. On a price-move Modify, PrevPrice holds the old price (double.NaN when unchanged).

MboEvent.cspublic readonly record struct MboEvent(
    long SequenceNumber,
    DateTime ExchangeTimestampUtc,
    string InstrumentId,
    string OrderId,
    Side Side,
    MboAction Action,
    double Price,
    long Size,
    ulong QueuePriority,
    double PrevPrice);

MboAction

Lifecycle of an MBO event (an enum : byte). Mirrors Rithmic DepthByOrder NEW / CHANGE / DELETE.

Side

Side of the book a depth or order event applies to (an enum : byte). Two-valued — every depth event is sided at the source (aggressor classification on a trade is separate, via TickFlags).

Example — reading the book from an indicator

DepthImbalance.csusing TradeStrike.Pipeline.Indicators;
using TradeStrike.Pipeline.MarketDepth;

// Inside an indicator: read top-of-book imbalance each calculation.
protected override void OnCalculate()
{
    IOrderBook book = Context.OrderBook;
    if (book is null) return;

    double bid = book.BestBidPrice, ask = book.BestAskPrice;
    if (double.IsNaN(bid) || double.IsNaN(ask)) return;   // one side empty

    PriceLevel? bestBid = book.GetLevel(Side.Bid, bid);
    PriceLevel? bestAsk = book.GetLevel(Side.Ask, ask);
    long bidSize = bestBid?.Size ?? 0, askSize = bestAsk?.Size ?? 0;

    // Imbalance in [-1, 1]: positive = bid-heavy.
    long total = bidSize + askSize;
    Imbalance[0] = total == 0 ? 0 : (double)(bidSize - askSize) / total;
}

// To hand the book to a render thread, snapshot it under the feed callback:
var snap = OrderBookSnapshot.Capture(Context.OrderBook, DateTime.UtcNow, maxLevelsPerSide: 20);