nodejs-order-book 8.0.0

package/dist/cjs/orderqueue.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderQueue = void 0;
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+var denque_1 = __importDefault(require("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_1.default();
+    }
+    return OrderQueue;
+}());
+exports.OrderQueue = OrderQueue;

package/dist/cjs/orderside.js

@@ -0,0 +1,158 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSide = void 0;
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+var functional_red_black_tree_1 = __importDefault(require("functional-red-black-tree"));
+var errors_1 = require("./errors");
+var order_1 = require("./order");
+var orderqueue_1 = require("./orderqueue");
+var types_1 = require("./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 = types_1.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_1.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 (0, errors_1.CustomError)(errors_1.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 = order_1.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 === types_1.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 === types_1.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 === types_1.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 === types_1.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 === types_1.Side.SELL
+            ? function (a, b) { return a - b; }
+            : function (a, b) { return b - a; };
+        this._priceTree = (0, functional_red_black_tree_1.default)(compare);
+        this._side = side;
+    }
+    return OrderSide;
+}());
+exports.OrderSide = OrderSide;

package/dist/cjs/stopbook.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopBook = void 0;
+var stopside_1 = require("./stopside");
+var types_1 = require("./types");
+var StopBook = /** @class */ (function () {
+    function StopBook() {
+        var _this = this;
+        this.add = function (order) {
+            var stopSide = order.side === types_1.Side.BUY ? _this.bids : _this.asks;
+            stopSide.append(order);
+        };
+        this.remove = function (side, id, stopPrice) {
+            var stopSide = side === types_1.Side.BUY ? _this.bids : _this.asks;
+            return stopSide.remove(id, stopPrice);
+        };
+        this.removePriceLevel = function (side, priceLevel) {
+            var stopSide = side === types_1.Side.BUY ? _this.bids : _this.asks;
+            stopSide.removePriceLevel(priceLevel);
+        };
+        this.getConditionalOrders = function (side, priceBefore, marketPrice) {
+            var stopSide = side === types_1.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 === types_1.OrderType.STOP_LIMIT) {
+                // Buy: marketPrice < stopPrice <= price
+                if (side === types_1.Side.BUY &&
+                    marketPrice < stopPrice &&
+                    stopPrice <= order.price) {
+                    response = true;
+                }
+                // Sell: marketPrice > stopPrice >= price
+                if (side === types_1.Side.SELL &&
+                    marketPrice > stopPrice &&
+                    stopPrice >= order.price) {
+                    response = true;
+                }
+            }
+            else {
+                // Buy: marketPrice < stopPrice
+                if (side === types_1.Side.BUY && marketPrice < stopPrice)
+                    response = true;
+                // Sell: marketPrice > stopPrice
+                if (side === types_1.Side.SELL && marketPrice > stopPrice)
+                    response = true;
+            }
+            return response;
+        };
+        this.bids = new stopside_1.StopSide(types_1.Side.BUY);
+        this.asks = new stopside_1.StopSide(types_1.Side.SELL);
+    }
+    return StopBook;
+}());
+exports.StopBook = StopBook;

package/dist/cjs/stopqueue.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopQueue = void 0;
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+var denque_1 = __importDefault(require("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_1.default();
+    }
+    Object.defineProperty(StopQueue.prototype, "price", {
+        get: function () {
+            return this._price;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return StopQueue;
+}());
+exports.StopQueue = StopQueue;

package/dist/cjs/stopside.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopSide = void 0;
+/* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
+var functional_red_black_tree_1 = __importDefault(require("functional-red-black-tree"));
+var errors_1 = require("./errors");
+var stopqueue_1 = require("./stopqueue");
+var types_1 = require("./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_1.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 (0, errors_1.CustomError)(errors_1.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 === types_1.Side.BUY) {
+                lowerBound = highest;
+                upperBound = lowest - 1;
+            }
+            else {
+                lowerBound = lowest;
+                upperBound = highest + 1;
+            }
+            _this._priceTree.forEach(function (price, queue) {
+                if ((_this._side === types_1.Side.BUY && price >= lowest) ||
+                    (_this._side === types_1.Side.SELL && price <= highest)) {
+                    queues.push(queue);
+                }
+            }, lowerBound, // Inclusive
+            upperBound);
+            return queues;
+        };
+        var compare = side === types_1.Side.SELL
+            ? function (a, b) { return a - b; }
+            : function (a, b) { return b - a; };
+        this._priceTree = (0, functional_red_black_tree_1.default)(compare);
+        this._side = side;
+    }
+    return StopSide;
+}());
+exports.StopSide = StopSide;

package/dist/cjs/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeInForce = exports.OrderType = exports.Side = void 0;
+var Side;
+(function (Side) {
+    Side["BUY"] = "buy";
+    Side["SELL"] = "sell";
+})(Side || (exports.Side = Side = {}));
+var OrderType;
+(function (OrderType) {
+    OrderType["LIMIT"] = "limit";
+    OrderType["MARKET"] = "market";
+    OrderType["OCO"] = "oco";
+    OrderType["STOP_LIMIT"] = "stop_limit";
+    OrderType["STOP_MARKET"] = "stop_market";
+})(OrderType || (exports.OrderType = OrderType = {}));
+var TimeInForce;
+(function (TimeInForce) {
+    TimeInForce["GTC"] = "GTC";
+    TimeInForce["IOC"] = "IOC";
+    TimeInForce["FOK"] = "FOK";
+})(TimeInForce || (exports.TimeInForce = TimeInForce = {}));
+/* node:coverage enable */

package/dist/esm/errors.js

@@ -0,0 +1,77 @@
+var _a, _b;
+export var ERROR;
+(function (ERROR) {
+    ERROR["DEFAULT"] = "DEFAULT";
+    ERROR["INSUFFICIENT_QUANTITY"] = "INSUFFICIENT_QUANTITY";
+    ERROR["INVALID_CONDITIONAL_ORDER"] = "INVALID_CONDITIONAL_ORDER";
+    ERROR["INVALID_JOURNAL_LOG"] = "INVALID_JOURNAL_LOG";
+    ERROR["INVALID_ORDER_TYPE"] = "INVALID_ORDER_TYPE";
+    ERROR["INVALID_PRICE"] = "INVALID_PRICE";
+    ERROR["INVALID_PRICE_LEVEL"] = "INVALID_PRICE_LEVEL";
+    ERROR["INVALID_PRICE_OR_QUANTITY"] = "INVALID_PRICE_OR_QUANTITY";
+    ERROR["INVALID_QUANTITY"] = "INVALID_QUANTITY";
+    ERROR["INVALID_SIDE"] = "INVALID_SIDE";
+    ERROR["INVALID_TIF"] = "INVALID_TIF";
+    ERROR["LIMIT_ORDER_FOK_NOT_FILLABLE"] = "LIMIT_ORDER_FOK_NOT_FILLABLE";
+    ERROR["LIMIT_ORDER_POST_ONLY"] = "LIMIT_ORDER_POST_ONLY";
+    ERROR["ORDER_ALREDY_EXISTS"] = "ORDER_ALREDY_EXISTS";
+    ERROR["ORDER_NOT_FOUND"] = "ORDER_NOT_FOUND";
+})(ERROR || (ERROR = {}));
+export var ErrorCodes = (_a = {},
+    // 10xx General issues
+    _a[ERROR.DEFAULT] = 1000,
+    // 11xx Request issues
+    _a[ERROR.INVALID_ORDER_TYPE] = 1100,
+    _a[ERROR.INVALID_SIDE] = 1101,
+    _a[ERROR.INVALID_QUANTITY] = 1102,
+    _a[ERROR.INVALID_PRICE] = 1103,
+    _a[ERROR.INVALID_PRICE_OR_QUANTITY] = 1104,
+    _a[ERROR.INVALID_TIF] = 1105,
+    _a[ERROR.LIMIT_ORDER_FOK_NOT_FILLABLE] = 1106,
+    _a[ERROR.LIMIT_ORDER_POST_ONLY] = 1107,
+    _a[ERROR.INVALID_CONDITIONAL_ORDER] = 1108,
+    _a[ERROR.ORDER_ALREDY_EXISTS] = 1109,
+    _a[ERROR.ORDER_NOT_FOUND] = 1110,
+    // 12xx Internal error
+    _a[ERROR.INSUFFICIENT_QUANTITY] = 1200,
+    _a[ERROR.INVALID_PRICE_LEVEL] = 1201,
+    _a[ERROR.INVALID_JOURNAL_LOG] = 1201,
+    _a);
+export var ErrorMessages = (_b = {},
+    _b[ERROR.DEFAULT] = "Something wrong",
+    _b[ERROR.INSUFFICIENT_QUANTITY] = "Insufficient quantity to calculate price",
+    _b[ERROR.INVALID_CONDITIONAL_ORDER] = "Stop-Limit Order (BUY: marketPrice < stopPrice <= price, SELL: marketPrice > stopPrice >= price). Stop-Market Order (BUY: marketPrice < stopPrice, SELL: marketPrice > stopPrice). OCO order (BUY: price < marketPrice < stopPrice, SELL: price > marketPrice > stopPrice)",
+    _b[ERROR.INVALID_ORDER_TYPE] = "Supported order type are 'limit' and 'market'",
+    _b[ERROR.INVALID_PRICE] = "Invalid order price",
+    _b[ERROR.INVALID_PRICE_LEVEL] = "Invalid order price level",
+    _b[ERROR.INVALID_PRICE_OR_QUANTITY] = "Invalid order price or quantity",
+    _b[ERROR.INVALID_QUANTITY] = "Invalid order quantity",
+    _b[ERROR.INVALID_SIDE] = "Invalid side: must be either 'sell' or 'buy'",
+    _b[ERROR.INVALID_TIF] = "Invalid TimeInForce: must be one of 'GTC', 'IOC' or 'FOK'",
+    _b[ERROR.LIMIT_ORDER_FOK_NOT_FILLABLE] = "Limit FOK order not fillable",
+    _b[ERROR.LIMIT_ORDER_POST_ONLY] = "Post-only limit order rejected because would execute immediately",
+    _b[ERROR.ORDER_ALREDY_EXISTS] = "Order already exists",
+    _b[ERROR.ORDER_NOT_FOUND] = "Order not found",
+    _b[ERROR.INVALID_JOURNAL_LOG] = "Invalid journal log format",
+    _b);
+var OrderBookError = /** @class */ (function () {
+    function OrderBookError(error) {
+        var _a;
+        var errorMessage;
+        if (error != null && ErrorMessages[error] != null) {
+            errorMessage = ErrorMessages[error];
+        }
+        else {
+            var customMessage = error === undefined || error === "" ? "" : ": ".concat(error);
+            errorMessage = "".concat(ErrorMessages.DEFAULT).concat(customMessage);
+        }
+        this.message = errorMessage;
+        this.code = (_a = ErrorCodes[error]) !== null && _a !== void 0 ? _a : ErrorCodes[ERROR.DEFAULT];
+    }
+    return OrderBookError;
+}());
+export { OrderBookError };
+/* node:coverage ignore next - Don't know why this line is uncoverd */
+export var CustomError = function (error) {
+    return new OrderBookError(error);
+};

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+/* node:coverage disable */
+import { OrderBook } from "./orderbook";
+import { OrderType, Side } from "./types";
+export { OrderBook, OrderType, Side, };
+/* node:coverage enable */