orderbooks/lib/OrderBook.d.ts

In-memory state stores and handlers for caching multiple exchange:symbol orderbook states

import { OrderBookLevelState } from './OrderBookLevel';
export interface OrderBookOptions {
    checkTimestamps?: boolean;
    maxDepth?: number;
    /** Whether to console.log when a snapshot or delta is processed */
    traceLog?: boolean;
}
/**
 * Storage helper to store/track/manipulate the current state of an symbol's orderbook
 * @class OrderBook
 */
export declare class OrderBook<ExtraStateType = unknown> {
    symbol: string;
    book: OrderBookLevelState<ExtraStateType>[];
    shouldCheckTimestamps: boolean;
    lastUpdateTimestamp: number;
    maxDepth: number;
    constructor(symbol: string, options?: OrderBookOptions);
    /**
     * Returns a cloned copy of the current orderbook state
     */
    getBookState(): OrderBookLevelState<ExtraStateType>[];
    /**
     * @public Process orderbook snapshot, replacing existing book in memory
     * @param {OrderBookLevelState[]} data current orderbook snapshot represented as array, where each child element is a level in the orderbook
     * @param {number} timestamp
     */
    handleSnapshot(data: OrderBookLevelState<ExtraStateType>[], timestamp?: number): this;
    /**
     * @public Process orderbook delta change, either deleting, updating or inserting level data into the existing book. Price is used on each level to find existing index in tracked book state.
     *
     * @param {Array} [deleteDelta=[]] levels to delete
     * @param {Array} [upsertDelta=[]] levels to update (will automatically insert if level does not exist)
     * @param {Array} [insertDelta=[]] levels to insert
     * @param {number} timestamp
     */
    handleDelta(deleteDelta?: OrderBookLevelState[], upsertDelta?: OrderBookLevelState[], insertDelta?: OrderBookLevelState[], timestamp?: number): this;
    /**
     * @private replace item at index, mutating existing book store
     */
    private replaceLevelAtIndex;
    /**
     * @private insert item, mutating existing book store
     */
    private insertLevel;
    /**
     * @private find index of level in book, using "price" property as primary key
     * @param {object} level
     * @returns {number} index of level in book, if found, else -1
     */
    private findIndexForSlice;
    /**
     * @public throw error if current timestamp is older than last updated timestamp
     * @param {number} timestamp
     */
    checkTimestamp(timestamp: number): false | undefined;
    /** Sort orderbook in memory, lowest price last, highest price first */
    private sort;
    /** trim orderbook in place to max depth, evenly across both sides */
    private trimToMaxDepth;
    /**
     * Trim edges of orderbook to total target
     *
     * @param {number} [totalToTrim=0]
     * @param {boolean} shouldTrimTop - if true, trim from array beginning (top = sells) else from array end (bottom = buys)
     */
    private trimSideCount;
    /** Track last updated timestamp */
    private trackDidUpdate;
    /** dump orderbook state to console */
    print(): this;
    /** empty current orderbook store to free memory */
    reset(): this;
    /**
     * get lowest sell order
     * @param {number} [offset=0] offset from array centre (should be positive)
     * @returns {number} lowest seller price
     */
    getBestAsk(offset?: number): number | null;
    /**
     * get highest buy order price
     * @param {number} [offset=0] offset from array centre (should be positive)
     * @returns {number} highest buyer price
     */
    getBestBid(offset?: number): number | null;
    /**
     * get current bid/ask spread percentage
     * @param {number} [n=0] offset from centre of book
     * @returns {number} percentage spread between best bid & ask
     */
    getSpreadPercent(n?: number): number | null;
    /**
     * get current bid/ask spread in basis points
     * @param {number} [n=0] offset from centre of book
     * @returns {number} spread between best bid & ask in basis points
     */
    getSpreadBasisPoints(n?: number): number | null;
    /**
     * Calculate expected slippage for a market order of a given size
     * @param {number} baseOrderSize - The size of the order in base units
     * @param {string} side - 'Buy' or 'Sell' side of the order
     * @returns {{ executionPrice: number, slippagePercent: number, slippageBasisPoints: number } | null} - The expected execution price and slippage
     */
    getEstimatedSlippage(baseOrderSize: number, side: 'Buy' | 'Sell'): {
        executionPrice: number;
        slippagePercent: number;
        slippageBasisPoints: number;
    } | null;
}