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

Orderflow — SabrTrader.Pipeline.OrderFlow

The per-bar orderflow model footprint-class indicators read, plus the volume-profile-window seam a drawing tool requests. Add using SabrTrader.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,
    long UpTickVolume = 0,
    long DownTickVolume = 0,
    double? LastTradePrice = null,
    int LastTickRuleDirection = 0,
    bool? DeltaHighSetAfterLow = null,
    DateTime? FirstTradeUtc = null,
    DateTime? LastTradeUtc = null);

Stats is filled on tick-built bars and on Databento / CQG / Tradovate / crypto 1-minute profiled ladders (those replay an aggressor-flagged tape). Rithmic and dxFeed profiled ladders leave it null — they have per-price volume, not print order.

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 — SabrTrader.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 SabrTrader.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);
    // Also hear about updates the feed dropped before the next one it delivers.
    // Default forwards to the two-argument form: a synchronous fan-out never drops.
    IDisposable Subscribe(string instrumentId, Action<DepthUpdate> onUpdate, Action<long> onLoss);
    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);
    // Also hear about events the feed dropped before the next one it delivers: the
    // count arrives before that event. Default forwards to the two-argument form
    // (a synchronous fan-out never drops); the hosted feed's per-instrument drain
    // pump overrides it, and the recorder subscribes this way.
    IDisposable Subscribe(string instrumentId, Action<MboEvent> onEvent, Action<long> onLoss);
    event Action? SubscriptionReset;   // clear book on connection loss; default no-op
    // One instrument's book was reset, re-imaged (RebuildStarted / RebuildCompleted)
    // or changed authority. Args: instrumentId, transition. Default no-op.
    event Action<string, OrderBookLifecycleEvent>? BookLifecycleChanged;
}

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,        // platform delivery stamp: venues leave it 0
    DateTime ExchangeTimestampUtc,
    string InstrumentId,
    string OrderId,
    Side Side,
    MboAction Action,
    double Price,
    long Size,
    ulong QueuePriority,
    double PrevPrice,
    ulong VenueSequence);       // the venue's own wire counter, 0 when it has none

// Ten-argument constructor: VenueSequence = 0.
public 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).

OrderBookDepthMode

Which feed currently authors an IOrderBook (an enum : byte, read through IOrderBook.DepthMode). A venue that grants both streams starts per-order and falls back to aggregated when its market-by-order book cannot be recovered; the change is announced as OrderBookLifecycleEvent.DepthModeChanged.

OrderBookLifecycleEvent

A transition of the shared book that invalidates state a consumer derived from earlier depth or MBO callbacks (an enum : byte). Delivered through IIndicator.OnOrderBookLifecycle; each value names what has already happened to the book when the callback runs.

Recorded tapes — SabrTrader.Pipeline.Storage

The platform's recorder writes an instrument's L2 / MBO stream to disk together with the control markers a reader needs to rebuild the book honestly. Live indicator callbacks are sampled; the tape is the record. Recording is started from the platform's recording window, not from a plugin. Add using SabrTrader.Pipeline.Storage;.

IRecordedDepthCatalog

Read seam over the recorded tapes, reached from an indicator through IIndicatorContext.RecordedDepth (null when the host records none). Tapes are keyed by DepthStoreKey (venue provider key + instrument); a null cursor means the store has no coverage of the window. Reads never block a live feed.

IRecordedDepthCatalog.cspublic interface IRecordedDepthCatalog
{
    IMboCursor? OpenMbo(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);
    IDepthCursor? OpenDepth(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);
    IHeatmapSidecarCursor? OpenHeatmap(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);

    IReadOnlyList<DepthStoreKey> EnumerateMboKeys();     // every key with an MBO tape
    IReadOnlyList<DepthStoreKey> EnumerateDepthKeys();   // every key with an L2 tape
    DepthStoreKeyInfo? DescribeMbo(DepthStoreKey key);       // coverage, or null
    DepthStoreKeyInfo? DescribeDepth(DepthStoreKey key);
}

public readonly record struct DepthStoreKey(string ProviderKey, string InstrumentId);

public interface IMboCursor : IDisposable
{
    bool MoveNext();          // false when the window is exhausted
    MboTapeItem Current { get; }
}

public readonly record struct MboTapeItem(
    DepthTapeMarker Marker,
    DateTime ExchangeTimestampUtc,   // the marker time when Marker is not Event
    MboEvent Event);                 // default when Marker is not Event

DepthTapeMarker

Control records on a tape (an enum : byte). Events are the payload; the rest bracket reconnects, venue images and capture loss so a reader never invents fills.

Example — reading the book from an indicator

DepthImbalance.csusing SabrTrader.Pipeline.Indicators;
using SabrTrader.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);

Example — rebuilding order lifecycles from the tape

QueueAudit.csusing SabrTrader.Pipeline.MarketDepth;
using SabrTrader.Pipeline.Storage;

// Off the hot path (a toolbar action, a background task): replay one hour of an
// instrument's MBO tape into a private book and measure how long orders rested.
void Audit(IIndicatorContext ctx, DateTime fromUtc)
{
    IRecordedDepthCatalog? tapes = ctx.RecordedDepth;
    if (tapes is null) return;                        // this host records nothing

    var key = tapes.EnumerateMboKeys()
        .FirstOrDefault(k => k.InstrumentId == "MNQU6");
    if (key == default) return;                       // never recorded

    using IMboCursor? cursor = tapes.OpenMbo(key, fromUtc, fromUtc.AddHours(1));
    if (cursor is null) return;                       // no coverage of that window

    var book = new OrderBook(key.InstrumentId);
    bool complete = true;                             // false once a Gap sits inside the window
    while (cursor.MoveNext())
    {
        var item = cursor.Current;
        switch (item.Marker)
        {
            case DepthTapeMarker.Event:
                var evt = item.Event;
                book.ApplyMbo(in evt);                // OrderRemoved fires with the entry's resting time
                break;
            case DepthTapeMarker.Reset:
            case DepthTapeMarker.ReimageBegin:
                book.Clear();                         // everything before is superseded
                break;
            case DepthTapeMarker.Gap:
                complete = false;                     // lifecycles across this point are unknowable
                break;
        }
    }
    // complete == true: every order that appeared in the window has a certain fate.
}