From 3db78a4e375ddeb85b9b36d3610b97607811d8a3 Mon Sep 17 00:00:00 2001 From: Peyman Date: Mon, 17 Jan 2022 15:15:40 +0330 Subject: [PATCH] close #175: Fix matching-engine's trade counter --- .../opex/matching/engine/app/bl/OrderBooks.kt | 3 +- .../engine/core/engine/SimpleOrderBook.kt | 143 +++++++----------- .../opex/matching/engine/core/model/Bucket.kt | 3 + .../engine/core/model/PersistentOrderBook.kt | 1 + .../matching/engine/core/model/SimpleOrder.kt | 39 +++++ .../core/engine/SimpleOrderBookUnitTest.kt | 81 +++++----- 6 files changed, 141 insertions(+), 129 deletions(-) create mode 100644 matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/Bucket.kt create mode 100644 matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/SimpleOrder.kt diff --git a/matching-engine/matching-engine-app/src/main/kotlin/co/nilin/opex/matching/engine/app/bl/OrderBooks.kt b/matching-engine/matching-engine-app/src/main/kotlin/co/nilin/opex/matching/engine/app/bl/OrderBooks.kt index 45be41247..e80b7a5dd 100644 --- a/matching-engine/matching-engine-app/src/main/kotlin/co/nilin/opex/matching/engine/app/bl/OrderBooks.kt +++ b/matching-engine/matching-engine-app/src/main/kotlin/co/nilin/opex/matching/engine/app/bl/OrderBooks.kt @@ -3,6 +3,7 @@ package co.nilin.opex.matching.engine.app.bl import co.nilin.opex.matching.engine.core.factory.OrderBookFactory import co.nilin.opex.matching.engine.core.model.OrderBook import co.nilin.opex.matching.engine.core.model.PersistentOrderBook +import co.nilin.opex.matching.engine.core.model.Pair object OrderBooks { private val orderBooks = mutableMapOf() @@ -12,7 +13,7 @@ object OrderBooks { if (orderBooks.containsKey(pair)) throw IllegalArgumentException("${pair} has an order book right now!") val pairs = pair.split("_") - orderBooks[pair] = OrderBookFactory.createOrderBook(co.nilin.opex.matching.engine.core.model.Pair(pairs[0], pairs[1])) + orderBooks[pair] = OrderBookFactory.createOrderBook(Pair(pairs[0], pairs[1])) println("order book:" + pair + " added, current order books#" + orderBooks.size) } diff --git a/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/engine/SimpleOrderBook.kt b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/engine/SimpleOrderBook.kt index c11e22e76..7b01bac7b 100644 --- a/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/engine/SimpleOrderBook.kt +++ b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/engine/SimpleOrderBook.kt @@ -11,66 +11,22 @@ import java.util.concurrent.atomic.AtomicLong class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { - private val logger = LoggerFactory.getLogger(co.nilin.opex.matching.engine.core.engine.SimpleOrderBook::class.java) + private val logger = LoggerFactory.getLogger(SimpleOrderBook::class.java) - val askOrders = LongAdaptiveRadixTreeMap() - val bidOrders = LongAdaptiveRadixTreeMap() - val orders = TreeMap() + val askOrders = LongAdaptiveRadixTreeMap() + val bidOrders = LongAdaptiveRadixTreeMap() + val orders = TreeMap() - var bestAskOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? = null - var bestBidOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? = null + var bestAskOrder: SimpleOrder? = null + var bestBidOrder: SimpleOrder? = null val orderCounter = AtomicLong() val tradeCounter = AtomicLong() - var lastOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? = null - - data class SimpleOrder( - var id: Long?, - val ouid: String, - val uuid: String, - val price: Long, - val quantity: Long, - val matchConstraint: MatchConstraint, - val orderType: OrderType, - val direction: OrderDirection, - var filledQuantity: Long, - var worse: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?, - var better: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?, - var bucket: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.Bucket? - ) : Order { - fun remainedQuantity() = quantity - filledQuantity - override fun id(): Long? = id - override fun toString(): String { - return "SimpleOrder(id=$id, price=$price, quantity=$quantity, matchConstraint=$matchConstraint, orderType=$orderType, filledQuantity=$filledQuantity, worse=${worse?.id}, better=${better?.id}, bucket=${bucket?.totalQuantity})" - } - - override fun persistent(): PersistentOrder { - return PersistentOrder( - id!!, - ouid, - uuid, - price, - quantity, - matchConstraint, - orderType, - direction, - filledQuantity - ) - } - } - - data class Bucket(val price: Long, var totalQuantity: Long, var ordersCount: Long, var lastOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder) + var lastOrder: SimpleOrder? = null override fun handleNewOrderCommand(orderCommand: OrderCreateCommand): Order? { - logger.info("****************** new order received *******************") - logger.info("** order id: ${orderCommand.ouid}") - logger.info("** price: ${orderCommand.price}") - logger.info("** quantity: ${orderCommand.quantity}") - logger.info("** direction: ${orderCommand.direction}") - logger.info("*********************************************************") - println() - + logNewOrder(orderCommand) val order = when (orderCommand.matchConstraint) { MatchConstraint.GTC -> { if (orderCommand.orderType == OrderType.MARKET_ORDER) { @@ -92,7 +48,7 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { } return null } - val order = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder( + val order = SimpleOrder( orderCounter.incrementAndGet(), orderCommand.ouid, orderCommand.uuid, @@ -131,7 +87,7 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { queueOrder } MatchConstraint.IOC -> { - val order = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder( + val order = SimpleOrder( orderCounter.incrementAndGet(), orderCommand.ouid, orderCommand.uuid, @@ -230,11 +186,11 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { } if (order.direction == OrderDirection.BID) { - handleCancelOrder(order, bidOrders, bestBidOrder) { newBestOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + handleCancelOrder(order, bidOrders, bestBidOrder) { newBestOrder: SimpleOrder? -> bestBidOrder = newBestOrder } } else { - handleCancelOrder(order, askOrders, bestAskOrder) { newBestOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + handleCancelOrder(order, askOrders, bestAskOrder) { newBestOrder: SimpleOrder? -> bestAskOrder = newBestOrder } } @@ -271,15 +227,15 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { return order } if (order.direction == OrderDirection.BID) { - handleCancelOrder(order, bidOrders, bestBidOrder) { newBestOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + handleCancelOrder(order, bidOrders, bestBidOrder) { newBestOrder: SimpleOrder? -> bestBidOrder = newBestOrder } } else { - handleCancelOrder(order, askOrders, bestAskOrder) { newBestOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + handleCancelOrder(order, askOrders, bestAskOrder) { newBestOrder: SimpleOrder? -> bestAskOrder = newBestOrder } } - val newOrder = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder( + val newOrder = SimpleOrder( order.id, orderCommand.ouid, orderCommand.uuid, @@ -382,10 +338,10 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { } private fun handleCancelOrder( - order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder, - bucketQueue: LongAdaptiveRadixTreeMap, - bestOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?, - setBestOrder: (co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?) -> Unit + order: SimpleOrder, + bucketQueue: LongAdaptiveRadixTreeMap, + bestOrder: SimpleOrder?, + setBestOrder: (SimpleOrder?) -> Unit ) { val bucket = order.bucket!! bucket.ordersCount-- @@ -402,62 +358,62 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { setBestOrder(bestOrder.worse) } - private fun matchInstantly(order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder): co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder { + private fun matchInstantly(order: SimpleOrder): SimpleOrder { if (order.direction == OrderDirection.BID) { return matchInstantly(order, bestAskOrder, askOrders, { makerPrice: Long -> makerPrice <= order.price - }) { newMakerOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + }) { newMakerOrder: SimpleOrder? -> bestAskOrder = newMakerOrder } } else { return matchInstantly(order, bestBidOrder, bidOrders, { makerPrice: Long -> makerPrice >= order.price - }) { newMakerOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + }) { newMakerOrder: SimpleOrder? -> bestBidOrder = newMakerOrder } } } - private fun matchIocInstantly(order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder): co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder { + private fun matchIocInstantly(order: SimpleOrder): SimpleOrder { if (order.direction == OrderDirection.BID) { return matchInstantly(order, bestAskOrder, askOrders, { makerPrice: Long -> order.orderType == OrderType.MARKET_ORDER || makerPrice <= order.price - }) { newMakerOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + }) { newMakerOrder: SimpleOrder? -> bestAskOrder = newMakerOrder } } else { return matchInstantly(order, bestBidOrder, bidOrders, { makerPrice: Long -> order.orderType == OrderType.MARKET_ORDER || makerPrice >= order.price - }) { newMakerOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + }) { newMakerOrder: SimpleOrder? -> bestBidOrder = newMakerOrder } } } - private fun putGtcInQueue(order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder): co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder { + private fun putGtcInQueue(order: SimpleOrder): SimpleOrder { if (order.direction == OrderDirection.BID) { return putGtcInQueue(order, bidOrders, bestBidOrder, { price, queue -> queue.getHigherValue(price) - }) { newMakerOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + }) { newMakerOrder: SimpleOrder? -> bestBidOrder = newMakerOrder } } else { return putGtcInQueue(order, askOrders, bestAskOrder, { price, queue -> queue.getLowerValue(price) - }) { newMakerOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder? -> + }) { newMakerOrder: SimpleOrder? -> bestAskOrder = newMakerOrder } } } private fun matchInstantly( - order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder, - makerOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?, - queue: LongAdaptiveRadixTreeMap, + order: SimpleOrder, + makerOrder: SimpleOrder?, + queue: LongAdaptiveRadixTreeMap, isPriceMatched: (makerPrice: Long) -> Boolean, - setNewMarkerOrder: (co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?) -> Unit - ): co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder { + setNewMarkerOrder: (SimpleOrder?) -> Unit + ): SimpleOrder { //the best sell price is higher the requested buy price, so no instant match if (makerOrder == null || !isPriceMatched(makerOrder.price)) { return order @@ -519,14 +475,13 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { } - private fun putGtcInQueue( - order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder, - queue: LongAdaptiveRadixTreeMap, - bestOrder: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?, - betterBucketSelector: (price: Long, queue: LongAdaptiveRadixTreeMap) -> co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.Bucket?, - setNewMarkerOrder: (co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder?) -> Unit - ): co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder { + order: SimpleOrder, + queue: LongAdaptiveRadixTreeMap, + bestOrder: SimpleOrder?, + betterBucketSelector: (price: Long, queue: LongAdaptiveRadixTreeMap) -> Bucket?, + setNewMarkerOrder: (SimpleOrder?) -> Unit + ): SimpleOrder { if (order.id == null) order.id = orderCounter.incrementAndGet() orders[order.id!!] = order @@ -545,7 +500,7 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { order.better = bucketLastOrder order.worse = worseOfBucketLastOrder } else { - bucket = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.Bucket( + bucket = Bucket( order.price, order.remainedQuantity(), 1, @@ -592,14 +547,14 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { private fun persistent(): PersistentOrderBook { val persistent = PersistentOrderBook(pair) persistent.lastOrder = lastOrder?.persistent() - persistent.orders = orders.values - .map { order -> order.persistent() } + persistent.orders = orders.values.map { order -> order.persistent() } + persistent.tradeCounter = tradeCounter.get() return persistent } fun rebuild(persistentOrderBook: PersistentOrderBook) { persistentOrderBook.orders?.map { order -> - co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder( + SimpleOrder( order.id, order.ouid, order.uuid, @@ -616,7 +571,19 @@ class SimpleOrderBook(val pair: Pair, var replayMode: Boolean) : OrderBook { }?.filter { order -> order.matchConstraint == MatchConstraint.GTC }?.forEach { order -> putGtcInQueue(order) } + orderCounter.set(persistentOrderBook.lastOrder?.id ?: 0) + tradeCounter.set(persistentOrderBook.tradeCounter) + } + + private fun logNewOrder(orderCommand: OrderCreateCommand) { + logger.info("****************** new order received *******************") + logger.info("** order id: ${orderCommand.ouid}") + logger.info("** price: ${orderCommand.price}") + logger.info("** quantity: ${orderCommand.quantity}") + logger.info("** direction: ${orderCommand.direction}") + logger.info("*********************************************************") + println() } private fun logCurrentState() { diff --git a/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/Bucket.kt b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/Bucket.kt new file mode 100644 index 000000000..90e6144b2 --- /dev/null +++ b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/Bucket.kt @@ -0,0 +1,3 @@ +package co.nilin.opex.matching.engine.core.model + +data class Bucket(val price: Long, var totalQuantity: Long, var ordersCount: Long, var lastOrder: SimpleOrder) \ No newline at end of file diff --git a/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/PersistentOrderBook.kt b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/PersistentOrderBook.kt index 4807125d6..49a7758be 100644 --- a/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/PersistentOrderBook.kt +++ b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/PersistentOrderBook.kt @@ -5,6 +5,7 @@ class PersistentOrderBook { lateinit var pair: Pair var lastOrder: PersistentOrder? = null var orders: List? = emptyList() + var tradeCounter: Long = 0 constructor() { } diff --git a/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/SimpleOrder.kt b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/SimpleOrder.kt new file mode 100644 index 000000000..24f52b819 --- /dev/null +++ b/matching-engine/matching-engine-core/src/main/kotlin/co/nilin/opex/matching/engine/core/model/SimpleOrder.kt @@ -0,0 +1,39 @@ +package co.nilin.opex.matching.engine.core.model + +data class SimpleOrder( + var id: Long?, + val ouid: String, + val uuid: String, + val price: Long, + val quantity: Long, + val matchConstraint: MatchConstraint, + val orderType: OrderType, + val direction: OrderDirection, + var filledQuantity: Long, + var worse: SimpleOrder?, + var better: SimpleOrder?, + var bucket: Bucket? +) : Order { + + fun remainedQuantity() = quantity - filledQuantity + + override fun id(): Long? = id + + override fun toString(): String { + return "SimpleOrder(id=$id, price=$price, quantity=$quantity, matchConstraint=$matchConstraint, orderType=$orderType, filledQuantity=$filledQuantity, worse=${worse?.id}, better=${better?.id}, bucket=${bucket?.totalQuantity})" + } + + override fun persistent(): PersistentOrder { + return PersistentOrder( + id!!, + ouid, + uuid, + price, + quantity, + matchConstraint, + orderType, + direction, + filledQuantity + ) + } +} \ No newline at end of file diff --git a/matching-engine/matching-engine-core/src/test/kotlin/co/nilin/opex/matching/core/engine/SimpleOrderBookUnitTest.kt b/matching-engine/matching-engine-core/src/test/kotlin/co/nilin/opex/matching/core/engine/SimpleOrderBookUnitTest.kt index 8cdbcf9a4..c037b9438 100644 --- a/matching-engine/matching-engine-core/src/test/kotlin/co/nilin/opex/matching/core/engine/SimpleOrderBookUnitTest.kt +++ b/matching-engine/matching-engine-core/src/test/kotlin/co/nilin/opex/matching/core/engine/SimpleOrderBookUnitTest.kt @@ -6,6 +6,7 @@ import co.nilin.opex.matching.engine.core.inout.OrderEditCommand import co.nilin.opex.matching.engine.core.model.MatchConstraint import co.nilin.opex.matching.engine.core.model.OrderDirection import co.nilin.opex.matching.engine.core.model.OrderType +import co.nilin.opex.matching.engine.core.model.SimpleOrder import kotlinx.coroutines.Dispatchers import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.Test @@ -19,7 +20,7 @@ class SimpleOrderBookUnitTest { @Test fun givenEmptyOrderBook_whenGtcBidLimitOrderCreated_then1BucketWithSize1() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) //when val order = orderBook.handleNewOrderCommand( OrderCreateCommand( @@ -42,7 +43,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidOrders_whenGtcBidLimitOrderWithSamePriceCreated_then() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -57,7 +58,7 @@ class SimpleOrderBookUnitTest { ) val bestBidOrder = orderBook.bestBidOrder //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = + val order: SimpleOrder = orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -69,7 +70,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 1) Assertions.assertEquals(orderBook.bestBidOrder, bestBidOrder) @@ -83,7 +84,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidOrders_whenGtcBidLimitOrderWithLowerPriceCreated_thenBestOrderNotChange() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -98,7 +99,7 @@ class SimpleOrderBookUnitTest { ) val bestBidOrder = orderBook.bestBidOrder //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = + val order: SimpleOrder = orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -110,7 +111,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 2) Assertions.assertEquals(orderBook.bestBidOrder, bestBidOrder) @@ -124,7 +125,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidOrders_whenGtcBidLimitOrderWithHigherPriceCreated_thenBestOrderChanged() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -139,7 +140,7 @@ class SimpleOrderBookUnitTest { ) val bestBidOrder = orderBook.bestBidOrder //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = + val order: SimpleOrder = orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -151,7 +152,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 2) Assertions.assertEquals(orderBook.bestBidOrder, order) @@ -165,7 +166,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidOrders_whenGtcAskLimitOrderWithSamePriceCreated_thenInstantMatch() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -190,7 +191,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 0) Assertions.assertEquals(orderBook.askOrders.entriesList().size, 0) @@ -201,7 +202,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidOrders_whenGtcAskLimitOrderWithNotMatchPriceCreated_thenAddToQueue() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -227,7 +228,7 @@ class SimpleOrderBookUnitTest { ) ) //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = + val order: SimpleOrder = orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -239,7 +240,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 2) Assertions.assertEquals(orderBook.askOrders.entriesList().size, 1) @@ -250,7 +251,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidAndAskOrders_whenGtcAskLimitOrderWithMatchPriceGreaterQuantityCreated_thenAddToQueue() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -288,7 +289,7 @@ class SimpleOrderBookUnitTest { ) ) //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = + val order: SimpleOrder = orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -300,7 +301,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 0) Assertions.assertEquals(orderBook.askOrders.entriesList().size, 2) @@ -311,7 +312,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBook_whenCancelBestBidOrder_thenBestBidOrderChange() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) val firstOrderId = UUID.randomUUID().toString() val secondOrderId = UUID.randomUUID().toString() @@ -349,7 +350,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithMoreBids_whenCancelBestBidOrder_thenBestBidOrderChange() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) val firstOrderId = UUID.randomUUID().toString() val secondOrderId = UUID.randomUUID().toString() @@ -399,7 +400,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithMoreBids_whenCancelABidOrder_thenBestBidOrderNotChange() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) val firstOrderId = UUID.randomUUID().toString() val secondOrderId = UUID.randomUUID().toString() @@ -450,7 +451,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithMoreBids_whenEditABidOrder_thenBestBidOrderChange() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -507,7 +508,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidAndAskOrders_whenEditABidOrder_thenRefill() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -545,7 +546,7 @@ class SimpleOrderBookUnitTest { ) ) //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = orderBook.handleEditCommand( + val order: SimpleOrder = orderBook.handleEditCommand( OrderEditCommand( UUID.randomUUID().toString(), uuid, @@ -554,7 +555,7 @@ class SimpleOrderBookUnitTest { 3, 3 ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(2, orderBook.bidOrders.entriesList().size) Assertions.assertEquals(0, orderBook.askOrders.entriesList().size) @@ -565,7 +566,7 @@ class SimpleOrderBookUnitTest { @Test fun givenEmptyOrderBook_whenGtcBidMarketOrderCreated_thenRejected() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) //when val order = orderBook.handleNewOrderCommand( @@ -589,7 +590,7 @@ class SimpleOrderBookUnitTest { @Test fun givenEmptyOrderBook_whenIocBidMarketOrderCreated_thenNoOrderCreated() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) //when val order = orderBook.handleNewOrderCommand( @@ -613,7 +614,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidAndAskOrders_whenIocAskMarketOrderWithGreaterQuantityCreated_thenPartiallyFilled() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -652,7 +653,7 @@ class SimpleOrderBookUnitTest { ) val bestAskOrder = orderBook.bestAskOrder //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = + val order: SimpleOrder = orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -664,7 +665,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.IOC, OrderType.MARKET_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(2, order.filledQuantity) Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 0) @@ -676,7 +677,7 @@ class SimpleOrderBookUnitTest { @Test fun givenOrderBookWithBidAndAskOrders_whenIocAskLimitOrderWithHigherPriceAndGreaterQuantityCreated_thenNotFilled() { //given - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(pair, false) + val orderBook = SimpleOrderBook(pair, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -716,7 +717,7 @@ class SimpleOrderBookUnitTest { val bestAskOrder = orderBook.bestAskOrder val bestBidOrder = orderBook.bestBidOrder //when - val order: co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder = + val order: SimpleOrder = orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -728,7 +729,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.IOC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder //then Assertions.assertEquals(0, order.filledQuantity) Assertions.assertEquals(orderBook.bidOrders.entriesList().size, 2) @@ -740,7 +741,7 @@ class SimpleOrderBookUnitTest { @Test fun whenSample1SequenceOfOrdersOccurs_thenAllSuccess() { - val orderBook = co.nilin.opex.matching.engine.core.engine.SimpleOrderBook(ETH_BTC_PAIR, false) + val orderBook = SimpleOrderBook(ETH_BTC_PAIR, false) orderBook.handleNewOrderCommand( OrderCreateCommand( UUID.randomUUID().toString(), @@ -752,7 +753,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder Assertions.assertNotNull(orderBook.bestBidOrder) Assertions.assertEquals(1, orderBook.bidOrders.entriesList().size) Assertions.assertEquals(1, orderBook.orders.size) @@ -768,7 +769,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder Assertions.assertNull(orderBook.bestBidOrder) Assertions.assertNotNull(orderBook.bestAskOrder) Assertions.assertEquals(0, orderBook.bidOrders.entriesList().size) @@ -786,7 +787,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder Assertions.assertNull(orderBook.bestBidOrder) Assertions.assertNotNull(orderBook.bestAskOrder) Assertions.assertEquals(0, orderBook.bidOrders.entriesList().size) @@ -804,7 +805,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder Assertions.assertEquals(1, orderBook.bidOrders.entriesList().size) Assertions.assertEquals(1, orderBook.askOrders.entriesList().size) Assertions.assertEquals(2, orderBook.orders.size) @@ -822,7 +823,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder Assertions.assertEquals(1, orderBook.bidOrders.entriesList().size) Assertions.assertEquals(2, orderBook.askOrders.entriesList().size) Assertions.assertEquals(3, orderBook.orders.size) @@ -840,7 +841,7 @@ class SimpleOrderBookUnitTest { MatchConstraint.GTC, OrderType.LIMIT_ORDER ) - ) as co.nilin.opex.matching.engine.core.engine.SimpleOrderBook.SimpleOrder + ) as SimpleOrder Assertions.assertEquals(2, orderBook.bidOrders.entriesList().size) Assertions.assertEquals(2, orderBook.askOrders.entriesList().size) Assertions.assertEquals(4, orderBook.orders.size)