Esempio n. 1
0
        public void AddToOrderBook(OrderLeg orderLeg)
        {
            _exchangeBook.NotifyOrderAdded(orderLeg);
            WatchOrder watchOrder = new WatchOrder(orderLeg);

            AddOrderToWatchList(watchOrder);
        }
Esempio n. 2
0
 public void MarkOrderFilled(WatchOrder watchOrder)
 {
     // This will ultimately be replaced with logic calling into the repository
     //
     //Console.WriteLine("Order ID {0} Leg ID {1} is filled", watchOrder.orderLegRecord.OrderId, watchOrder.orderLegRecord.OrderLegId);
     watchOrder.orderLegRecord.OrderLegFillStatus = OrderLegFillStatusEnum.Full;
     _exchangeBook.NotifyOrderLegFilled(watchOrder.orderLegRecord);
 }
Esempio n. 3
0
        public void SaveFilledOrders(WatchOrder buyOrder, WatchOrder sellOrder, decimal AmountOffset, decimal OrderPrice)
        {
            OrderFilledData orderFilledDataRecord = new OrderFilledData();

            orderFilledDataRecord.OrderLegId   = buyOrder.orderLegRecord.OrderLegId;
            orderFilledDataRecord.Token1Amount = AmountOffset;
            orderFilledDataRecord.Token1Id     = buyOrder.orderLegRecord.Token1Id;
            orderFilledDataRecord.Token2Id     = buyOrder.orderLegRecord.Token2Id;
            orderFilledDataRecord.Token2Amount = AmountOffset * (buyOrder.orderLegRecord.OrderPriceTerms == OrderPriceTermsEnum.Token2PerToken1 ?
                                                                 OrderPrice : 1.0M / OrderPrice);
            orderFilledDataRecord.OrderPriceTerms = buyOrder.orderLegRecord.OrderPriceTerms;
            orderFilledDataRecord.FilledDateTime  = System.DateTime.Now;

            _exchangeBook.NotifyOrderLegMatched(buyOrder.orderLegRecord, orderFilledDataRecord);
            _exchangeBook.NotifyOrderLegMatched(sellOrder.orderLegRecord, orderFilledDataRecord);

            //Console.WriteLine("Updating Order Book for Order {0}/{1} offset amount {2} at price {3}", buyOrder.orderLegRecord.OrderId, sellOrder.orderLegRecord.OrderId, AmountOffset, OrderPrice);
        }
Esempio n. 4
0
        public void AddOrderToWatchList(WatchOrder watchRecord)
        {
            // Buy Limit Orders Descending Order
            if (watchRecord.orderLegRecord.OrderLegType == OrderLegTypeEnum.Limit)
            {
                if (watchRecord.orderLegRecord.BuySellType == OrderLegBuySellEnum.Buy)
                {
                    lock (LimitBuyLock)
                    {
                        LinkedListNode <WatchOrder> Node = LimitBuyOrders.First;

                        if (Node == null)
                        {
                            LimitBuyOrders.AddFirst(watchRecord);
                            UpdateOrderBookBid(watchRecord);
                        }
                        else
                        {
                            // Locate the Node with a price less than the current order
                            for (; (Node != null) && (Node.Value.orderLegRecord.OrderPrice >= watchRecord.orderLegRecord.OrderPrice); Node = Node.Next)
                            {
                                ;
                            }

                            // End of the road, so add to the end of the list
                            if (Node == null)
                            {
                                LimitBuyOrders.AddLast(watchRecord);
                            }
                            // Insertion Point
                            else
                            {
                                if (Node.Previous == null)
                                {
                                    UpdateOrderBookBid(watchRecord);
                                }

                                LimitBuyOrders.AddBefore(Node, watchRecord);
                            }
                        }
                    }

                    MatchLimitBuyWithSells();
                }
                else // Sell Limit Order Ascending Order
                {
                    lock (LimitSellLock)
                    {
                        LinkedListNode <WatchOrder> Node = LimitSellOrders.First;

                        if (Node == null)
                        {
                            LimitSellOrders.AddFirst(watchRecord);
                            UpdateOrderBookAsk(watchRecord);
                        }
                        else
                        {
                            // Locate the Node with a price less than the current order
                            for (; (Node != null) && (Node.Value.orderLegRecord.OrderPrice <= watchRecord.orderLegRecord.OrderPrice); Node = Node.Next)
                            {
                                ;
                            }

                            // End of the road, so add to the end of the list
                            if (Node == null)
                            {
                                LimitSellOrders.AddLast(watchRecord);
                            }
                            // Insertion Point
                            else
                            {
                                if (Node.Previous == null)
                                {
                                    UpdateOrderBookAsk(watchRecord);
                                }

                                LimitSellOrders.AddBefore(Node, watchRecord);
                            }
                        }
                    }

                    MatchLimitSellWithBuys();
                }
            }
            else if (watchRecord.orderLegRecord.OrderLegType == OrderLegTypeEnum.Stop)
            {
                if (watchRecord.BuySellType == OrderLegBuySellEnum.Buy)
                {
                    LinkedListNode <WatchOrder> Node = StopBuyOrders.First;


                    if (Node == null)
                    {
                        StopBuyOrders.AddFirst(watchRecord);
                    }
                    else
                    {
                        for (; (Node != null) && (Node.Value.OrderPrice <= watchRecord.OrderPrice); Node = Node.Next)
                        {
                            ;
                        }

                        // End of the road, so add to the end of the list
                        if (Node == null)
                        {
                            StopBuyOrders.AddLast(watchRecord);
                        }
                        // Insertion Point
                        else
                        {
                            StopBuyOrders.AddBefore(Node, watchRecord);
                        }
                    }
                }
                else
                {
                    LinkedListNode <WatchOrder> Node = StopSellOrders.First;

                    if (Node == null)
                    {
                        StopSellOrders.AddFirst(watchRecord);
                    }
                    else
                    {
                        // Locate the Node with a price less than the current order

                        for (; (Node != null) && (Node.Value.OrderPrice >= watchRecord.OrderPrice); Node = Node.Next)
                        {
                            ;
                        }

                        // End of the road, so add to the end of the list
                        if (Node == null)
                        {
                            StopSellOrders.AddLast(watchRecord);
                        }
                        // Insertion Point
                        else
                        {
                            StopSellOrders.AddBefore(Node, watchRecord);
                        }
                    }
                }
            }
            else if (watchRecord.orderLegRecord.OrderLegType == OrderLegTypeEnum.Market)
            {
                if (watchRecord.BuySellType == OrderLegBuySellEnum.Buy)
                {
                    lock (MarketBuyLock)
                    {
                        MarketBuyOrders.AddLast(watchRecord);

                        BuyMarketOrdersOutstanding += watchRecord.AmountOutstanding;
                    }


                    MatchMarketBuyWithSells();
                }
                else
                {
                    lock (MarketSellLock)
                    {
                        MarketSellOrders.AddLast(watchRecord);

                        SellMarketOrdersOutstanding += watchRecord.AmountOutstanding;
                    }

                    MatchMarketSellWithBuys();
                }
            }
            else
            {
                // Don't add it to the list
            }
        }
Esempio n. 5
0
 public void UpdateOrderBookAsk(WatchOrder OrderWatchRecord)
 {
     AskRate   = OrderWatchRecord.OrderPrice;
     AskAmount = OrderWatchRecord.AmountOutstanding;
 }
Esempio n. 6
0
 public void UpdateOrderBookBid(WatchOrder OrderWatchRecord)
 {
     BidRate   = OrderWatchRecord.OrderPrice;
     BidAmount = OrderWatchRecord.AmountOutstanding;
 }
Esempio n. 7
0
        public void OffsetBuySellOrders(WatchOrder buyOrder, WatchOrder sellOrder)
        {
            decimal AmountOffset = 0;
            decimal OrderPrice   = 0;

            if (buyOrder.AmountOutstanding > sellOrder.AmountOutstanding)
            {
                AmountOffset = sellOrder.AmountOutstanding;
            }
            else
            {
                AmountOffset = buyOrder.AmountOutstanding;
            }

            buyOrder.orderLegRecord.Token1AmountFilled  += AmountOffset;
            sellOrder.orderLegRecord.Token1AmountFilled += AmountOffset;

            if (buyOrder.orderLegRecord.OrderLegType == OrderLegTypeEnum.Market)
            {
                BuyMarketOrdersOutstanding -= AmountOffset;
            }

            if (sellOrder.orderLegRecord.OrderLegType == OrderLegTypeEnum.Market)
            {
                SellMarketOrdersOutstanding -= AmountOffset;
            }

            if (buyOrder.orderLegRecord.OrderLegType == OrderLegTypeEnum.Market)
            {
                if (sellOrder.orderLegRecord.OrderLegType == OrderLegTypeEnum.Market)
                {
                    // Market Price was established when orders were paired
                    OrderPrice = sellOrder.OrderPrice;
                }
                else
                {
                    // Order Price is the Limit Price on the Sell Order;
                    OrderPrice = sellOrder.OrderPrice;
                }
            }
            else if (buyOrder.orderLegRecord.OrderLegType == OrderLegTypeEnum.Limit)
            {
                if (sellOrder.orderLegRecord.OrderLegType == OrderLegTypeEnum.Market)
                {
                    OrderPrice = buyOrder.OrderPrice;
                }
                else
                {
                    OrderPrice = buyOrder.OrderPrice;
                }
            }
            else
            {
                throw new NotImplementedException("Order Type not Implemented");
            }

            // Update the Database to reflect
            // the changes to the Order Legs and the amounts filled for each order leg
            SaveFilledOrders(buyOrder, sellOrder, AmountOffset, OrderPrice);

            //Console.WriteLine("Matched Asset Pair {0}-{1} Order {2}/{3} - {4}/{5} for {6}", buyOrder.AssetID1, buyOrder.AssetID2, buyOrder.OrderLegID, buyOrder.OrderType.ToString(), sellOrder.OrderLegID, sellOrder.OrderType.ToString(), AmountOffset);
            //Console.WriteLine("Asset Pair {0}-{1} Outstanding Mkt Buy {2} / Mkt Sell {3}", buyOrder.AssetID1, buyOrder.AssetID2, BuyMarketOrdersOutstanding, SellMarketOrdersOutstanding);
            //Console.WriteLine("Buy  Order {0} Type {1} Outstanding {2}", buyOrder.orderLegRecord.OrderLegID, buyOrder.OrderType.ToString(), buyOrder.AmountOutstanding);
            //Console.WriteLine("Sell Order {0} Type {1} Outstanding {2}", sellOrder.orderLegRecord.OrderLegID, sellOrder.OrderType.ToString(), sellOrder.AmountOutstanding);
        }