Merge pull request #267 from fasenderos/bignumber

feat: use bignumber.js for size precision

Author: fasenderos

package-lock.json

@@ -41,6 +41,7 @@
     "prepare": "husky install"
   },
   "dependencies": {
+    "bignumber.js": "^9.1.1",
     "denque": "2.1.0",
     "functional-red-black-tree": "1.0.1"
   },

package.json

@@ -1,3 +1,4 @@
+import BigNumber from 'bignumber.js'
 import { Side } from './side'
 
 export interface OrderUpdate {
@@ -20,14 +21,14 @@ export enum TimeInForce {
 export class Order {
   private readonly _id: string
   private readonly _side: Side
-  private _size: number
+  private _size: BigNumber
   private readonly _price: number
   private _time: number
   private readonly _isMaker: boolean
   constructor (
     orderId: string,
     side: Side,
-    size: number,
+    size: BigNumber,
     price: number,
     time?: number,
     isMaker?: boolean
@@ -56,11 +57,11 @@ export class Order {
   }
 
   // returns size of the order
-  get size (): number {
+  get size (): BigNumber {
     return this._size
   }
 
-  set size (size: number) {
+  set size (size: BigNumber) {
     this._size = size
   }
 
@@ -81,7 +82,7 @@ export class Order {
   toString = (): string => {
     return `${this._id}:
     side: ${this._side}
-    size: ${this._side}
+    size: ${this._size.toNumber() as unknown as string}
     price: ${this._price}
     time: ${this._time}
     isMaker: ${this.isMaker as unknown as string}`
@@ -92,7 +93,7 @@ export class Order {
     return JSON.stringify({
       id: this._id,
       side: this._side,
-      size: this._size,
+      size: this._size.toNumber(),
       price: this._price,
       time: this._time,
       isMaker: this.isMaker
@@ -111,7 +112,7 @@ export class Order {
     return {
       id: this._id,
       side: this._side,
-      size: this._size,
+      size: this._size.toNumber(),
       price: this._price,
       time: this._time,
       isMaker: this.isMaker

src/order.ts

@@ -1,3 +1,4 @@
+import BigNumber from 'bignumber.js'
 import { ERROR, CustomError } from './errors'
 import { Order, OrderType, OrderUpdate, TimeInForce } from './order'
 import { OrderQueue } from './orderqueue'
@@ -225,7 +226,7 @@ export class OrderBook {
       const order = new Order(
         orderID,
         side,
-        quantityToTrade,
+        new BigNumber(quantityToTrade),
         price,
         Date.now(),
         true
@@ -240,8 +241,9 @@ export class OrderBook {
       let totalPrice = 0
 
       response.done.forEach((order: Order) => {
-        totalQuantity += order.size
-        totalPrice += order.price * order.size
+        const ordrSize: number = order.size.toNumber()
+        totalQuantity += ordrSize
+        totalPrice += order.price * ordrSize
       })
       if (response.partialQuantityProcessed > 0 && response.partial !== null) {
         totalQuantity += response.partialQuantityProcessed
@@ -250,7 +252,7 @@ export class OrderBook {
       }
 
       response.done.push(
-        new Order(orderID, side, size, totalPrice / totalQuantity, Date.now())
+        new Order(orderID, side, new BigNumber(size), totalPrice / totalQuantity, Date.now())
       )
     }
 
@@ -317,10 +319,10 @@ export class OrderBook {
     const asks: Array<[number, number]> = []
     const bids: Array<[number, number]> = []
     this.asks.priceTree().forEach((levelPrice, level) => {
-      asks.push([levelPrice, level.volume()])
+      asks.push([levelPrice, level.volume().toNumber()])
     })
     this.bids.priceTree().forEach((levelPrice, level) => {
-      bids.push([levelPrice, level.volume()])
+      bids.push([levelPrice, level.volume().toNumber()])
     })
     return [asks, bids]
   }
@@ -356,7 +358,7 @@ export class OrderBook {
     }
 
     while (size > 0 && level !== undefined) {
-      const levelVolume = level.volume()
+      const levelVolume = level.volume().toNumber()
       const levelPrice = level.price()
       if (this.greaterThanOrEqual(size, levelVolume)) {
         price += levelPrice * levelVolume
@@ -398,11 +400,12 @@ export class OrderBook {
       while (orderQueue.len() > 0 && response.quantityLeft > 0) {
         const headOrder = orderQueue.head()
         if (headOrder !== undefined) {
-          if (response.quantityLeft < headOrder.size) {
+          const headSize = headOrder.size.toNumber()
+          if (response.quantityLeft < headSize) {
             response.partial = new Order(
               headOrder.id,
               headOrder.side,
-              headOrder.size - response.quantityLeft,
+              new BigNumber(headSize - response.quantityLeft),
               headOrder.price,
               headOrder.time,
               true
@@ -412,7 +415,7 @@ export class OrderBook {
             orderQueue.update(headOrder, response.partial)
             response.quantityLeft = 0
           } else {
-            response.quantityLeft = response.quantityLeft - headOrder.size
+            response.quantityLeft = response.quantityLeft - headSize
             const canceledOrder = this.cancel(headOrder.id)
             if (canceledOrder !== undefined) response.done.push(canceledOrder)
           }
@@ -438,14 +441,16 @@ export class OrderBook {
     size: number,
     price: number
   ): boolean => {
-    if (orderSide.volume() < size) {
+    const insufficientSideVolume: boolean = orderSide.volume().lt(size)
+    if (insufficientSideVolume) {
       return false
     }
 
     let cumulativeSize = 0
     orderSide.priceTree().forEach((_key, priceLevel) => {
       if (price >= priceLevel.price() && cumulativeSize < size) {
-        cumulativeSize += priceLevel.volume()
+        const volume: number = priceLevel.volume().toNumber()
+        cumulativeSize += volume
       } else {
         return true // break the loop
       }
@@ -458,14 +463,16 @@ export class OrderBook {
     size: number,
     price: number
   ): boolean => {
-    if (orderSide.volume() < size) {
+    const insufficientSideVolume: boolean = orderSide.volume().lt(size)
+    if (insufficientSideVolume) {
       return false
     }
 
     let cumulativeSize = 0
     orderSide.priceTree().forEach((_key, priceLevel) => {
       if (price <= priceLevel.price() && cumulativeSize < size) {
-        cumulativeSize += priceLevel.volume()
+        const volume: number = priceLevel.volume().toNumber()
+        cumulativeSize += volume
       } else {
         return true // break the loop
       }

src/orderbook.ts

@@ -1,16 +1,17 @@
+import BigNumber from 'bignumber.js'
 import Denque from 'denque'
 import { Order } from './order'
 
 export class OrderQueue {
   private readonly _price: number
-  private _volume: number
+  private _volume: BigNumber
   private readonly _orders: Denque<Order>
   // { orderID: index } index in denque
   private _ordersMap: { [key: string]: number } = {}
 
   constructor (price: number) {
     this._price = price
-    this._volume = 0
+    this._volume = new BigNumber(0)
     this._orders = new Denque<Order>()
   }
 
@@ -29,7 +30,7 @@ export class OrderQueue {
   }
 
   // returns price level of the queue
-  volume = (): number => {
+  volume = (): BigNumber => {
     return this._volume
   }
 
@@ -45,16 +46,15 @@ export class OrderQueue {
 
   // adds order to tail of the queue
   append = (order: Order): Order => {
-    this._volume += order.size
+    this._volume = this._volume.plus(order.size)
     this._orders.push(order)
     this._ordersMap[order.id] = this._orders.length - 1
     return order
   }
 
   // sets up new order to list value
   update = (oldOrder: Order, newOrder: Order): void => {
-    this._volume -= oldOrder.size
-    this._volume += newOrder.size
+    this._volume = this._volume.minus(oldOrder.size).plus(newOrder.size)
     // Remove old order from head
     this._orders.shift()
     /* eslint-disable @typescript-eslint/no-dynamic-delete */
@@ -66,7 +66,7 @@ export class OrderQueue {
 
   // removes order from the queue
   remove = (order: Order): void => {
-    this._volume -= order.size
+    this._volume = this._volume.minus(order.size)
     const deletedOrderIndex = this._ordersMap[order.id]
     this._orders.removeOne(deletedOrderIndex)
     delete this._ordersMap[order.id]
@@ -80,8 +80,9 @@ export class OrderQueue {
     }
   }
 
-  updateOrderSize = (order: Order, newSize: number): void => {
-    this._volume += newSize - order.size // update volume
+  updateOrderSize = (order: Order, size: number): void => {
+    const newSize = new BigNumber(size)
+    this._volume = this._volume.plus(newSize.minus(order.size)) // update volume
     order.size = newSize
     order.time = Date.now()
   }

src/orderqueue.ts

@@ -1,3 +1,4 @@
+import BigNumber from 'bignumber.js'
 import createRBTree from 'functional-red-black-tree'
 import { CustomError, ERROR } from './errors'
 import { Order, OrderUpdate } from './order'
@@ -7,8 +8,8 @@ import { Side } from './side'
 export class OrderSide {
   private _priceTree: createRBTree.Tree<number, OrderQueue>
   private _prices: { [key: string]: OrderQueue } = {}
-  private _volume = 0
-  private _total = 0
+  private _volume = new BigNumber(0)
+  private _total = new BigNumber(0)
   private _numOrders = 0
   private _depthSide = 0
   private readonly _side: Side = Side.SELL
@@ -33,12 +34,12 @@ export class OrderSide {
   }
 
   // returns total amount of quantity in side
-  volume = (): number => {
+  volume = (): BigNumber => {
     return this._volume
   }
 
   // returns the total (size * price of each price level) in side
-  total = (): number => {
+  total = (): BigNumber => {
     return this._total
   }
 
@@ -58,8 +59,8 @@ export class OrderSide {
       this._depthSide += 1
     }
     this._numOrders += 1
-    this._volume += order.size
-    this._total += order.size * order.price
+    this._volume = this._volume.plus(order.size)
+    this._total = this._total.plus(order.size.multipliedBy(order.price))
     return this._prices[strPrice].append(order)
   }
 
@@ -77,8 +78,8 @@ export class OrderSide {
     }
 
     this._numOrders -= 1
-    this._volume -= order.size
-    this._total -= order.size * order.price
+    this._volume = this._volume.minus(order.size)
+    this._total = this._total.minus(order.size.multipliedBy(order.price))
     return order
   }
 
@@ -92,7 +93,7 @@ export class OrderSide {
       const newOrder = new Order(
         oldOrder.id,
         oldOrder.side,
-        orderUpdate.size ?? oldOrder.size,
+        orderUpdate.size !== undefined ? new BigNumber(orderUpdate.size) : oldOrder.size,
         orderUpdate.price,
         Date.now(),
         oldOrder.isMaker
@@ -101,13 +102,15 @@ export class OrderSide {
       return newOrder
     } else if (
       orderUpdate.size !== undefined &&
-      orderUpdate.size !== oldOrder.size
+      orderUpdate.size !== oldOrder.size.toNumber()
     ) {
       // Quantity changed. Price is the same.
+      const oldOrderSize: number = oldOrder.size.toNumber()
       const strPrice = oldOrder.price.toString()
-      this._volume += orderUpdate.size - oldOrder.size
-      this._total +=
-        orderUpdate.size * orderUpdate.price - oldOrder.size * oldOrder.price
+      this._volume = this._volume.plus(orderUpdate.size - oldOrderSize)
+      this._total = this._total.plus(
+        orderUpdate.size * orderUpdate.price - oldOrderSize * oldOrder.price
+      )
       this._prices[strPrice].updateOrderSize(oldOrder, orderUpdate.size)
       return oldOrder
     }
@@ -165,7 +168,8 @@ export class OrderSide {
     let s = ''
     let level = this.maxPriceQueue()
     while (level !== undefined) {
-      s += `\n${level.price()} -> ${level.volume()}`
+      const volume: string = level.volume().toString()
+      s += `\n${level.price()} -> ${volume}`
       level = this.lowerThan(level.price())
     }
     return s

src/orderside.ts

@@ -1,5 +1,5 @@
-import { CustomError, ERROR } from '../src/errors'
 import { test } from 'tap'
+import { CustomError, ERROR } from '../src/errors'
 
 void test('Test default CustomError', ({ equal, end }) => {
   const a = CustomError()