nodejs-order-book 10.0.1 → 10.2.0

package/dist/esm/orderbook.js

@@ -1,22 +1,18 @@
-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 { CustomError, ERROR } from "./errors";
 import { OrderFactory, } from "./order";
 import { OrderSide } from "./orderside";
 import { StopBook } from "./stopbook";
-import { OrderType, Side, TimeInForce, } from "./types";
-var validTimeInForce = Object.values(TimeInForce);
-var OrderBook = /** @class */ (function () {
+import { OrderType, SelfTradePreventionMode, Side, TimeInForce, } from "./types";
+const validTimeInForce = Object.values(TimeInForce);
+export class OrderBook {
+    orders = {};
+    _lastOp = 0;
+    _marketPrice = 0;
+    bids;
+    asks;
+    enableJournaling;
+    stopBook;
     /**
      * Creates an instance of OrderBook.
      * @param {OrderBookOptions} [options={}] - Options for configuring the order book.
@@ -24,747 +20,7 @@ var OrderBook = /** @class */ (function () {
      * @param {JournalLog} [options.journal] - Array of journal logs (optional).
      * @param {boolean} [options.enableJournaling=false] - Flag to enable journaling. Default to false
      */
-    function OrderBook(_a) {
-        var _b = _a === void 0 ? {} : _a, snapshot = _b.snapshot, journal = _b.journal, _c = _b.enableJournaling, enableJournaling = _c === void 0 ? false : _c;
-        var _this = this;
-        this.orders = {};
-        this._lastOp = 0;
-        this._marketPrice = 0;
-        /**
-         * 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
-         */
-        this.stopMarket = function (options) {
-            var response = _this._stopMarket(options);
-            if (_this.enableJournaling && response.err === null) {
-                response.log = {
-                    opId: ++_this._lastOp,
-                    ts: Date.now(),
-                    op: "sm",
-                    o: options,
-                };
-            }
-            return response;
-        };
-        /**
-         * 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
-         */
-        this.stopLimit = function (options) {
-            var response = _this._stopLimit(options);
-            if (_this.enableJournaling && response.err === null) {
-                response.log = {
-                    opId: ++_this._lastOp,
-                    ts: Date.now(),
-                    op: "sl",
-                    o: options,
-                };
-            }
-            return response;
-        };
-        /**
-         * 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
-         */
-        this.oco = function (options) {
-            var response = _this._oco(options);
-            if (_this.enableJournaling && response.err === null) {
-                response.log = {
-                    opId: ++_this._lastOp,
-                    ts: Date.now(),
-                    op: "oco",
-                    o: options,
-                };
-            }
-            return response;
-        };
-        /**
-         * 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
-         */
-        this.modify = function (orderID, orderUpdate) {
-            var _a, _b, _c;
-            var order = _this.orders[orderID];
-            if (order === undefined) {
-                return {
-                    done: [],
-                    activated: [],
-                    partial: null,
-                    partialQuantityProcessed: 0,
-                    quantityLeft: 0,
-                    err: CustomError(ERROR.ORDER_NOT_FOUND),
-                };
-            }
-            if ((orderUpdate === null || orderUpdate === void 0 ? void 0 : orderUpdate.price) !== undefined || (orderUpdate === null || orderUpdate === void 0 ? void 0 : orderUpdate.size) !== undefined) {
-                var newPrice = (_a = orderUpdate.price) !== null && _a !== void 0 ? _a : order.price;
-                var newSize = (_b = orderUpdate.size) !== null && _b !== void 0 ? _b : order.size;
-                if (newPrice > 0 && newSize > 0) {
-                    var response = _this.getProcessOrderResponse(newSize);
-                    _this._cancelOrder(order.id, true);
-                    _this.createLimitOrder(response, order.side, order.id, newSize, newPrice, order.postOnly, TimeInForce.GTC);
-                    if (_this.enableJournaling) {
-                        response.log = {
-                            opId: ++_this._lastOp,
-                            ts: Date.now(),
-                            op: "u",
-                            o: { orderID: orderID, orderUpdate: orderUpdate },
-                        };
-                    }
-                    return response;
-                }
-            }
-            // Missing one of price and/or size, or the provided ones are not greater than zero
-            return {
-                done: [],
-                activated: [],
-                partial: null,
-                partialQuantityProcessed: 0,
-                quantityLeft: (_c = orderUpdate === null || orderUpdate === void 0 ? void 0 : orderUpdate.size) !== null && _c !== void 0 ? _c : 0,
-                err: CustomError(ERROR.INVALID_PRICE_OR_QUANTITY),
-            };
-        };
-        /**
-         * 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`
-         */
-        this.cancel = function (orderID) {
-            return _this._cancelOrder(orderID);
-        };
-        /**
-         * 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`
-         */
-        this.order = function (orderID) {
-            var _a;
-            return (_a = _this.orders[orderID]) === null || _a === void 0 ? void 0 : _a.toObject();
-        };
-        // Returns price levels and volume at price level
-        this.depth = function () {
-            var asks = [];
-            var bids = [];
-            _this.asks.priceTree().forEach(function (levelPrice, level) {
-                asks.push([levelPrice, level.volume()]);
-            });
-            _this.bids.priceTree().forEach(function (levelPrice, level) {
-                bids.push([levelPrice, level.volume()]);
-            });
-            return [asks, bids];
-        };
-        this.toString = function () {
-            /* node:coverage ignore next - Don't know what is the uncovered branch here */
-            return "".concat(_this.asks.toString(), "\r\n------------------------------------").concat(_this.bids.toString());
-        };
-        // Returns total market price for requested quantity
-        // if err is not null price returns total price of all levels in side
-        this.calculateMarketPrice = function (side, size) {
-            var price = 0;
-            var err = null;
-            var level;
-            var iter;
-            var quantity = size;
-            if (side === Side.BUY) {
-                level = _this.asks.minPriceQueue();
-                iter = _this.asks.greaterThan;
-            }
-            else {
-                level = _this.bids.maxPriceQueue();
-                iter = _this.bids.lowerThan;
-            }
-            while (quantity > 0 && level !== undefined) {
-                var levelVolume = level.volume();
-                var levelPrice = level.price();
-                if (_this.greaterThanOrEqual(quantity, levelVolume)) {
-                    price += levelPrice * levelVolume;
-                    quantity -= levelVolume;
-                    level = iter(levelPrice);
-                }
-                else {
-                    price += levelPrice * quantity;
-                    quantity = 0;
-                }
-            }
-            if (quantity > 0) {
-                err = CustomError(ERROR.INSUFFICIENT_QUANTITY);
-            }
-            return { price: price, err: err };
-        };
-        this.snapshot = function () {
-            var bids = [];
-            var asks = [];
-            _this.bids.priceTree().forEach(function (price, orders) {
-                bids.push({ price: price, orders: orders.toArray().map(function (o) { return o.toObject(); }) });
-            });
-            _this.asks.priceTree().forEach(function (price, orders) {
-                asks.push({ price: price, orders: orders.toArray().map(function (o) { return o.toObject(); }) });
-            });
-            var stopBook = _this.stopBook.snapshot();
-            return { bids: bids, asks: asks, stopBook: stopBook, ts: Date.now(), lastOp: _this._lastOp };
-        };
-        this._market = function (options, incomingResponse) {
-            var response = incomingResponse !== null && incomingResponse !== void 0 ? incomingResponse : _this.validateMarketOrder(options);
-            if (response.err !== null)
-                return response;
-            var quantityToTrade = options.size;
-            var iter;
-            var sideToProcess;
-            if (options.side === Side.BUY) {
-                iter = _this.asks.minPriceQueue;
-                sideToProcess = _this.asks;
-            }
-            else {
-                iter = _this.bids.maxPriceQueue;
-                sideToProcess = _this.bids;
-            }
-            var priceBefore = _this._marketPrice;
-            while (quantityToTrade > 0 && sideToProcess.len() > 0) {
-                // if sideToProcess.len > 0 it is not necessary to verify that bestPrice exists
-                var bestPrice = iter();
-                var _a = _this.processQueue(bestPrice, quantityToTrade), done = _a.done, partial = _a.partial, partialQuantityProcessed = _a.partialQuantityProcessed, quantityLeft = _a.quantityLeft;
-                response.done = response.done.concat(done);
-                response.partial = partial;
-                response.partialQuantityProcessed = partialQuantityProcessed;
-                quantityToTrade = quantityLeft;
-            }
-            response.quantityLeft = quantityToTrade;
-            _this.executeConditionalOrder(options.side, priceBefore, response);
-            return response;
-        };
-        this._limit = function (options, incomingResponse) {
-            var _a, _b;
-            var response = incomingResponse !== null && incomingResponse !== void 0 ? incomingResponse : _this.validateLimitOrder(options);
-            if (response.err !== null)
-                return response;
-            _this.createLimitOrder(response, options.side, options.id, options.size, options.price, (_a = options.postOnly) !== null && _a !== void 0 ? _a : false, (_b = options.timeInForce) !== null && _b !== void 0 ? _b : TimeInForce.GTC, options.ocoStopPrice);
-            return response;
-        };
-        this._stopMarket = function (options) {
-            var response = _this.validateMarketOrder(options);
-            if (response.err !== null)
-                return response;
-            var stopMarket = OrderFactory.createOrder(__assign(__assign({}, options), { type: OrderType.STOP_MARKET }));
-            return _this._stopOrder(stopMarket, response);
-        };
-        this._stopLimit = function (options) {
-            var _a;
-            var response = _this.validateLimitOrder(options);
-            if (response.err !== null)
-                return response;
-            var stopLimit = OrderFactory.createOrder(__assign(__assign({}, options), { type: OrderType.STOP_LIMIT, timeInForce: (_a = options.timeInForce) !== null && _a !== void 0 ? _a : TimeInForce.GTC }));
-            return _this._stopOrder(stopLimit, response);
-        };
-        this._oco = function (options) {
-            var _a;
-            var response = _this.validateLimitOrder(options);
-            /* node:coverage ignore next - Already validated with limit test */
-            if (response.err !== null)
-                return response;
-            if (_this.validateOCOOrder(options)) {
-                // We use the same ID for Stop Limit and Limit Order, since
-                // we check only on limit order for duplicated ids
-                _this._limit({
-                    id: options.id,
-                    side: options.side,
-                    size: options.size,
-                    price: options.price,
-                    timeInForce: options.timeInForce,
-                    ocoStopPrice: options.stopPrice,
-                }, response);
-                /* node:coverage ignore next - Already validated with limit test */
-                if (response.err !== null)
-                    return response;
-                var stopLimit = OrderFactory.createOrder({
-                    type: OrderType.STOP_LIMIT,
-                    id: options.id,
-                    side: options.side,
-                    size: options.size,
-                    price: options.stopLimitPrice,
-                    stopPrice: options.stopPrice,
-                    timeInForce: (_a = options.stopLimitTimeInForce) !== null && _a !== void 0 ? _a : TimeInForce.GTC,
-                    isOCO: true,
-                });
-                _this.stopBook.add(stopLimit);
-                response.done.push(stopLimit.toObject());
-            }
-            else {
-                response.err = CustomError(ERROR.INVALID_CONDITIONAL_ORDER);
-            }
-            return response;
-        };
-        this._stopOrder = function (stopOrder, response) {
-            if (_this.stopBook.validConditionalOrder(_this._marketPrice, stopOrder)) {
-                _this.stopBook.add(stopOrder);
-                response.done.push(stopOrder.toObject());
-            }
-            else {
-                response.err = CustomError(ERROR.INVALID_CONDITIONAL_ORDER);
-            }
-            return response;
-        };
-        this.restoreSnapshot = function (snapshot) {
-            var _a, _b, _c, _d;
-            _this._lastOp = snapshot.lastOp;
-            for (var _i = 0, _e = snapshot.bids; _i < _e.length; _i++) {
-                var level = _e[_i];
-                for (var _f = 0, _g = level.orders; _f < _g.length; _f++) {
-                    var order = _g[_f];
-                    var newOrder = OrderFactory.createOrder(order);
-                    _this.orders[newOrder.id] = newOrder;
-                    _this.bids.append(newOrder);
-                }
-            }
-            for (var _h = 0, _j = snapshot.asks; _h < _j.length; _h++) {
-                var level = _j[_h];
-                for (var _k = 0, _l = level.orders; _k < _l.length; _k++) {
-                    var order = _l[_k];
-                    var newOrder = OrderFactory.createOrder(order);
-                    _this.orders[newOrder.id] = newOrder;
-                    _this.asks.append(newOrder);
-                }
-            }
-            if (((_b = (_a = snapshot.stopBook) === null || _a === void 0 ? void 0 : _a.bids) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-                for (var _m = 0, _o = snapshot.stopBook.bids; _m < _o.length; _m++) {
-                    var level = _o[_m];
-                    for (var _p = 0, _q = level.orders; _p < _q.length; _p++) {
-                        var order = _q[_p];
-                        // @ts-expect-error // TODO fix types
-                        var newOrder = OrderFactory.createOrder(order);
-                        // @ts-expect-error // TODO fix types
-                        _this.stopBook.add(newOrder);
-                    }
-                }
-            }
-            if (((_d = (_c = snapshot.stopBook) === null || _c === void 0 ? void 0 : _c.asks) === null || _d === void 0 ? void 0 : _d.length) > 0) {
-                for (var _r = 0, _s = snapshot.stopBook.asks; _r < _s.length; _r++) {
-                    var level = _s[_r];
-                    for (var _t = 0, _u = level.orders; _t < _u.length; _t++) {
-                        var order = _u[_t];
-                        // @ts-expect-error // TODO fix types
-                        var newOrder = OrderFactory.createOrder(order);
-                        // @ts-expect-error // TODO fix types
-                        _this.stopBook.add(newOrder);
-                    }
-                }
-            }
-        };
-        /**
-         * 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`
-         */
-        this._cancelOrder = function (orderID, internalDeletion) {
-            var _a, _b;
-            if (internalDeletion === void 0) { internalDeletion = false; }
-            var order = _this.orders[orderID];
-            if (order === undefined)
-                return;
-            delete _this.orders[orderID];
-            var side = order.side === Side.BUY ? _this.bids : _this.asks;
-            var response = {
-                order: (_a = side.remove(order)) === null || _a === void 0 ? void 0 : _a.toObject(),
-            };
-            // Delete OCO Order only when the delete request comes from user
-            if (!internalDeletion && order.ocoStopPrice !== undefined) {
-                response.stopOrder = (_b = _this.stopBook
-                    .remove(order.side, orderID, order.ocoStopPrice)) === null || _b === void 0 ? void 0 : _b.toObject();
-            }
-            if (_this.enableJournaling) {
-                response.log = {
-                    opId: internalDeletion ? _this._lastOp : ++_this._lastOp,
-                    ts: Date.now(),
-                    op: "d",
-                    o: { orderID: orderID },
-                };
-            }
-            return response;
-        };
-        this.getProcessOrderResponse = function (size) {
-            return {
-                done: [],
-                activated: [],
-                partial: null,
-                partialQuantityProcessed: 0,
-                quantityLeft: size,
-                err: null,
-            };
-        };
-        this.createLimitOrder = function (response, side, orderID, size, price, postOnly, timeInForce, ocoStopPrice) {
-            var quantityToTrade = size;
-            var sideToProcess;
-            var sideToAdd;
-            var comparator;
-            var iter;
-            if (side === Side.BUY) {
-                sideToAdd = _this.bids;
-                sideToProcess = _this.asks;
-                comparator = _this.greaterThanOrEqual;
-                iter = _this.asks.minPriceQueue;
-            }
-            else {
-                sideToAdd = _this.asks;
-                sideToProcess = _this.bids;
-                comparator = _this.lowerThanOrEqual;
-                iter = _this.bids.maxPriceQueue;
-            }
-            if (timeInForce === TimeInForce.FOK) {
-                var fillable = _this.canFillOrder(sideToProcess, side, size, price);
-                if (!fillable) {
-                    response.err = CustomError(ERROR.LIMIT_ORDER_FOK_NOT_FILLABLE);
-                    return;
-                }
-            }
-            var bestPrice = iter();
-            var priceBefore = _this._marketPrice;
-            while (quantityToTrade > 0 &&
-                sideToProcess.len() > 0 &&
-                bestPrice !== undefined &&
-                comparator(price, bestPrice.price())) {
-                if (postOnly) {
-                    response.err = CustomError(ERROR.LIMIT_ORDER_POST_ONLY);
-                    return;
-                }
-                var _a = _this.processQueue(bestPrice, quantityToTrade), done = _a.done, partial = _a.partial, partialQuantityProcessed = _a.partialQuantityProcessed, quantityLeft = _a.quantityLeft;
-                response.done = response.done.concat(done);
-                response.partial = partial;
-                response.partialQuantityProcessed = partialQuantityProcessed;
-                quantityToTrade = quantityLeft;
-                response.quantityLeft = quantityToTrade;
-                bestPrice = iter();
-            }
-            _this.executeConditionalOrder(side, priceBefore, response);
-            var order;
-            var takerQty = size - quantityToTrade;
-            var makerQty = quantityToTrade;
-            if (quantityToTrade > 0) {
-                order = OrderFactory.createOrder(__assign({ type: OrderType.LIMIT, id: orderID, side: side, size: quantityToTrade, origSize: size, price: price, time: Date.now(), timeInForce: timeInForce, postOnly: postOnly, takerQty: takerQty, makerQty: makerQty }, (ocoStopPrice !== undefined ? { ocoStopPrice: ocoStopPrice } : {})));
-                if (response.done.length > 0) {
-                    response.partialQuantityProcessed = size - quantityToTrade;
-                    response.partial = order.toObject();
-                }
-                _this.orders[orderID] = sideToAdd.append(order);
-            }
-            else {
-                var totalQuantity_1 = 0;
-                var totalPrice_1 = 0;
-                response.done.forEach(function (order) {
-                    totalQuantity_1 += order.size;
-                    totalPrice_1 += order.price * order.size;
-                });
-                if (response.partialQuantityProcessed > 0 && response.partial !== null) {
-                    totalQuantity_1 += response.partialQuantityProcessed;
-                    totalPrice_1 +=
-                        response.partial.price * response.partialQuantityProcessed;
-                }
-                order = OrderFactory.createOrder({
-                    id: orderID,
-                    type: OrderType.LIMIT,
-                    side: side,
-                    size: size,
-                    origSize: size,
-                    price: totalPrice_1 / totalQuantity_1,
-                    time: Date.now(),
-                    timeInForce: timeInForce,
-                    postOnly: postOnly,
-                    takerQty: takerQty,
-                    makerQty: makerQty,
-                });
-                response.done.push(order.toObject());
-            }
-            // If IOC order was not matched completely remove from the order book
-            if (timeInForce === TimeInForce.IOC && response.quantityLeft > 0) {
-                _this._cancelOrder(orderID, true);
-            }
-            return order;
-        };
-        this.executeConditionalOrder = function (side, priceBefore, response) {
-            var pendingOrders = _this.stopBook.getConditionalOrders(side, priceBefore, _this._marketPrice);
-            if (pendingOrders.length > 0) {
-                var toBeExecuted_1 = [];
-                // Before get all orders to be executed and clean up the stop queue
-                // in order to avoid that an executed limit/market order run against
-                // the same stop order queue
-                pendingOrders.forEach(function (queue) {
-                    while (queue.len() > 0) {
-                        var headOrder = queue.removeFromHead();
-                        if (headOrder !== undefined)
-                            toBeExecuted_1.push(headOrder);
-                    }
-                    // Queue is empty now so remove the priceLevel
-                    _this.stopBook.removePriceLevel(side, queue.price);
-                });
-                toBeExecuted_1.forEach(function (stopOrder) {
-                    if (stopOrder.type === OrderType.STOP_MARKET) {
-                        _this._market({
-                            id: stopOrder.id,
-                            side: stopOrder.side,
-                            size: stopOrder.size,
-                        }, response);
-                    }
-                    else {
-                        if (stopOrder.isOCO) {
-                            _this._cancelOrder(stopOrder.id, true);
-                        }
-                        _this._limit({
-                            id: stopOrder.id,
-                            side: stopOrder.side,
-                            size: stopOrder.size,
-                            price: stopOrder.price,
-                            timeInForce: stopOrder.timeInForce,
-                        }, response);
-                    }
-                    response.activated.push(stopOrder.toObject());
-                });
-            }
-        };
-        this.replayJournal = function (journal) {
-            for (var _i = 0, journal_1 = journal; _i < journal_1.length; _i++) {
-                var log = journal_1[_i];
-                switch (log.op) {
-                    case "m": {
-                        var _a = log.o, side = _a.side, size = _a.size;
-                        if (side == null || size == null) {
-                            throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                        }
-                        _this.market(log.o);
-                        break;
-                    }
-                    case "l": {
-                        var _b = log.o, side = _b.side, id = _b.id, size = _b.size, price = _b.price;
-                        if (side == null || id == null || size == null || price == null) {
-                            throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                        }
-                        _this.limit(log.o);
-                        break;
-                    }
-                    case "sm": {
-                        var _c = log.o, side = _c.side, size = _c.size, stopPrice = _c.stopPrice;
-                        if (side == null || size == null || stopPrice == null) {
-                            throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                        }
-                        _this.stopMarket(log.o);
-                        break;
-                    }
-                    case "sl": {
-                        var _d = log.o, side = _d.side, id = _d.id, size = _d.size, price = _d.price, stopPrice = _d.stopPrice;
-                        if (side == null ||
-                            id == null ||
-                            size == null ||
-                            price == null ||
-                            stopPrice == null) {
-                            throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                        }
-                        _this.stopLimit(log.o);
-                        break;
-                    }
-                    case "oco": {
-                        var _e = log.o, side = _e.side, id = _e.id, size = _e.size, price = _e.price, stopPrice = _e.stopPrice, stopLimitPrice = _e.stopLimitPrice;
-                        if (side == null ||
-                            id == null ||
-                            size == null ||
-                            price == null ||
-                            stopPrice == null ||
-                            stopLimitPrice == null) {
-                            throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                        }
-                        _this.oco(log.o);
-                        break;
-                    }
-                    case "d":
-                        if (log.o.orderID == null)
-                            throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                        _this.cancel(log.o.orderID);
-                        break;
-                    case "u":
-                        if (log.o.orderID == null || log.o.orderUpdate == null) {
-                            throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                        }
-                        _this.modify(log.o.orderID, log.o.orderUpdate);
-                        break;
-                    default:
-                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
-                }
-            }
-        };
-        /**
-         * OCO Order:
-         *    Buy: price < marketPrice < stopPrice
-         *    Sell: price > marketPrice > stopPrice
-         */
-        this.validateOCOOrder = function (options) {
-            var response = false;
-            if (options.side === Side.BUY &&
-                options.price < _this._marketPrice &&
-                _this._marketPrice < options.stopPrice) {
-                response = true;
-            }
-            if (options.side === Side.SELL &&
-                options.price > _this._marketPrice &&
-                _this._marketPrice > options.stopPrice) {
-                response = true;
-            }
-            return response;
-        };
-        this.greaterThanOrEqual = function (a, b) {
-            return a >= b;
-        };
-        this.lowerThanOrEqual = function (a, b) {
-            return a <= b;
-        };
-        this.processQueue = function (orderQueue, quantityToTrade) {
-            var response = {
-                done: [],
-                activated: [],
-                partial: null,
-                partialQuantityProcessed: 0,
-                quantityLeft: quantityToTrade,
-                err: null,
-            };
-            if (response.quantityLeft > 0) {
-                while (orderQueue.len() > 0 && response.quantityLeft > 0) {
-                    var headOrder = orderQueue.head();
-                    if (headOrder !== undefined) {
-                        if (response.quantityLeft < headOrder.size) {
-                            var partial = OrderFactory.createOrder(__assign(__assign({}, headOrder.toObject()), { size: headOrder.size - response.quantityLeft }));
-                            response.partial = partial.toObject();
-                            _this.orders[headOrder.id] = partial;
-                            response.partialQuantityProcessed = response.quantityLeft;
-                            orderQueue.update(headOrder, partial);
-                            response.quantityLeft = 0;
-                        }
-                        else {
-                            response.quantityLeft = response.quantityLeft - headOrder.size;
-                            var canceledOrder = _this._cancelOrder(headOrder.id, true);
-                            /* node:coverage ignore next - Unable to test when order is undefined */
-                            if ((canceledOrder === null || canceledOrder === void 0 ? void 0 : canceledOrder.order) !== undefined) {
-                                response.done.push(canceledOrder.order);
-                            }
-                        }
-                        // Remove linked OCO Stop Order if any
-                        if (headOrder.ocoStopPrice !== undefined) {
-                            _this.stopBook.remove(headOrder.side, headOrder.id, headOrder.ocoStopPrice);
-                        }
-                        _this._marketPrice = headOrder.price;
-                    }
-                }
-            }
-            return response;
-        };
-        this.canFillOrder = function (orderSide, side, size, price) {
-            return side === Side.BUY
-                ? _this.buyOrderCanBeFilled(orderSide, size, price)
-                : _this.sellOrderCanBeFilled(orderSide, size, price);
-        };
-        this.buyOrderCanBeFilled = function (orderSide, size, price) {
-            if (orderSide.volume() < size) {
-                return false;
-            }
-            var cumulativeSize = 0;
-            // biome-ignore lint/suspicious/useIterableCallbackReturn: the forEach of the priceTree must return true to break the loop
-            orderSide.priceTree().forEach(function (_, level) {
-                if (price >= level.price() && cumulativeSize < size) {
-                    cumulativeSize += level.volume();
-                }
-                else {
-                    return true; // break the loop
-                }
-            });
-            return cumulativeSize >= size;
-        };
-        this.sellOrderCanBeFilled = function (orderSide, size, price) {
-            if (orderSide.volume() < size) {
-                return false;
-            }
-            var cumulativeSize = 0;
-            // biome-ignore lint/suspicious/useIterableCallbackReturn: the forEach of the priceTree must return true to break the loop
-            orderSide.priceTree().forEach(function (_, level) {
-                if (price <= level.price() && cumulativeSize < size) {
-                    cumulativeSize += level.volume();
-                }
-                else {
-                    return true; // break the loop
-                }
-            });
-            return cumulativeSize >= size;
-        };
-        this.validateMarketOrder = function (order) {
-            var response = _this.getProcessOrderResponse(order.size);
-            if (![Side.SELL, Side.BUY].includes(order.side)) {
-                response.err = CustomError(ERROR.INVALID_SIDE);
-                return response;
-            }
-            if (typeof order.size !== "number" || order.size <= 0) {
-                response.err = CustomError(ERROR.INSUFFICIENT_QUANTITY);
-                return response;
-            }
-            return response;
-        };
-        this.validateLimitOrder = function (options) {
-            var response = _this.getProcessOrderResponse(options.size);
-            if (![Side.SELL, Side.BUY].includes(options.side)) {
-                response.err = CustomError(ERROR.INVALID_SIDE);
-                return response;
-            }
-            if (_this.orders[options.id] !== undefined) {
-                response.err = CustomError(ERROR.ORDER_ALREDY_EXISTS);
-                return response;
-            }
-            if (typeof options.size !== "number" || options.size <= 0) {
-                response.err = CustomError(ERROR.INVALID_QUANTITY);
-                return response;
-            }
-            if (typeof options.price !== "number" || options.price <= 0) {
-                response.err = CustomError(ERROR.INVALID_PRICE);
-                return response;
-            }
-            if (options.timeInForce &&
-                !validTimeInForce.includes(options.timeInForce)) {
-                response.err = CustomError(ERROR.INVALID_TIF);
-                return response;
-            }
-            return response;
-        };
+    constructor({ snapshot, journal, enableJournaling = false, } = {}) {
         this.bids = new OrderSide(Side.BUY);
         this.asks = new OrderSide(Side.SELL);
         this.enableJournaling = enableJournaling;
@@ -779,27 +35,19 @@ var OrderBook = /** @class */ (function () {
                 throw CustomError(ERROR.INVALID_JOURNAL_LOG);
             // If a snapshot is available be sure to remove logs before the last restored operation
             if (snapshot != null && snapshot.lastOp > 0) {
-                journal = journal.filter(function (log) { return log.opId > snapshot.lastOp; });
+                journal = journal.filter((log) => log.opId > snapshot.lastOp);
             }
             this.replayJournal(journal);
         }
     }
-    Object.defineProperty(OrderBook.prototype, "marketPrice", {
-        // Getter for the market price
-        get: function () {
-            return this._marketPrice;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(OrderBook.prototype, "lastOp", {
-        // Getter for the lastOp
-        get: function () {
-            return this._lastOp;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    // Getter for the market price
+    get marketPrice() {
+        return this._marketPrice;
+    }
+    // Getter for the lastOp
+    get lastOp() {
+        return this._lastOp;
+    }
     /**
      * Create new order. See {@link CreateOrderOptions} for details.
      *
@@ -816,7 +64,7 @@ var OrderBook = /** @class */ (function () {
      * @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
      */
-    OrderBook.prototype.createOrder = function (options) {
+    createOrder(options) {
         switch (options.type) {
             case OrderType.MARKET:
                 return this.market(options);
@@ -838,7 +86,7 @@ var OrderBook = /** @class */ (function () {
                     err: CustomError(ERROR.INVALID_ORDER_TYPE),
                 };
         }
-    };
+    }
     /**
      * Create a market order. See {@link MarketOrderOptions} for details.
      *
@@ -847,8 +95,8 @@ var OrderBook = /** @class */ (function () {
      * @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
      */
-    OrderBook.prototype.market = function (options) {
-        var response = this._market(options);
+    market(options) {
+        const response = this._market(options);
         if (this.enableJournaling && response.err === null) {
             response.log = {
                 opId: ++this._lastOp,
@@ -858,6 +106,27 @@ var OrderBook = /** @class */ (function () {
             };
         }
         return response;
+    }
+    /**
+     * 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) => {
+        const response = this._stopMarket(options);
+        if (this.enableJournaling && response.err === null) {
+            response.log = {
+                opId: ++this._lastOp,
+                ts: Date.now(),
+                op: "sm",
+                o: options,
+            };
+        }
+        return response;
     };
     /**
      * Create a limit order. See {@link LimitOrderOptions} for details.
@@ -871,8 +140,8 @@ var OrderBook = /** @class */ (function () {
      * @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
      */
-    OrderBook.prototype.limit = function (options) {
-        var response = this._limit(options);
+    limit(options) {
+        const response = this._limit(options);
         if (this.enableJournaling && response.err === null) {
             response.log = {
                 opId: ++this._lastOp,
@@ -882,7 +151,857 @@ var OrderBook = /** @class */ (function () {
             };
         }
         return response;
+    }
+    /**
+     * 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) => {
+        const response = this._stopLimit(options);
+        if (this.enableJournaling && response.err === null) {
+            response.log = {
+                opId: ++this._lastOp,
+                ts: Date.now(),
+                op: "sl",
+                o: options,
+            };
+        }
+        return response;
+    };
+    /**
+     * 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) => {
+        const response = this._oco(options);
+        if (this.enableJournaling && response.err === null) {
+            response.log = {
+                opId: ++this._lastOp,
+                ts: Date.now(),
+                op: "oco",
+                o: options,
+            };
+        }
+        return response;
+    };
+    /**
+     * 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, orderUpdate) => {
+        const order = this.orders[orderID];
+        if (order === undefined) {
+            return {
+                done: [],
+                activated: [],
+                partial: null,
+                partialQuantityProcessed: 0,
+                quantityLeft: 0,
+                err: CustomError(ERROR.ORDER_NOT_FOUND),
+            };
+        }
+        if (orderUpdate?.price !== undefined || orderUpdate?.size !== undefined) {
+            const newPrice = orderUpdate.price ?? order.price;
+            const newSize = orderUpdate.size ?? order.size;
+            if (newPrice > 0 && newSize > 0) {
+                const response = this.getProcessOrderResponse(newSize);
+                this._cancelOrder(order.id, true);
+                this.createLimitOrder(response, order.side, order.id, newSize, newPrice, order.postOnly, TimeInForce.GTC, undefined, "", SelfTradePreventionMode.NONE);
+                if (this.enableJournaling) {
+                    response.log = {
+                        opId: ++this._lastOp,
+                        ts: Date.now(),
+                        op: "u",
+                        o: { orderID, orderUpdate },
+                    };
+                }
+                return response;
+            }
+        }
+        // Missing one of price and/or size, or the provided ones are not greater than zero
+        return {
+            done: [],
+            activated: [],
+            partial: null,
+            partialQuantityProcessed: 0,
+            quantityLeft: orderUpdate?.size ?? 0,
+            err: CustomError(ERROR.INVALID_PRICE_OR_QUANTITY),
+        };
+    };
+    /**
+     * 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) => {
+        return this._cancelOrder(orderID);
+    };
+    /**
+     * 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) => {
+        return this.orders[orderID]?.toObject();
+    };
+    // Returns price levels and volume at price level
+    depth = () => {
+        const asks = [];
+        const bids = [];
+        this.asks.priceTree().forEach((levelPrice, level) => {
+            asks.push([levelPrice, level.volume()]);
+        });
+        this.bids.priceTree().forEach((levelPrice, level) => {
+            bids.push([levelPrice, level.volume()]);
+        });
+        return [asks, bids];
+    };
+    toString = () => {
+        /* node:coverage ignore next - Don't know what is the uncovered branch here */
+        return `${this.asks.toString()}\r\n------------------------------------${this.bids.toString()}`;
+    };
+    // Returns total market price for requested quantity
+    // if err is not null price returns total price of all levels in side
+    calculateMarketPrice = (side, size) => {
+        let price = 0;
+        let err = null;
+        let level;
+        let iter;
+        let quantity = size;
+        if (side === Side.BUY) {
+            level = this.asks.minPriceQueue();
+            iter = this.asks.greaterThan;
+        }
+        else {
+            level = this.bids.maxPriceQueue();
+            iter = this.bids.lowerThan;
+        }
+        while (quantity > 0 && level !== undefined) {
+            const levelVolume = level.volume();
+            const levelPrice = level.price();
+            if (this.greaterThanOrEqual(quantity, levelVolume)) {
+                price += levelPrice * levelVolume;
+                quantity -= levelVolume;
+                level = iter(levelPrice);
+            }
+            else {
+                price += levelPrice * quantity;
+                quantity = 0;
+            }
+        }
+        if (quantity > 0) {
+            err = CustomError(ERROR.INSUFFICIENT_QUANTITY);
+        }
+        return { price, err };
+    };
+    snapshot = () => {
+        const bids = [];
+        const asks = [];
+        this.bids.priceTree().forEach((price, orders) => {
+            bids.push({ price, orders: orders.toArray().map((o) => o.toObject()) });
+        });
+        this.asks.priceTree().forEach((price, orders) => {
+            asks.push({ price, orders: orders.toArray().map((o) => o.toObject()) });
+        });
+        const stopBook = this.stopBook.snapshot();
+        return { bids, asks, stopBook, ts: Date.now(), lastOp: this._lastOp };
+    };
+    _market = (options, incomingResponse) => {
+        const response = incomingResponse ?? this.validateMarketOrder(options);
+        if (response.err !== null)
+            return response;
+        const takerAccountId = options.accountId;
+        const takerStpMode = options.stpMode;
+        let quantityToTrade = options.size;
+        let iter;
+        let sideToProcess;
+        if (options.side === Side.BUY) {
+            iter = this.asks.minPriceQueue;
+            sideToProcess = this.asks;
+        }
+        else {
+            iter = this.bids.maxPriceQueue;
+            sideToProcess = this.bids;
+        }
+        const priceBefore = this._marketPrice;
+        while (quantityToTrade > 0 &&
+            sideToProcess.len() > 0 &&
+            response.err === null) {
+            // if sideToProcess.len > 0 it is not necessary to verify that bestPrice exists
+            const bestPrice = iter();
+            const { done, partial, partialQuantityProcessed, quantityLeft, stpExpired, err, } = this.processQueue(bestPrice, quantityToTrade, takerAccountId, takerStpMode);
+            response.done = response.done.concat(done);
+            response.partial = partial;
+            response.partialQuantityProcessed = partialQuantityProcessed;
+            quantityToTrade = quantityLeft;
+            if (err !== null) {
+                response.err = err;
+            }
+            if (stpExpired !== undefined) {
+                if (response.stpExpired === undefined) {
+                    response.stpExpired = [];
+                }
+                response.stpExpired = response.stpExpired.concat(stpExpired);
+            }
+        }
+        response.quantityLeft = quantityToTrade;
+        if (response.err === null) {
+            this.executeConditionalOrder(options.side, priceBefore, response);
+        }
+        return response;
+    };
+    _limit = (options, incomingResponse) => {
+        const response = incomingResponse ?? this.validateLimitOrder(options);
+        if (response.err !== null)
+            return response;
+        this.createLimitOrder(response, options.side, options.id, options.size, options.price, options.postOnly ?? false, options.timeInForce ?? TimeInForce.GTC, options.ocoStopPrice, options.accountId, options.stpMode);
+        return response;
+    };
+    _stopMarket = (options) => {
+        const response = this.validateMarketOrder(options);
+        if (response.err !== null)
+            return response;
+        const stopMarket = OrderFactory.createOrder({
+            ...options,
+            type: OrderType.STOP_MARKET,
+        });
+        return this._stopOrder(stopMarket, response);
+    };
+    _stopLimit = (options) => {
+        const response = this.validateLimitOrder(options);
+        if (response.err !== null)
+            return response;
+        const stopLimit = OrderFactory.createOrder({
+            ...options,
+            type: OrderType.STOP_LIMIT,
+            timeInForce: options.timeInForce ?? TimeInForce.GTC,
+        });
+        return this._stopOrder(stopLimit, response);
+    };
+    _oco = (options) => {
+        const response = this.validateLimitOrder(options);
+        /* node:coverage ignore next - Already validated with limit test */
+        if (response.err !== null)
+            return response;
+        if (this.validateOCOOrder(options)) {
+            // We use the same ID for Stop Limit and Limit Order, since
+            // we check only on limit order for duplicated ids
+            this._limit({
+                id: options.id,
+                side: options.side,
+                size: options.size,
+                price: options.price,
+                timeInForce: options.timeInForce,
+                ocoStopPrice: options.stopPrice,
+            }, response);
+            /* node:coverage ignore next - Already validated with limit test */
+            if (response.err !== null)
+                return response;
+            const stopLimit = OrderFactory.createOrder({
+                type: OrderType.STOP_LIMIT,
+                id: options.id,
+                side: options.side,
+                size: options.size,
+                price: options.stopLimitPrice,
+                stopPrice: options.stopPrice,
+                timeInForce: options.stopLimitTimeInForce ?? TimeInForce.GTC,
+                isOCO: true,
+            });
+            this.stopBook.add(stopLimit);
+            response.done.push(stopLimit.toObject());
+        }
+        else {
+            response.err = CustomError(ERROR.INVALID_CONDITIONAL_ORDER);
+        }
+        return response;
+    };
+    _stopOrder = (stopOrder, response) => {
+        if (this.stopBook.validConditionalOrder(this._marketPrice, stopOrder)) {
+            this.stopBook.add(stopOrder);
+            response.done.push(stopOrder.toObject());
+        }
+        else {
+            response.err = CustomError(ERROR.INVALID_CONDITIONAL_ORDER);
+        }
+        return response;
+    };
+    restoreSnapshot = (snapshot) => {
+        this._lastOp = snapshot.lastOp;
+        for (const level of snapshot.bids) {
+            for (const order of level.orders) {
+                const newOrder = OrderFactory.createOrder(order);
+                this.orders[newOrder.id] = newOrder;
+                this.bids.append(newOrder);
+            }
+        }
+        for (const level of snapshot.asks) {
+            for (const order of level.orders) {
+                const newOrder = OrderFactory.createOrder(order);
+                this.orders[newOrder.id] = newOrder;
+                this.asks.append(newOrder);
+            }
+        }
+        if (snapshot.stopBook?.bids?.length > 0) {
+            for (const level of snapshot.stopBook.bids) {
+                for (const order of level.orders) {
+                    // @ts-expect-error // TODO fix types
+                    const newOrder = OrderFactory.createOrder(order);
+                    // @ts-expect-error // TODO fix types
+                    this.stopBook.add(newOrder);
+                }
+            }
+        }
+        if (snapshot.stopBook?.asks?.length > 0) {
+            for (const level of snapshot.stopBook.asks) {
+                for (const order of level.orders) {
+                    // @ts-expect-error // TODO fix types
+                    const newOrder = OrderFactory.createOrder(order);
+                    // @ts-expect-error // TODO fix types
+                    this.stopBook.add(newOrder);
+                }
+            }
+        }
+    };
+    /**
+     * 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`
+     */
+    _cancelOrder = (orderID, internalDeletion = false) => {
+        const order = this.orders[orderID];
+        if (order === undefined)
+            return;
+        delete this.orders[orderID];
+        const side = order.side === Side.BUY ? this.bids : this.asks;
+        const response = {
+            order: side.remove(order)?.toObject(),
+        };
+        // Delete OCO Order only when the delete request comes from user
+        if (!internalDeletion && order.ocoStopPrice !== undefined) {
+            response.stopOrder = this.stopBook
+                .remove(order.side, orderID, order.ocoStopPrice)
+                ?.toObject();
+        }
+        if (this.enableJournaling) {
+            response.log = {
+                opId: internalDeletion ? this._lastOp : ++this._lastOp,
+                ts: Date.now(),
+                op: "d",
+                o: { orderID },
+            };
+        }
+        return response;
+    };
+    getProcessOrderResponse = (size) => {
+        return {
+            done: [],
+            activated: [],
+            partial: null,
+            partialQuantityProcessed: 0,
+            quantityLeft: size,
+            err: null,
+        };
+    };
+    createLimitOrder = (response, side, orderID, size, price, postOnly, timeInForce, ocoStopPrice, takerAccountId, stpMode) => {
+        let quantityToTrade = size;
+        let sideToProcess;
+        let sideToAdd;
+        let comparator;
+        let iter;
+        if (side === Side.BUY) {
+            sideToAdd = this.bids;
+            sideToProcess = this.asks;
+            comparator = this.greaterThanOrEqual;
+            iter = this.asks.minPriceQueue;
+        }
+        else {
+            sideToAdd = this.asks;
+            sideToProcess = this.bids;
+            comparator = this.lowerThanOrEqual;
+            iter = this.bids.maxPriceQueue;
+        }
+        if (timeInForce === TimeInForce.FOK) {
+            // FOK is atomic, so this check is STP-aware.
+            const fillable = this.canFillOrder(sideToProcess, (levelPrice) => comparator(price, levelPrice), size, takerAccountId, stpMode);
+            if (!fillable) {
+                response.err = CustomError(ERROR.LIMIT_ORDER_FOK_NOT_FILLABLE);
+                return;
+            }
+        }
+        let bestPrice = iter();
+        const priceBefore = this._marketPrice;
+        while (quantityToTrade > 0 &&
+            sideToProcess.len() > 0 &&
+            bestPrice !== undefined &&
+            comparator(price, bestPrice.price()) &&
+            response.err === null) {
+            if (postOnly) {
+                response.err = CustomError(ERROR.LIMIT_ORDER_POST_ONLY);
+                return;
+            }
+            const { done, partial, partialQuantityProcessed, quantityLeft, stpExpired, err, } = this.processQueue(bestPrice, quantityToTrade, takerAccountId, stpMode);
+            response.done = response.done.concat(done);
+            response.partial = partial;
+            response.partialQuantityProcessed = partialQuantityProcessed;
+            quantityToTrade = quantityLeft;
+            response.quantityLeft = quantityToTrade;
+            if (err !== null) {
+                response.err = err;
+            }
+            if (stpExpired !== undefined) {
+                if (response.stpExpired === undefined) {
+                    response.stpExpired = [];
+                }
+                response.stpExpired = response.stpExpired.concat(stpExpired);
+            }
+            bestPrice = iter();
+        }
+        // If STP triggered (EXPIRE_TAKER or EXPIRE_BOTH), don't add order to book
+        if (response.err !== null) {
+            return;
+        }
+        this.executeConditionalOrder(side, priceBefore, response);
+        let order;
+        const takerQty = size - quantityToTrade;
+        const makerQty = quantityToTrade;
+        if (quantityToTrade > 0) {
+            order = OrderFactory.createOrder({
+                type: OrderType.LIMIT,
+                id: orderID,
+                side,
+                size: quantityToTrade,
+                origSize: size,
+                price,
+                time: Date.now(),
+                timeInForce,
+                postOnly,
+                takerQty,
+                makerQty,
+                accountId: takerAccountId,
+                stpMode: stpMode,
+                ...(ocoStopPrice !== undefined ? { ocoStopPrice } : {}),
+            });
+            if (response.done.length > 0) {
+                response.partialQuantityProcessed = size - quantityToTrade;
+                response.partial = order.toObject();
+            }
+            this.orders[orderID] = sideToAdd.append(order);
+        }
+        else {
+            let totalQuantity = 0;
+            let totalPrice = 0;
+            response.done.forEach((order) => {
+                totalQuantity += order.size;
+                totalPrice += order.price * order.size;
+            });
+            if (response.partialQuantityProcessed > 0 && response.partial !== null) {
+                totalQuantity += response.partialQuantityProcessed;
+                totalPrice +=
+                    response.partial.price * response.partialQuantityProcessed;
+            }
+            order = OrderFactory.createOrder({
+                id: orderID,
+                type: OrderType.LIMIT,
+                side,
+                size,
+                origSize: size,
+                price: totalPrice / totalQuantity,
+                time: Date.now(),
+                timeInForce,
+                postOnly,
+                takerQty,
+                makerQty,
+                accountId: takerAccountId,
+                stpMode: stpMode,
+            });
+            response.done.push(order.toObject());
+        }
+        // If IOC order was not matched completely remove from the order book
+        if (timeInForce === TimeInForce.IOC && response.quantityLeft > 0) {
+            this._cancelOrder(orderID, true);
+        }
+        return order;
+    };
+    executeConditionalOrder = (side, priceBefore, response) => {
+        const pendingOrders = this.stopBook.getConditionalOrders(side, priceBefore, this._marketPrice);
+        if (pendingOrders.length > 0) {
+            const toBeExecuted = [];
+            // Before get all orders to be executed and clean up the stop queue
+            // in order to avoid that an executed limit/market order run against
+            // the same stop order queue
+            pendingOrders.forEach((queue) => {
+                while (queue.len() > 0) {
+                    const headOrder = queue.removeFromHead();
+                    if (headOrder !== undefined)
+                        toBeExecuted.push(headOrder);
+                }
+                // Queue is empty now so remove the priceLevel
+                this.stopBook.removePriceLevel(side, queue.price);
+            });
+            toBeExecuted.forEach((stopOrder) => {
+                if (stopOrder.type === OrderType.STOP_MARKET) {
+                    this._market({
+                        id: stopOrder.id,
+                        side: stopOrder.side,
+                        size: stopOrder.size,
+                        accountId: stopOrder.accountId,
+                        stpMode: stopOrder.stpMode,
+                    }, response);
+                }
+                else {
+                    if (stopOrder.isOCO) {
+                        this._cancelOrder(stopOrder.id, true);
+                    }
+                    this._limit({
+                        id: stopOrder.id,
+                        side: stopOrder.side,
+                        size: stopOrder.size,
+                        price: stopOrder.price,
+                        timeInForce: stopOrder.timeInForce,
+                        accountId: stopOrder.accountId,
+                        stpMode: stopOrder.stpMode,
+                    }, response);
+                }
+                response.activated.push(stopOrder.toObject());
+            });
+        }
+    };
+    replayJournal = (journal) => {
+        for (const log of journal) {
+            switch (log.op) {
+                case "m": {
+                    const { side, size } = log.o;
+                    if (side == null || size == null) {
+                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+                    }
+                    this.market(log.o);
+                    break;
+                }
+                case "l": {
+                    const { side, id, size, price } = log.o;
+                    if (side == null || id == null || size == null || price == null) {
+                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+                    }
+                    this.limit(log.o);
+                    break;
+                }
+                case "sm": {
+                    const { side, size, stopPrice } = log.o;
+                    if (side == null || size == null || stopPrice == null) {
+                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+                    }
+                    this.stopMarket(log.o);
+                    break;
+                }
+                case "sl": {
+                    const { side, id, size, price, stopPrice } = log.o;
+                    if (side == null ||
+                        id == null ||
+                        size == null ||
+                        price == null ||
+                        stopPrice == null) {
+                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+                    }
+                    this.stopLimit(log.o);
+                    break;
+                }
+                case "oco": {
+                    const { side, id, size, price, stopPrice, stopLimitPrice } = log.o;
+                    if (side == null ||
+                        id == null ||
+                        size == null ||
+                        price == null ||
+                        stopPrice == null ||
+                        stopLimitPrice == null) {
+                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+                    }
+                    this.oco(log.o);
+                    break;
+                }
+                case "d":
+                    if (log.o.orderID == null)
+                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+                    this.cancel(log.o.orderID);
+                    break;
+                case "u":
+                    if (log.o.orderID == null || log.o.orderUpdate == null) {
+                        throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+                    }
+                    this.modify(log.o.orderID, log.o.orderUpdate);
+                    break;
+                default:
+                    throw CustomError(ERROR.INVALID_JOURNAL_LOG);
+            }
+        }
+    };
+    /**
+     * OCO Order:
+     *    Buy: price < marketPrice < stopPrice
+     *    Sell: price > marketPrice > stopPrice
+     */
+    validateOCOOrder = (options) => {
+        let response = false;
+        if (options.side === Side.BUY &&
+            options.price < this._marketPrice &&
+            this._marketPrice < options.stopPrice) {
+            response = true;
+        }
+        if (options.side === Side.SELL &&
+            options.price > this._marketPrice &&
+            this._marketPrice > options.stopPrice) {
+            response = true;
+        }
+        return response;
+    };
+    greaterThanOrEqual = (a, b) => {
+        return a >= b;
+    };
+    lowerThanOrEqual = (a, b) => {
+        return a <= b;
+    };
+    processQueue = (orderQueue, quantityToTrade, takerAccountId, stpMode) => {
+        const response = {
+            done: [],
+            activated: [],
+            partial: null,
+            partialQuantityProcessed: 0,
+            quantityLeft: quantityToTrade,
+            err: null,
+        };
+        if (response.quantityLeft > 0) {
+            while (orderQueue.len() > 0 && response.quantityLeft > 0) {
+                const headOrder = orderQueue.head();
+                if (headOrder !== undefined) {
+                    // Self-Trade Prevention check
+                    if (takerAccountId &&
+                        headOrder.accountId === takerAccountId &&
+                        stpMode != null &&
+                        stpMode !== SelfTradePreventionMode.NONE) {
+                        switch (stpMode) {
+                            case SelfTradePreventionMode.EXPIRE_MAKER: {
+                                // Remove the maker order from the book, continue matching
+                                const removedOrder = this._cancelOrder(headOrder.id, true);
+                                if (removedOrder?.order !== undefined) {
+                                    if (response.stpExpired === undefined) {
+                                        response.stpExpired = [];
+                                    }
+                                    response.stpExpired.push(removedOrder.order);
+                                }
+                                continue;
+                            }
+                            case SelfTradePreventionMode.EXPIRE_TAKER: {
+                                // Taker expires immediately, nothing matches.
+                                // response.quantityLeft is intentionally left untouched: it already
+                                // holds the unfilled quantity, which is lower than the level-entry
+                                // `quantityToTrade` when STP triggers after a partial fill inside
+                                // this price level. Resetting it would resurrect filled quantity.
+                                response.err = CustomError(ERROR.STP_TRIGGERED);
+                                return response;
+                            }
+                            case SelfTradePreventionMode.EXPIRE_BOTH: {
+                                // Remove maker from book AND expire taker.
+                                // As in EXPIRE_TAKER, response.quantityLeft must keep the running
+                                // unfilled quantity rather than the level-entry quantityToTrade.
+                                const removedOrder = this._cancelOrder(headOrder.id, true);
+                                if (removedOrder?.order !== undefined) {
+                                    if (response.stpExpired === undefined) {
+                                        response.stpExpired = [];
+                                    }
+                                    response.stpExpired.push(removedOrder.order);
+                                }
+                                response.err = CustomError(ERROR.STP_TRIGGERED);
+                                return response;
+                            }
+                        }
+                    }
+                    if (response.quantityLeft < headOrder.size) {
+                        const partial = OrderFactory.createOrder({
+                            ...headOrder.toObject(),
+                            size: headOrder.size - response.quantityLeft,
+                        });
+                        response.partial = partial.toObject();
+                        this.orders[headOrder.id] = partial;
+                        response.partialQuantityProcessed = response.quantityLeft;
+                        orderQueue.update(headOrder, partial);
+                        response.quantityLeft = 0;
+                    }
+                    else {
+                        response.quantityLeft = response.quantityLeft - headOrder.size;
+                        const canceledOrder = this._cancelOrder(headOrder.id, true);
+                        /* node:coverage ignore next - Unable to test when order is undefined */
+                        if (canceledOrder?.order !== undefined) {
+                            response.done.push(canceledOrder.order);
+                        }
+                    }
+                    // Remove linked OCO Stop Order if any
+                    if (headOrder.ocoStopPrice !== undefined) {
+                        this.stopBook.remove(headOrder.side, headOrder.id, headOrder.ocoStopPrice);
+                    }
+                    this._marketPrice = headOrder.price;
+                }
+            }
+        }
+        return response;
+    };
+    /**
+     * Tells whether a self-trade check is required for this order, which is also the
+     * point past which level volumes stop being enough and orders must be walked
+     * individually.
+     *
+     * The conditions mirror the guard in `processQueue`, and the two must stay
+     * equivalent: if this reports a check where the matcher would not, a FOK order
+     * gets rejected as not fillable while the same order would otherwise have
+     * matched.
+     */
+    shouldCheckSelfTrade = (takerAccountId, stpMode) => {
+        return (Boolean(takerAccountId) &&
+            stpMode != null &&
+            stpMode !== SelfTradePreventionMode.NONE);
+    };
+    /**
+     * Decides whether a FOK order can be filled in full, before the book is touched.
+     *
+     * Liquidity is walked in the same order the matcher consumes it, and a maker
+     * belonging to the taker's own account is not tradeable when STP is active.
+     * The three modes differ in how they stop the walk:
+     * EXPIRE_MAKER expires the maker and matching continues past it, while
+     * EXPIRE_TAKER and EXPIRE_BOTH stop the taker there, leaving no liquidity
+     * beyond that maker reachable.
+     *
+     * Only the STP-active path has to inspect individual orders. Without STP there
+     * is nothing to rule out, so level volumes are exact and the walk stays one
+     * step per price level.
+     *
+     * @param isLevelReachable - tells whether a level is within the taker's price.
+     * @returns true when `size` can be filled in full.
+     */
+    canFillOrder = (orderSide, isLevelReachable, size, takerAccountId, stpMode) => {
+        // Necessary condition, so it is safe to reject on regardless of STP.
+        if (orderSide.volume() < size) {
+            return false;
+        }
+        if (!this.shouldCheckSelfTrade(takerAccountId, stpMode)) {
+            let cumulativeSize = 0;
+            // biome-ignore lint/suspicious/useIterableCallbackReturn: the forEach of the priceTree must return true to break the loop
+            orderSide.priceTree().forEach((levelPrice, level) => {
+                if (isLevelReachable(levelPrice) && cumulativeSize < size) {
+                    cumulativeSize += level.volume();
+                }
+                else {
+                    return true; // break the loop
+                }
+            });
+            return cumulativeSize >= size;
+        }
+        // A same-account maker is not tradeable, so the walk has to inspect orders
+        // rather than just level volumes. The price tree is ordered best-price-first
+        // on both sides, which is the order the matcher consumes levels in. Snapshot
+        // the reachable levels rather than polling for the next one: this walk removes
+        // nothing, so polling would keep returning the level it is already on.
+        const levels = [];
+        orderSide.priceTree().forEach((levelPrice, level) => {
+            if (isLevelReachable(levelPrice)) {
+                levels.push(level);
+            }
+        });
+        let quantityLeft = size;
+        for (const level of levels) {
+            for (const order of level.toArray()) {
+                // `shouldCheckSelfTrade` above already guarantees takerAccountId is a
+                // non-empty string, so this cannot match an order that has no
+                // accountId, nor a second order with an empty one.
+                if (order.accountId === takerAccountId) {
+                    if (stpMode !== SelfTradePreventionMode.EXPIRE_MAKER) {
+                        // EXPIRE_TAKER / EXPIRE_BOTH stop the taker here, so no
+                        // liquidity beyond this maker is reachable. STP is guaranteed
+                        // active in this branch, so every other mode aborts.
+                        return false;
+                    }
+                    // EXPIRE_MAKER expires the maker, so it offers no tradeable size
+                    // and the walk continues past it.
+                    continue;
+                }
+                if (quantityLeft <= order.size) {
+                    // The taker completes here, so an STP maker further down the queue
+                    // is never reached, exactly as in `processQueue`.
+                    return true;
+                }
+                quantityLeft -= order.size;
+            }
+        }
+        return false;
+    };
+    validateMarketOrder = (order) => {
+        const response = this.getProcessOrderResponse(order.size);
+        if (![Side.SELL, Side.BUY].includes(order.side)) {
+            response.err = CustomError(ERROR.INVALID_SIDE);
+            return response;
+        }
+        if (typeof order.size !== "number" || order.size <= 0) {
+            response.err = CustomError(ERROR.INSUFFICIENT_QUANTITY);
+            return response;
+        }
+        return response;
+    };
+    validateLimitOrder = (options) => {
+        const response = this.getProcessOrderResponse(options.size);
+        if (![Side.SELL, Side.BUY].includes(options.side)) {
+            response.err = CustomError(ERROR.INVALID_SIDE);
+            return response;
+        }
+        if (this.orders[options.id] !== undefined) {
+            response.err = CustomError(ERROR.ORDER_ALREDY_EXISTS);
+            return response;
+        }
+        if (typeof options.size !== "number" || options.size <= 0) {
+            response.err = CustomError(ERROR.INVALID_QUANTITY);
+            return response;
+        }
+        if (typeof options.price !== "number" || options.price <= 0) {
+            response.err = CustomError(ERROR.INVALID_PRICE);
+            return response;
+        }
+        if (options.timeInForce &&
+            !validTimeInForce.includes(options.timeInForce)) {
+            response.err = CustomError(ERROR.INVALID_TIF);
+            return response;
+        }
+        return response;
     };
-    return OrderBook;
-}());
-export { OrderBook };
+}