perf: replace dbly-linked-list with denque

Author: andreafassina

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "hft-limit-order-book",
   "version": "0.0.2",
-  "description": "Ultra-fast Limit Order Book for high-frequency trading (HFT) for NodeJS.",
+  "description": "Node.js Lmit Order Book for high-frequency trading (HFT).",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "umd:main": "dist/umd/index.js",
@@ -56,7 +56,7 @@
     "url": "https://github.com/fasenderos/hft-limit-order-book/issues"
   },
   "dependencies": {
-    "dbly-linked-list": "0.3.5",
+    "denque": "2.1.0",
     "functional-red-black-tree": "1.0.1"
   },
   "devDependencies": {

package.json

@@ -205,28 +205,23 @@ export class OrderBook {
     }
     if (response.quantityLeft) {
       while (orderQueue.len() > 0 && response.quantityLeft > 0) {
-        const headOrderEl = orderQueue.head()
-        if (headOrderEl) {
-          const headOrder = headOrderEl.getData<Order>()
-          if (headOrder) {
-            if (response.quantityLeft < headOrder.size) {
-              response.partial = new Order(
-                headOrder.id,
-                headOrder.side,
-                headOrder.size - response.quantityLeft,
-                headOrder.price,
-                headOrder.time
-              )
+        const headOrder = orderQueue.head()
+        if (headOrder) {
+          if (response.quantityLeft < headOrder.size) {
+            response.partial = new Order(
+              headOrder.id,
+              headOrder.side,
+              headOrder.size - response.quantityLeft,
+              headOrder.price,
+              headOrder.time
+            )
 
-              response.partialQuantityProcessed = response.quantityLeft
-              orderQueue.update(headOrderEl, headOrder, response.partial)
-              response.quantityLeft = 0
-            } else {
-              response.quantityLeft = response.quantityLeft - headOrder.size
-              response.done = response.done.concat(
-                this.cancelOrder(headOrder.id)
-              )
-            }
+            response.partialQuantityProcessed = response.quantityLeft
+            orderQueue.update(headOrder, response.partial)
+            response.quantityLeft = 0
+          } else {
+            response.quantityLeft = response.quantityLeft - headOrder.size
+            response.done = response.done.concat(this.cancelOrder(headOrder.id))
           }
         }
       }

src/orderbook.ts

@@ -1,24 +1,24 @@
-import LinkedList, { Node, NodeData } from 'dbly-linked-list'
+import Denque from 'denque'
 import { Order } from './order'
 
 export class OrderQueue {
   private _price: number
   private _volume: number
-  private orders: LinkedList
+  private orders: Denque<Order>
   private ordersMap: { [key: string]: number } = {}
 
   constructor(price: number) {
     this._price = price
     this._volume = 0
-    this.orders = new LinkedList()
+    this.orders = new Denque<Order>()
   }
 
   // returns the number of orders in queue
   len = (): number => {
-    return this.orders.getSize()
+    return this.orders.length
   }
 
-  toArray = (): NodeData[] => {
+  toArray = (): Order[] => {
     return this.orders.toArray()
   }
 
@@ -33,34 +33,34 @@ export class OrderQueue {
   }
 
   // returns top order in queue
-  head = () => {
-    return this.orders.getHeadNode()
+  head = (): Order | undefined => {
+    return this.orders.peekFront()
   }
 
   // returns bottom order in queue
-  tail = () => {
-    return this.orders.getTailNode()
+  tail = (): Order | undefined => {
+    return this.orders.peekBack()
   }
 
   // adds order to tail of the queue
   append = (order: Order): Order => {
     this._volume += order.size
-    this.orders.insert(order)
-    this.ordersMap[order.id] = this.orders.getSize() - 1
+    this.orders.push(order)
+    this.ordersMap[order.id] = this.orders.length - 1
     return order
   }
 
   // sets up new order to list value
-  update = (node: Node, nodeData: Order, order: Order) => {
-    this._volume -= nodeData.size
-    this._volume += order.size
-    node.data = order
+  update = (oldOrder: Order, newOrder: Order) => {
+    this._volume -= oldOrder.size
+    this._volume += newOrder.size
+    oldOrder = newOrder
   }
 
   // removes order from the queue
   remove = (order: Order) => {
     this._volume -= order.size
-    this.orders.removeAt(this.ordersMap[order.id])
+    this.orders.removeOne(this.ordersMap[order.id])
     delete this.ordersMap[order.id]
   }
 }

src/orderqueue.ts

@@ -1,5 +1,4 @@
 import createRBTree from 'functional-red-black-tree'
-import { NodeData } from 'dbly-linked-list'
 import { Order } from './order'
 import { OrderQueue } from './orderqueue'
 
@@ -95,7 +94,7 @@ export class OrderSide {
 
   // returns all orders
   orders = () => {
-    let orders: NodeData[] = []
+    let orders: Order[] = []
     for (const price in this.prices) {
       if (Object.prototype.hasOwnProperty.call(this.prices, price)) {
         const allOrders = this.prices[price].toArray()