nodejs-order-book 8.0.0

package/dist/esm/orderqueue.js

@@ -0,0 +1,72 @@
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+import Denque from "denque";
+var OrderQueue = /** @class */ (function () {
+    function OrderQueue(price) {
+        var _this = this;
+        this._ordersMap = {};
+        // returns the number of orders in queue
+        this.len = function () {
+            return _this._orders.length;
+        };
+        this.toArray = function () {
+            return _this._orders.toArray();
+        };
+        // returns price level of the queue
+        this.price = function () {
+            return _this._price;
+        };
+        // returns price level of the queue
+        this.volume = function () {
+            return _this._volume;
+        };
+        // returns top order in queue
+        this.head = function () {
+            return _this._orders.peekFront();
+        };
+        // returns bottom order in queue
+        this.tail = function () {
+            return _this._orders.peekBack();
+        };
+        // adds order to tail of the queue
+        this.append = function (order) {
+            _this._volume += order.size;
+            _this._orders.push(order);
+            _this._ordersMap[order.id] = _this._orders.length - 1;
+            return order;
+        };
+        // sets up new order to list value
+        this.update = function (oldOrder, newOrder) {
+            _this._volume -= oldOrder.size;
+            _this._volume += newOrder.size;
+            // Remove old order from head
+            _this._orders.shift();
+            delete _this._ordersMap[oldOrder.id];
+            // Add new order to head
+            _this._orders.unshift(newOrder);
+            _this._ordersMap[newOrder.id] = 0;
+        };
+        // removes order from the queue
+        this.remove = function (order) {
+            _this._volume -= order.size;
+            var deletedOrderIndex = _this._ordersMap[order.id];
+            _this._orders.removeOne(deletedOrderIndex);
+            delete _this._ordersMap[order.id];
+            // Update all orders indexes where index is greater than the deleted one
+            for (var orderId in _this._ordersMap) {
+                if (_this._ordersMap[orderId] > deletedOrderIndex) {
+                    _this._ordersMap[orderId] -= 1;
+                }
+            }
+        };
+        this.updateOrderSize = function (order, size) {
+            _this._volume += size - order.size; // update volume
+            order.size = size;
+            order.time = Date.now();
+        };
+        this._price = price;
+        this._volume = 0;
+        this._orders = new Denque();
+    }
+    return OrderQueue;
+}());
+export { OrderQueue };

package/dist/esm/orderside.js

@@ -0,0 +1,152 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+import createRBTree from "functional-red-black-tree";
+import { CustomError, ERROR } from "./errors";
+import { OrderFactory } from "./order";
+import { OrderQueue } from "./orderqueue";
+import { Side } from "./types";
+var OrderSide = /** @class */ (function () {
+    function OrderSide(side) {
+        var _this = this;
+        this._prices = {};
+        this._volume = 0;
+        this._total = 0;
+        this._numOrders = 0;
+        this._depthSide = 0;
+        this._side = Side.SELL;
+        // returns amount of orders
+        this.len = function () {
+            return _this._numOrders;
+        };
+        // returns depth of market
+        this.depth = function () {
+            return _this._depthSide;
+        };
+        // returns total amount of quantity in side
+        this.volume = function () {
+            return _this._volume;
+        };
+        // returns the total (size * price of each price level) in side
+        this.total = function () {
+            return _this._total;
+        };
+        // returns the price tree in side
+        this.priceTree = function () {
+            return _this._priceTree;
+        };
+        // appends order to definite price level
+        this.append = function (order) {
+            var price = order.price;
+            var strPrice = price.toString();
+            if (_this._prices[strPrice] === undefined) {
+                var priceQueue = new OrderQueue(price);
+                _this._prices[strPrice] = priceQueue;
+                _this._priceTree = _this._priceTree.insert(price, priceQueue);
+                _this._depthSide += 1;
+            }
+            _this._numOrders += 1;
+            _this._volume += order.size;
+            _this._total += order.size * order.price;
+            return _this._prices[strPrice].append(order);
+        };
+        // removes order from definite price level
+        this.remove = function (order) {
+            var price = order.price;
+            var strPrice = price.toString();
+            if (_this._prices[strPrice] === undefined) {
+                throw CustomError(ERROR.INVALID_PRICE_LEVEL);
+            }
+            _this._prices[strPrice].remove(order);
+            if (_this._prices[strPrice].len() === 0) {
+                delete _this._prices[strPrice];
+                _this._priceTree = _this._priceTree.remove(price);
+                _this._depthSide -= 1;
+            }
+            _this._numOrders -= 1;
+            _this._volume -= order.size;
+            _this._total -= order.size * order.price;
+            return order;
+        };
+        // Update the price of an order and return the order with the updated price
+        this.updateOrderPrice = function (oldOrder, orderUpdate) {
+            _this.remove(oldOrder);
+            var newOrder = OrderFactory.createOrder(__assign(__assign({}, oldOrder.toObject()), { size: orderUpdate.size !== undefined ? orderUpdate.size : oldOrder.size, price: orderUpdate.price, time: Date.now() }));
+            _this.append(newOrder);
+            return newOrder;
+        };
+        // Update the price of an order and return the order with the updated price
+        this.updateOrderSize = function (oldOrder, orderUpdate) {
+            var _a;
+            var newOrderPrice = (_a = orderUpdate.price) !== null && _a !== void 0 ? _a : oldOrder.price;
+            _this._volume += orderUpdate.size - oldOrder.size;
+            _this._total +=
+                orderUpdate.size * newOrderPrice - oldOrder.size * oldOrder.price;
+            _this._prices[oldOrder.price.toString()].updateOrderSize(oldOrder, orderUpdate.size);
+            return oldOrder;
+        };
+        // returns max level of price
+        this.maxPriceQueue = function () {
+            if (_this._depthSide > 0) {
+                var max = _this._side === Side.SELL ? _this._priceTree.end : _this._priceTree.begin;
+                return max.value;
+            }
+        };
+        // returns min level of price
+        this.minPriceQueue = function () {
+            if (_this._depthSide > 0) {
+                var min = _this._side === Side.SELL ? _this._priceTree.begin : _this._priceTree.end;
+                return min.value;
+            }
+        };
+        // returns nearest OrderQueue with price less than given
+        this.lowerThan = function (price) {
+            var node = _this._side === Side.SELL
+                ? _this._priceTree.lt(price)
+                : _this._priceTree.gt(price);
+            return node.value;
+        };
+        // returns nearest OrderQueue with price greater than given
+        this.greaterThan = function (price) {
+            var node = _this._side === Side.SELL
+                ? _this._priceTree.gt(price)
+                : _this._priceTree.lt(price);
+            return node.value;
+        };
+        // returns all orders
+        this.orders = function () {
+            var orders = [];
+            for (var price in _this._prices) {
+                var allOrders = _this._prices[price].toArray();
+                orders = orders.concat(allOrders);
+            }
+            return orders;
+        };
+        this.toString = function () {
+            var s = "";
+            var level = _this.maxPriceQueue();
+            while (level !== undefined) {
+                var volume = level.volume().toString();
+                s += "\n".concat(level.price(), " -> ").concat(volume);
+                level = _this.lowerThan(level.price());
+            }
+            return s;
+        };
+        var compare = side === Side.SELL
+            ? function (a, b) { return a - b; }
+            : function (a, b) { return b - a; };
+        this._priceTree = createRBTree(compare);
+        this._side = side;
+    }
+    return OrderSide;
+}());
+export { OrderSide };

package/dist/esm/stopbook.js

@@ -0,0 +1,62 @@
+import { StopSide } from "./stopside";
+import { OrderType, Side } from "./types";
+var StopBook = /** @class */ (function () {
+    function StopBook() {
+        var _this = this;
+        this.add = function (order) {
+            var stopSide = order.side === Side.BUY ? _this.bids : _this.asks;
+            stopSide.append(order);
+        };
+        this.remove = function (side, id, stopPrice) {
+            var stopSide = side === Side.BUY ? _this.bids : _this.asks;
+            return stopSide.remove(id, stopPrice);
+        };
+        this.removePriceLevel = function (side, priceLevel) {
+            var stopSide = side === Side.BUY ? _this.bids : _this.asks;
+            stopSide.removePriceLevel(priceLevel);
+        };
+        this.getConditionalOrders = function (side, priceBefore, marketPrice) {
+            var stopSide = side === Side.BUY ? _this.bids : _this.asks;
+            return stopSide.between(priceBefore, marketPrice);
+        };
+        /**
+         * Stop-Limit Order:
+         *    Buy: marketPrice < stopPrice <= price
+         *    Sell: marketPrice > stopPrice >= price
+         * Stop-Market Order:
+         *    Buy: marketPrice < stopPrice
+         *    Sell: marketPrice > stopPrice
+         */
+        this.validConditionalOrder = function (marketPrice, order) {
+            var response = false;
+            var type = order.type, side = order.side, stopPrice = order.stopPrice;
+            if (type === OrderType.STOP_LIMIT) {
+                // Buy: marketPrice < stopPrice <= price
+                if (side === Side.BUY &&
+                    marketPrice < stopPrice &&
+                    stopPrice <= order.price) {
+                    response = true;
+                }
+                // Sell: marketPrice > stopPrice >= price
+                if (side === Side.SELL &&
+                    marketPrice > stopPrice &&
+                    stopPrice >= order.price) {
+                    response = true;
+                }
+            }
+            else {
+                // Buy: marketPrice < stopPrice
+                if (side === Side.BUY && marketPrice < stopPrice)
+                    response = true;
+                // Sell: marketPrice > stopPrice
+                if (side === Side.SELL && marketPrice > stopPrice)
+                    response = true;
+            }
+            return response;
+        };
+        this.bids = new StopSide(Side.BUY);
+        this.asks = new StopSide(Side.SELL);
+    }
+    return StopBook;
+}());
+export { StopBook };

package/dist/esm/stopqueue.js

@@ -0,0 +1,53 @@
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+import Denque from "denque";
+var StopQueue = /** @class */ (function () {
+    function StopQueue(price) {
+        var _this = this;
+        this._ordersMap = {};
+        // returns the number of orders in queue
+        this.len = function () {
+            return _this._orders.length;
+        };
+        // remove order from head of queue
+        this.removeFromHead = function () {
+            // We can't use the shift method here because we need
+            // to update index in the map, so we use the remove(id) function
+            var order = _this._orders.peekFront();
+            if (order === undefined)
+                return;
+            return _this.remove(order.id);
+        };
+        // adds order to tail of the queue
+        this.append = function (order) {
+            _this._orders.push(order);
+            _this._ordersMap[order.id] = _this._orders.length - 1;
+            return order;
+        };
+        // removes order from the queue
+        this.remove = function (id) {
+            var deletedOrderIndex = _this._ordersMap[id];
+            if (deletedOrderIndex === undefined)
+                return;
+            var deletedOrder = _this._orders.removeOne(deletedOrderIndex);
+            delete _this._ordersMap[id];
+            // Update all orders indexes where index is greater than the deleted one
+            for (var orderId in _this._ordersMap) {
+                if (_this._ordersMap[orderId] > deletedOrderIndex) {
+                    _this._ordersMap[orderId] -= 1;
+                }
+            }
+            return deletedOrder;
+        };
+        this._price = price;
+        this._orders = new Denque();
+    }
+    Object.defineProperty(StopQueue.prototype, "price", {
+        get: function () {
+            return this._price;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return StopQueue;
+}());
+export { StopQueue };

package/dist/esm/stopside.js

@@ -0,0 +1,70 @@
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+import createRBTree from "functional-red-black-tree";
+import { CustomError, ERROR } from "./errors";
+import { StopQueue } from "./stopqueue";
+import { Side } from "./types";
+var StopSide = /** @class */ (function () {
+    function StopSide(side) {
+        var _this = this;
+        this._prices = {};
+        // appends order to definite price level
+        this.append = function (order) {
+            var price = order.stopPrice;
+            var strPrice = price.toString();
+            if (_this._prices[strPrice] === undefined) {
+                var priceQueue = new StopQueue(price);
+                _this._prices[strPrice] = priceQueue;
+                _this._priceTree = _this._priceTree.insert(price, priceQueue);
+            }
+            return _this._prices[strPrice].append(order);
+        };
+        // removes order from definite price level
+        this.remove = function (id, stopPrice) {
+            var strPrice = stopPrice.toString();
+            if (_this._prices[strPrice] === undefined) {
+                throw CustomError(ERROR.INVALID_PRICE_LEVEL);
+            }
+            var deletedOrder = _this._prices[strPrice].remove(id);
+            if (_this._prices[strPrice].len() === 0) {
+                delete _this._prices[strPrice];
+                _this._priceTree = _this._priceTree.remove(stopPrice);
+            }
+            return deletedOrder;
+        };
+        this.removePriceLevel = function (priceLevel) {
+            delete _this._prices[priceLevel.toString()];
+            _this._priceTree = _this._priceTree.remove(priceLevel);
+        };
+        // Get orders queue between two price levels
+        this.between = function (priceBefore, marketPrice) {
+            var queues = [];
+            var lowerBound = priceBefore;
+            var upperBound = marketPrice;
+            var highest = Math.max(priceBefore, marketPrice);
+            var lowest = Math.min(priceBefore, marketPrice);
+            if (_this._side === Side.BUY) {
+                lowerBound = highest;
+                upperBound = lowest - 1;
+            }
+            else {
+                lowerBound = lowest;
+                upperBound = highest + 1;
+            }
+            _this._priceTree.forEach(function (price, queue) {
+                if ((_this._side === Side.BUY && price >= lowest) ||
+                    (_this._side === Side.SELL && price <= highest)) {
+                    queues.push(queue);
+                }
+            }, lowerBound, // Inclusive
+            upperBound);
+            return queues;
+        };
+        var compare = side === Side.SELL
+            ? function (a, b) { return a - b; }
+            : function (a, b) { return b - a; };
+        this._priceTree = createRBTree(compare);
+        this._side = side;
+    }
+    return StopSide;
+}());
+export { StopSide };

package/dist/esm/types.js

@@ -0,0 +1,20 @@
+export var Side;
+(function (Side) {
+    Side["BUY"] = "buy";
+    Side["SELL"] = "sell";
+})(Side || (Side = {}));
+export var OrderType;
+(function (OrderType) {
+    OrderType["LIMIT"] = "limit";
+    OrderType["MARKET"] = "market";
+    OrderType["OCO"] = "oco";
+    OrderType["STOP_LIMIT"] = "stop_limit";
+    OrderType["STOP_MARKET"] = "stop_market";
+})(OrderType || (OrderType = {}));
+export var TimeInForce;
+(function (TimeInForce) {
+    TimeInForce["GTC"] = "GTC";
+    TimeInForce["IOC"] = "IOC";
+    TimeInForce["FOK"] = "FOK";
+})(TimeInForce || (TimeInForce = {}));
+/* node:coverage enable */

package/dist/types/errors.d.ts

@@ -0,0 +1,26 @@
+import type { IError } from "./types";
+export declare enum ERROR {
+    DEFAULT = "DEFAULT",
+    INSUFFICIENT_QUANTITY = "INSUFFICIENT_QUANTITY",
+    INVALID_CONDITIONAL_ORDER = "INVALID_CONDITIONAL_ORDER",
+    INVALID_JOURNAL_LOG = "INVALID_JOURNAL_LOG",
+    INVALID_ORDER_TYPE = "INVALID_ORDER_TYPE",
+    INVALID_PRICE = "INVALID_PRICE",
+    INVALID_PRICE_LEVEL = "INVALID_PRICE_LEVEL",
+    INVALID_PRICE_OR_QUANTITY = "INVALID_PRICE_OR_QUANTITY",
+    INVALID_QUANTITY = "INVALID_QUANTITY",
+    INVALID_SIDE = "INVALID_SIDE",
+    INVALID_TIF = "INVALID_TIF",
+    LIMIT_ORDER_FOK_NOT_FILLABLE = "LIMIT_ORDER_FOK_NOT_FILLABLE",
+    LIMIT_ORDER_POST_ONLY = "LIMIT_ORDER_POST_ONLY",
+    ORDER_ALREDY_EXISTS = "ORDER_ALREDY_EXISTS",
+    ORDER_NOT_FOUND = "ORDER_NOT_FOUND"
+}
+export declare const ErrorCodes: Record<ERROR, number>;
+export declare const ErrorMessages: Record<ERROR, string>;
+export declare class OrderBookError implements IError {
+    message: string;
+    code: number;
+    constructor(error?: ERROR | string);
+}
+export declare const CustomError: (error?: ERROR | string) => OrderBookError;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import { OrderBook } from "./orderbook";
+import { OrderType, Side } from "./types";
+import type { CreateOrderOptions, ICancelOrder, IProcessOrder, LimitOrderOptions, MarketOrderOptions, OCOOrderOptions, OrderBookOptions, OrderUpdatePrice, OrderUpdateSize, StopLimitOrderOptions, StopMarketOrderOptions } from "./types";
+export { type CreateOrderOptions, type ICancelOrder, type IProcessOrder, type LimitOrderOptions, type MarketOrderOptions, type OCOOrderOptions, OrderBook, type OrderBookOptions, OrderType, type OrderUpdatePrice, type OrderUpdateSize, Side, type StopLimitOrderOptions, type StopMarketOrderOptions, };

package/dist/types/order.d.ts

@@ -0,0 +1,71 @@
+import { type ILimitOrder, type IStopLimitOrder, type IStopMarketOrder, type InternalLimitOrderOptions, type InternalStopLimitOrderOptions, type InternalStopMarketOrderOptions, type OrderOptions, OrderType, type Side, type TimeInForce } from "./types";
+declare abstract class BaseOrder {
+    readonly _id: string;
+    readonly _side: Side;
+    _size: number;
+    _time: number;
+    constructor(options: OrderOptions);
+    get id(): string;
+    get side(): Side;
+    get size(): number;
+    set size(size: number);
+    get time(): number;
+    set time(time: number);
+    abstract toString(): void;
+    abstract toJSON(): void;
+    abstract toObject(): void;
+}
+export declare class LimitOrder extends BaseOrder {
+    private readonly _type;
+    readonly _origSize: number;
+    private _price;
+    private readonly _timeInForce;
+    private readonly _makerQty;
+    private readonly _takerQty;
+    private readonly _postOnly;
+    private readonly _ocoStopPrice?;
+    constructor(options: InternalLimitOrderOptions);
+    get type(): OrderType.LIMIT;
+    get price(): number;
+    set price(price: number);
+    get timeInForce(): TimeInForce;
+    get postOnly(): boolean;
+    get origSize(): number;
+    get makerQty(): number;
+    get takerQty(): number;
+    get ocoStopPrice(): number | undefined;
+    toString: () => string;
+    toJSON: () => string;
+    toObject: () => ILimitOrder;
+}
+export declare class StopMarketOrder extends BaseOrder {
+    private readonly _type;
+    private readonly _stopPrice;
+    constructor(options: InternalStopMarketOrderOptions);
+    get type(): OrderType.STOP_MARKET;
+    get stopPrice(): number;
+    toString: () => string;
+    toJSON: () => string;
+    toObject: () => IStopMarketOrder;
+}
+export declare class StopLimitOrder extends BaseOrder {
+    private readonly _type;
+    private _price;
+    private readonly _stopPrice;
+    private readonly _timeInForce;
+    private readonly _isOCO;
+    constructor(options: InternalStopLimitOrderOptions);
+    get type(): OrderType.STOP_LIMIT;
+    get price(): number;
+    set price(price: number);
+    get stopPrice(): number;
+    get timeInForce(): TimeInForce;
+    get isOCO(): boolean;
+    toString: () => string;
+    toJSON: () => string;
+    toObject: () => IStopLimitOrder;
+}
+export declare const OrderFactory: {
+    createOrder<T extends OrderOptions>(options: T): T extends InternalLimitOrderOptions ? LimitOrder : T extends InternalStopLimitOrderOptions ? StopLimitOrder : T extends InternalStopMarketOrderOptions ? StopMarketOrder : never;
+};
+export {};