nodejs-order-book 8.0.0

package/dist/types/orderbook.d.ts

@@ -0,0 +1,218 @@
+import { type OrderBookError } from "./errors";
+import { type LimitOrder } from "./order";
+import { type CreateOrderOptions, type ICancelOrder, type IProcessOrder, type LimitOrderOptions, type MarketOrderOptions, type OCOOrderOptions, type OrderBookOptions, OrderType, type OrderUpdatePrice, type OrderUpdateSize, Side, type Snapshot, type StopLimitOrderOptions, type StopMarketOrderOptions, TimeInForce } from "./types";
+export declare class OrderBook {
+    private orders;
+    private _lastOp;
+    private _marketPrice;
+    private readonly bids;
+    private readonly asks;
+    private readonly enableJournaling;
+    private readonly stopBook;
+    private readonly experimentalConditionalOrders;
+    /**
+     * Creates an instance of OrderBook.
+     * @param {OrderBookOptions} [options={}] - Options for configuring the order book.
+     * @param {JournalLog} [options.snapshot] - The orderbook snapshot will be restored before processing any journal logs, if any.
+     * @param {JournalLog} [options.journal] - Array of journal logs (optional).
+     * @param {boolean} [options.enableJournaling=false] - Flag to enable journaling. Default to false
+     * @param {boolean} [options.experimentalConditionalOrders=false] - Flag to enable experimental Conditional Order (Stop Market, Stop Limit and OCO orders). Default to false
+     */
+    constructor({ snapshot, journal, enableJournaling, experimentalConditionalOrders, }?: OrderBookOptions);
+    get marketPrice(): number;
+    get lastOp(): number;
+    /**
+     * Create new order. See {@link CreateOrderOptions} for details.
+     *
+     * @param options
+     * @param options.type - `limit` | `market` | 'stop_limit' | 'stop_market' | 'oco'
+     * @param options.side - `sell` or `buy`
+     * @param options.size - How much of currency you want to trade in units of base currency
+     * @param options.price - The price at which the order is to be fullfilled, in units of the quote currency. Param only for limit order
+     * @param options.orderID - Unique order ID. Param only for limit order
+     * @param options.postOnly - Can be used with 'limit' order and when it's `true` the order will be rejected if immediately matches and trades as a taker. Default is `false`
+     * @param options.stopPrice - The price at which the order will be triggered. Used with `stop_limit` and `stop_market` order.
+     * @param options.stopLimitPrice - The price at which the order will be triggered. Used with `stop_limit` and `stop_market` order.
+     * @param options.timeInForce - Time-in-force supported are: `GTC` (default), `FOK`, `IOC`. Param only for limit order
+     * @param options.stopLimitTimeInForce - Time-in-force supported are: `GTC` (default), `FOK`, `IOC`. Param only for limit order
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    createOrder(options: CreateOrderOptions): IProcessOrder;
+    /**
+     * @deprecated This implementation has been deprecated and will be removed on v7.0.0.
+     * Use createOrder({ type, side, size, price, id, timeInForce }) instead.
+     *
+     * Create a trade order
+     *
+     * @param type - `limit` | `market` | 'stop_limit' | 'stop_market' | 'oco'
+     * @param side - `sell` or `buy`
+     * @param size - How much of currency you want to trade in units of base currency
+     * @param price - The price at which the order is to be fullfilled, in units of the quote currency. Param only for limit order
+     * @param orderID - Unique order ID. Param only for limit order
+     * @param timeInForce - Time-in-force supported are: `GTC` (default), `FOK`, `IOC`. Param only for limit order
+     * @param stopPrice - The price at which the order will be triggered. Used with `stop_limit` and `stop_market` order.
+     * @param stopLimitPrice - The price at which the order will be triggered. Used with `stop_limit` and `stop_market` order.
+     * @param stopLimitTimeInForce - Time-in-force supported are: `GTC` (default), `FOK`, `IOC`. Param only for limit order
+     * @param postOnly - Can be used with 'limit' order and when it's `true` the order will be rejected if immediately matches and trades as a taker. Default is `false`
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    createOrder(type: OrderType, side: Side, size: number, price?: number, orderID?: string, timeInForce?: TimeInForce, stopPrice?: number, stopLimitPrice?: number, stopLimitTimeInForce?: TimeInForce, postOnly?: boolean): IProcessOrder;
+    /**
+     * Create a market order. See {@link MarketOrderOptions} for details.
+     *
+     * @param options
+     * @param options.side - `sell` or `buy`
+     * @param options.size - How much of currency you want to trade in units of base currency
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    market(options: MarketOrderOptions): IProcessOrder;
+    /**
+     * @deprecated This implementation has been deprecated and will be removed on v7.0.0.
+     * Use market({ side, size }) instead.
+     *
+     * Create a market order
+     *
+     * @param side - `sell` or `buy`
+     * @param size - How much of currency you want to trade in units of base currency
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    market(side: Side, size: number): IProcessOrder;
+    /**
+     * Create a stop market order. See {@link StopMarketOrderOptions} for details.
+     *
+     * @param options
+     * @param options.side - `sell` or `buy`
+     * @param options.size - How much of currency you want to trade in units of base currency
+     * @param options.stopPrice - The price at which the order will be triggered.
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    stopMarket: (options: StopMarketOrderOptions) => IProcessOrder;
+    /**
+     * Create a limit order. See {@link LimitOrderOptions} for details.
+     *
+     * @param options
+     * @param options.side - `sell` or `buy`
+     * @param options.id - Unique order ID
+     * @param options.size - How much of currency you want to trade in units of base currency
+     * @param options.price - The price at which the order is to be fullfilled, in units of the quote currency
+     * @param options.postOnly - When `true` the order will be rejected if immediately matches and trades as a taker. Default is `false`
+     * @param options.timeInForce - Time-in-force type supported are: GTC, FOK, IOC. Default is GTC
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    limit(options: LimitOrderOptions): IProcessOrder;
+    /**
+     * @deprecated This implementation has been deprecated and will be removed on v7.0.0.
+     * Use limit({ id, side, size, price, timeInForce }) instead.
+     *
+     * Create a limit order
+     *
+     * @param side - `sell` or `buy`
+     * @param orderID - Unique order ID
+     * @param size - How much of currency you want to trade in units of base currency
+     * @param price - The price at which the order is to be fullfilled, in units of the quote currency
+     * @param timeInForce - Time-in-force type supported are: GTC, FOK, IOC. Default is GTC
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    limit(side: Side, orderID: string, size: number, price: number, timeInForce?: TimeInForce): IProcessOrder;
+    /**
+     * Create a stop limit order. See {@link StopLimitOrderOptions} for details.
+     *
+     * @param options
+     * @param options.side - `sell` or `buy`
+     * @param options.id - Unique order ID
+     * @param options.size - How much of currency you want to trade in units of base currency
+     * @param options.price - The price at which the order is to be fullfilled, in units of the quote currency
+     * @param options.stopPrice - The price at which the order will be triggered.
+     * @param options.timeInForce - Time-in-force type supported are: GTC, FOK, IOC. Default is GTC
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    stopLimit: (options: StopLimitOrderOptions) => IProcessOrder;
+    /**
+     * Create an OCO (One-Cancels-the-Other) order.
+     * OCO order combines a `stop_limit` order and a `limit` order, where if stop price
+     * is triggered or limit order is fully or partially fulfilled, the other is canceled.
+     * Both orders have the same `side` and `size`. If you cancel one of the orders, the
+     * entire OCO order pair will be canceled.
+     *
+     * For BUY orders the `stopPrice` must be above the current price and the `price` below the current price
+     * For SELL orders the `stopPrice` must be below the current price and the `price` above the current price
+     *
+     * See {@link OCOOrderOptions} for details.
+     *
+     * @param options
+     * @param options.side - `sell` or `buy`
+     * @param options.id - Unique order ID
+     * @param options.size - How much of currency you want to trade in units of base currency
+     * @param options.price - The price of the `limit` order at which the order is to be fullfilled, in units of the quote currency
+     * @param options.stopPrice - The price at which the `stop_limit` order will be triggered.
+     * @param options.stopLimitPrice - The price of the `stop_limit` order at which the order is to be fullfilled, in units of the quote currency.
+     * @param options.timeInForce - Time-in-force of the `limit` order. Type supported are: GTC, FOK, IOC. Default is GTC
+     * @param options.stopLimitTimeInForce - Time-in-force of the `stop_limit` order. Type supported are: GTC, FOK, IOC. Default is GTC
+     * @returns An object with the result of the processed order or an error. See {@link IProcessOrder} for the returned data structure
+     */
+    oco: (options: OCOOrderOptions) => IProcessOrder;
+    /**
+     * Modify an existing order with given ID. When an order is modified by price or quantity,
+     * it will be deemed as a new entry. Under the price-time-priority algorithm, orders are
+     * prioritized according to their order price and order time. Hence, the latest orders
+     * will be placed at the back of the matching order queue.
+     *
+     * @param orderID - The ID of the order to be modified
+     * @param orderUpdate - An object with the modified size and/or price of an order. The shape of the object is `{size, price}`.
+     * @returns An object with the result of the processed order or an error
+     */
+    modify: (orderID: string, orderUpdate: OrderUpdatePrice | OrderUpdateSize) => IProcessOrder;
+    /**
+     * Remove an existing order with given ID from the order book
+     *
+     * @param orderID - The ID of the order to be removed
+     * @returns The removed order if exists or `undefined`
+     */
+    cancel: (orderID: string) => ICancelOrder | undefined;
+    /**
+     * Get an existing order with the given ID
+     *
+     * @param orderID - The ID of the order to be returned
+     * @returns The order if exists or `undefined`
+     */
+    order: (orderID: string) => LimitOrder | undefined;
+    depth: () => [Array<[number, number]>, Array<[number, number]>];
+    toString: () => string;
+    calculateMarketPrice: (side: Side, size: number) => {
+        price: number;
+        err: null | OrderBookError;
+    };
+    snapshot: () => Snapshot;
+    private readonly _market;
+    private readonly _limit;
+    private readonly _stopMarket;
+    private readonly _stopLimit;
+    private readonly _oco;
+    private readonly _stopOrder;
+    private readonly restoreSnapshot;
+    /**
+     * Remove an existing order with given ID from the order book
+     * @param orderID The id of the order to be deleted
+     * @param internalDeletion Set to true when the delete comes from internal operations
+     * @returns The removed order if exists or `undefined`
+     */
+    private readonly _cancelOrder;
+    private readonly getProcessOrderResponse;
+    private readonly createLimitOrder;
+    private readonly executeConditionalOrder;
+    private readonly replayJournal;
+    /**
+     * OCO Order:
+     *    Buy: price < marketPrice < stopPrice
+     *    Sell: price > marketPrice > stopPrice
+     */
+    private readonly validateOCOOrder;
+    private readonly greaterThanOrEqual;
+    private readonly lowerThanOrEqual;
+    private readonly processQueue;
+    private readonly canFillOrder;
+    private readonly buyOrderCanBeFilled;
+    private readonly sellOrderCanBeFilled;
+    private readonly validateMarketOrder;
+    private readonly validateLimitOrder;
+}

package/dist/types/orderqueue.d.ts

@@ -0,0 +1,18 @@
+import type { LimitOrder } from "./order";
+export declare class OrderQueue {
+    private readonly _price;
+    private _volume;
+    private readonly _orders;
+    private _ordersMap;
+    constructor(price: number);
+    len: () => number;
+    toArray: () => LimitOrder[];
+    price: () => number;
+    volume: () => number;
+    head: () => LimitOrder | undefined;
+    tail: () => LimitOrder | undefined;
+    append: (order: LimitOrder) => LimitOrder;
+    update: (oldOrder: LimitOrder, newOrder: LimitOrder) => void;
+    remove: (order: LimitOrder) => void;
+    updateOrderSize: (order: LimitOrder, size: number) => void;
+}

package/dist/types/orderside.d.ts

@@ -0,0 +1,29 @@
+import createRBTree from "functional-red-black-tree";
+import { type LimitOrder } from "./order";
+import { OrderQueue } from "./orderqueue";
+import { type OrderUpdatePrice, type OrderUpdateSize, Side } from "./types";
+export declare class OrderSide {
+    private _priceTree;
+    private _prices;
+    private _volume;
+    private _total;
+    private _numOrders;
+    private _depthSide;
+    private readonly _side;
+    constructor(side: Side);
+    len: () => number;
+    depth: () => number;
+    volume: () => number;
+    total: () => number;
+    priceTree: () => createRBTree.Tree<number, OrderQueue>;
+    append: (order: LimitOrder) => LimitOrder;
+    remove: (order: LimitOrder) => LimitOrder;
+    updateOrderPrice: (oldOrder: LimitOrder, orderUpdate: OrderUpdatePrice) => LimitOrder;
+    updateOrderSize: (oldOrder: LimitOrder, orderUpdate: OrderUpdateSize) => LimitOrder;
+    maxPriceQueue: () => OrderQueue | undefined;
+    minPriceQueue: () => OrderQueue | undefined;
+    lowerThan: (price: number) => OrderQueue | undefined;
+    greaterThan: (price: number) => OrderQueue | undefined;
+    orders: () => LimitOrder[];
+    toString: () => string;
+}

package/dist/types/stopbook.d.ts

@@ -0,0 +1,20 @@
+import type { StopQueue } from "./stopqueue";
+import { Side, type StopOrder } from "./types";
+export declare class StopBook {
+    private readonly bids;
+    private readonly asks;
+    constructor();
+    add: (order: StopOrder) => void;
+    remove: (side: Side, id: string, stopPrice: number) => StopOrder | undefined;
+    removePriceLevel: (side: Side, priceLevel: number) => void;
+    getConditionalOrders: (side: Side, priceBefore: number, marketPrice: number) => StopQueue[];
+    /**
+     * Stop-Limit Order:
+     *    Buy: marketPrice < stopPrice <= price
+     *    Sell: marketPrice > stopPrice >= price
+     * Stop-Market Order:
+     *    Buy: marketPrice < stopPrice
+     *    Sell: marketPrice > stopPrice
+     */
+    validConditionalOrder: (marketPrice: number, order: StopOrder) => boolean;
+}

package/dist/types/stopqueue.d.ts

@@ -0,0 +1,12 @@
+import type { StopOrder } from "./types";
+export declare class StopQueue {
+    private readonly _price;
+    private readonly _orders;
+    private _ordersMap;
+    constructor(price: number);
+    get price(): number;
+    len: () => number;
+    removeFromHead: () => StopOrder | undefined;
+    append: (order: StopOrder) => StopOrder;
+    remove: (id: string) => StopOrder | undefined;
+}

package/dist/types/stopside.d.ts

@@ -0,0 +1,12 @@
+import { StopQueue } from "./stopqueue";
+import { Side, type StopOrder } from "./types";
+export declare class StopSide {
+    private _priceTree;
+    private _prices;
+    private readonly _side;
+    constructor(side: Side);
+    append: (order: StopOrder) => StopOrder;
+    remove: (id: string, stopPrice: number) => StopOrder | undefined;
+    removePriceLevel: (priceLevel: number) => void;
+    between: (priceBefore: number, marketPrice: number) => StopQueue[];
+}

package/dist/types/types.d.ts

@@ -0,0 +1,324 @@
+import type { OrderBookError } from "./errors";
+import type { LimitOrder, StopLimitOrder, StopMarketOrder } from "./order";
+export declare enum Side {
+    BUY = "buy",
+    SELL = "sell"
+}
+export declare enum OrderType {
+    LIMIT = "limit",
+    MARKET = "market",
+    OCO = "oco",
+    STOP_LIMIT = "stop_limit",
+    STOP_MARKET = "stop_market"
+}
+export declare enum TimeInForce {
+    GTC = "GTC",
+    IOC = "IOC",
+    FOK = "FOK"
+}
+export interface IError {
+    code: number;
+    message: string;
+}
+export type StopOrder = StopLimitOrder | StopMarketOrder;
+export type Order = LimitOrder | StopOrder;
+interface BaseOrderOptions {
+    id?: string;
+    side: Side;
+    size: number;
+}
+interface InternalBaseOrderOptions extends BaseOrderOptions {
+    type: OrderType;
+    time?: number;
+}
+/**
+ * Specific options for a market order.
+ */
+export interface MarketOrderOptions extends BaseOrderOptions {
+}
+interface IMarketOrderOptions extends InternalBaseOrderOptions {
+}
+export interface InternalMarketOrderOptions extends IMarketOrderOptions {
+    type: OrderType.MARKET;
+}
+/**
+ * Specific options for a limit order.
+ */
+export interface LimitOrderOptions extends MarketOrderOptions {
+    id: string;
+    price: number;
+    timeInForce?: TimeInForce;
+    postOnly?: boolean;
+}
+interface ILimitOrderOptions extends InternalBaseOrderOptions {
+    id: string;
+    price: number;
+    timeInForce: TimeInForce;
+}
+export interface InternalLimitOrderOptions extends ILimitOrderOptions {
+    type: OrderType.LIMIT;
+    origSize: number;
+    makerQty: number;
+    takerQty: number;
+    postOnly?: boolean;
+    ocoStopPrice?: number;
+}
+/**
+ * Specific options for a stop market order.
+ */
+export interface StopMarketOrderOptions extends MarketOrderOptions {
+    stopPrice: number;
+}
+export interface InternalStopMarketOrderOptions extends IMarketOrderOptions {
+    type: OrderType.STOP_MARKET;
+    stopPrice: number;
+}
+/**
+ * Specific options for a stop limit order.
+ */
+export interface StopLimitOrderOptions extends LimitOrderOptions {
+    stopPrice: number;
+}
+export interface InternalStopLimitOrderOptions extends ILimitOrderOptions {
+    type: OrderType.STOP_LIMIT;
+    stopPrice: number;
+    isOCO?: boolean;
+}
+/**
+ * Specific options for oco order.
+ */
+export interface OCOOrderOptions extends StopLimitOrderOptions {
+    stopPrice: number;
+    stopLimitPrice: number;
+    stopLimitTimeInForce?: TimeInForce;
+}
+/**
+ * Object object representation of a market order returned by the toObject() method.
+ */
+export interface IMarketOrder {
+    id: string;
+    type: OrderType;
+    side: Side;
+    size: number;
+    origSize: number;
+    time: number;
+}
+/**
+ * Object object representation of a limit order returned by the toObject() method.
+ */
+export interface ILimitOrder {
+    id: string;
+    type: OrderType.LIMIT;
+    side: Side;
+    size: number;
+    origSize: number;
+    price: number;
+    time: number;
+    timeInForce: TimeInForce;
+    takerQty: number;
+    makerQty: number;
+}
+/**
+ * Object object representation of a stop market order returned by the toObject() method.
+ */
+export interface IStopMarketOrder {
+    id: string;
+    type: OrderType;
+    side: Side;
+    size: number;
+    stopPrice: number;
+    time: number;
+}
+/**
+ * Object object representation of a stop limit order returned by the toObject() method.
+ */
+export interface IStopLimitOrder {
+    id: string;
+    type: OrderType;
+    side: Side;
+    size: number;
+    price: number;
+    stopPrice: number;
+    timeInForce: TimeInForce;
+    time: number;
+}
+/**
+ * Represents an order in the order book.
+ */
+export type OrderOptions = InternalMarketOrderOptions | InternalLimitOrderOptions | InternalStopLimitOrderOptions | InternalStopMarketOrderOptions;
+export type StopOrderOptions = StopMarketOrderOptions | StopLimitOrderOptions | OCOOrderOptions;
+/**
+ * Represents the result of processing an order.
+ */
+export interface IProcessOrder {
+    /** Array of fully processed orders. */
+    done: Order[];
+    /** Array of activated (stop limit or stop market) orders */
+    activated: StopOrder[];
+    /** The partially processed order, if any. */
+    partial: LimitOrder | null;
+    /** The quantity that has been processed in the partial order. */
+    partialQuantityProcessed: number;
+    /** The remaining quantity that needs to be processed. */
+    quantityLeft: number;
+    /** The error encountered during order processing, if any. */
+    err: OrderBookError | null;
+    /** Optional journal log entry related to the order processing. */
+    log?: JournalLog;
+}
+export interface ConditionOrderOptions {
+    stopPrice: number;
+}
+/**
+ * Specific options for modifying an order.
+ */
+export interface ModifyOrderOptions {
+    /** Unique identifier of the order. */
+    orderID: string;
+    /** Details of the order update (price or size). */
+    orderUpdate: OrderUpdatePrice | OrderUpdateSize;
+}
+/**
+ * Specific options for canceling an order.
+ */
+export interface CancelOrderOptions {
+    /** Unique identifier of the order. */
+    orderID: string;
+}
+/**
+ * Represents a cancel order operation.
+ */
+export interface ICancelOrder {
+    order: LimitOrder;
+    stopOrder?: StopOrder;
+    /** Optional log related to the order cancellation. */
+    log?: CancelOrderJournalLog;
+}
+/**
+ * Represents a log entry for a market order operation.
+ */
+export interface MarketOrderJournalLog {
+    /** Incremental ID of the operation */
+    opId: number;
+    /** Timestamp of the operation. */
+    ts: number;
+    /** Operation type: 'm' for market order. */
+    op: "m";
+    /** Specific options for the market order. */
+    o: MarketOrderOptions;
+}
+/**
+ * Represents a log entry for a limit order operation.
+ */
+export interface LimitOrderJournalLog {
+    /** Incremental ID of the operation */
+    opId: number;
+    /** Timestamp of the operation. */
+    ts: number;
+    /** Operation type: 'l' for limit order. */
+    op: "l";
+    /** Specific options for the limit order. */
+    o: LimitOrderOptions;
+}
+/**
+ * Represents a log entry for an order modification operation.
+ */
+export interface ModifyOrderJournalLog {
+    /** Incremental ID of the operation */
+    opId: number;
+    /** Timestamp of the operation. */
+    ts: number;
+    /** Operation type: 'u' for update order. */
+    op: "u";
+    /** Specific options for modifying the order. */
+    o: ModifyOrderOptions;
+}
+/**
+ * Represents a log entry for an order cancellation operation.
+ */
+export interface CancelOrderJournalLog {
+    /** Incremental ID of the operation */
+    opId: number;
+    /** Timestamp of the operation. */
+    ts: number;
+    /** Operation type: 'd' for delete order. */
+    op: "d";
+    /** Specific options for canceling the order. */
+    o: CancelOrderOptions;
+}
+/**
+ * Discriminated union of all journaling log types.
+ */
+export type JournalLog = MarketOrderJournalLog | LimitOrderJournalLog | ModifyOrderJournalLog | CancelOrderJournalLog;
+export type CreateOrderOptions = ({
+    type: OrderType.MARKET;
+} & MarketOrderOptions) | ({
+    type: OrderType.LIMIT;
+} & LimitOrderOptions) | ({
+    type: OrderType.STOP_MARKET;
+} & StopMarketOrderOptions) | ({
+    type: OrderType.STOP_LIMIT;
+} & StopLimitOrderOptions) | ({
+    type: OrderType.OCO;
+} & OCOOrderOptions);
+/**
+ * Options for configuring the order book.
+ */
+export interface OrderBookOptions {
+    /**
+     * Orderbook snapshot to restore from. The restoration
+     * will be executed before processing any journal logs, if any.
+     */
+    snapshot?: Snapshot;
+    /** Flag to enable journaling. */
+    enableJournaling?: boolean;
+    /** Array of journal logs. */
+    journal?: JournalLog[];
+    /**
+     * Flag to enable experimental Conditional Order (Stop Market, Stop Limit and OCO orders).
+     * Default to false
+     */
+    experimentalConditionalOrders?: boolean;
+}
+/**
+ * Represents an update to the price of an order.
+ */
+export interface OrderUpdatePrice {
+    /** New price of the order. */
+    price: number;
+    /** New size of the order (optional). */
+    size?: number;
+}
+/**
+ * Represents an update to the size of an order.
+ */
+export interface OrderUpdateSize {
+    /** New price of the order (optional). */
+    price?: number;
+    /** New size of the order. */
+    size: number;
+}
+/**
+ * Interface to represent a snapshot of the order book
+ */
+export interface Snapshot {
+    /** List of ask orders, each with a price and a list of associated orders */
+    asks: Array<{
+        /** Price of the ask order */
+        price: number;
+        /** List of orders associated with this price */
+        orders: LimitOrder[];
+    }>;
+    /** List of bid orders, each with a price and a list of associated orders */
+    bids: Array<{
+        /** Price of the bid order */
+        price: number;
+        /** List of orders associated with this price */
+        orders: LimitOrder[];
+    }>;
+    /** Unix timestamp representing when the snapshot was taken */
+    ts: number;
+    /** The id of the last operation inserted in the orderbook */
+    lastOp: number;
+}
+export {};