private bool IsUpdated(BinanceStreamOrderUpdate orderUpdate) { BinanceStreamOrderUpdate ou = m_order[orderUpdate.OrderId.ToString()]; //bool match = () return(true); }
public void SubscribingToOrderUpdateStream_Should_TriggerWhenOrderUpdateStreamMessageIsReceived() { // arrange var socket = new Mock <IWebsocket>(); socket.Setup(s => s.Close()); socket.Setup(s => s.Connect()); socket.Setup(s => s.Url).Returns("test"); socket.Setup(s => s.SetEnabledSslProtocols(It.IsAny <System.Security.Authentication.SslProtocols>())); var factory = new Mock <IWebsocketFactory>(); factory.Setup(s => s.CreateWebsocket(It.IsAny <string>())).Returns(socket.Object); BinanceStreamOrderUpdate result = null; var client = new BinanceSocketClient { SocketFactory = factory.Object }; client.SubscribeToOrderUpdateStream("test", (test) => result = test); var data = new BinanceStreamOrderUpdate() { Event = "executionReport", EventTime = new DateTime(2017, 1, 1), AccumulatedQuantityOfFilledTrades = 1.1, BuyerIsMaker = true, C = "", Commission = 2.2, CommissionAsset = "test", ExecutionType = ExecutionType.Trade, F = 3.3, g = 4.4, I = 100000000000, NewClientOrderId = "test", OrderId = 100000000000, P = 5.5, Price = 6.6, PriceLastFilledTrade = 7.7, Quantity = 8.8, QuantityOfLastFilledTrade = 9.9, RejectReason = OrderRejectReason.AccountCannotSettle, Side = OrderSide.Buy, Status = OrderStatus.Filled, Symbol = "test", Time = new DateTime(2017, 1, 1), TimeInForce = TimeInForce.GoodTillCancel, TradeId = 10000000000000, Type = OrderType.Limit }; // act socket.Raise(r => r.OnMessage += null, new MessagedEventArgs(JsonConvert.SerializeObject(data), false, false, true, new byte[2])); // assert Assert.IsNotNull(result); Assert.IsTrue(Compare.PublicInstancePropertiesEqual(data, result, "Balances")); }
public void SubscribingToUserStream_Should_TriggerWhenOrderUpdateStreamMessageIsReceived() { // arrange var socket = new Mock <IWebsocket>(); socket.Setup(s => s.Close()); socket.Setup(s => s.Connect()).Returns(Task.FromResult(true)); socket.Setup(s => s.SetEnabledSslProtocols(It.IsAny <System.Security.Authentication.SslProtocols>())); var factory = new Mock <IWebsocketFactory>(); factory.Setup(s => s.CreateWebsocket(It.IsAny <Log>(), It.IsAny <string>())).Returns(socket.Object); BinanceStreamOrderUpdate result = null; var client = new BinanceSocketClient { SocketFactory = factory.Object }; client.SubscribeToUserStream("test", null, (test) => result = test); var data = new BinanceStreamOrderUpdate() { Event = "executionReport", EventTime = new DateTime(2017, 1, 1), AccumulatedQuantityOfFilledTrades = 1.1m, BuyerIsMaker = true, Commission = 2.2m, CommissionAsset = "test", ExecutionType = ExecutionType.Trade, I = 100000000000, OrderId = 100000000000, Price = 6.6m, PriceLastFilledTrade = 7.7m, Quantity = 8.8m, QuantityOfLastFilledTrade = 9.9m, RejectReason = OrderRejectReason.AccountCannotSettle, Side = OrderSide.Buy, Status = OrderStatus.Filled, Symbol = "test", Time = new DateTime(2017, 1, 1), TimeInForce = TimeInForce.GoodTillCancel, TradeId = 10000000000000, Type = OrderType.Limit, ClientOrderId = "123", IcebergQuantity = 9.9m, IsWorking = true, OriginalClientOrderId = "456", StopPrice = 10.10m }; // act socket.Raise(r => r.OnMessage += null, JsonConvert.SerializeObject(data)); // assert Assert.IsNotNull(result); Assert.IsTrue(TestHelpers.PublicInstancePropertiesEqual(data, result, "Balances")); }
public static Order ConvertOrder(BinanceStreamOrderUpdate order) { return new Order( order.Symbol, ExchangeName.Binance, ConvertOrderDirection(order.Side), order.Quantity, order.Price, ConvertOrderType(order.Type), ConvertTimeInForce(order.TimeInForce), order.StopPrice, order.OrderId.ToString()); }
public void ToInternalOrderUpdateConversionCreationTime() { var input = new BinanceStreamOrderUpdate { Symbol = "TRXETH", OrderCreationTime = DateTime.UtcNow, Side = Binance.Net.Objects.OrderSide.Buy, }; var order = BinanceUtilities.ToInternal(input); var diff = DateTimeOffset.Now - DateTimeOffset.FromUnixTimeMilliseconds(order.CreatedTimestamp); Assert.True(diff.TotalSeconds < 1.0, "CreatedTimeStamp of order not parsed correctly."); }
public void ToInternalOrderUpdateConversionNoCommission() { var input = new BinanceStreamOrderUpdate { Symbol = "TRXETH", OrderCreationTime = DateTime.UtcNow, CummulativeQuoteQuantity = 0, ExecutionType = ExecutionType.Trade, }; var order = BinanceUtilities.ToInternal(input); Assert.Equal(0.0M, order.Commission); Assert.Null(order.CommissionAsset); }
public void ToInternalOrderUpdateDividingZeroSafe() { var input = new BinanceStreamOrderUpdate { Symbol = "TRXETH", AccumulatedQuantityOfFilledTrades = 0, OrderCreationTime = DateTime.UtcNow, CummulativeQuoteQuantity = 6, Side = Binance.Net.Objects.OrderSide.Buy, }; var order = BinanceUtilities.ToInternal(input); Assert.Equal(0M, order.AverageFilledPrice); }
public void ToInternalOrderUpdateStopPricePropagates() { var input = new BinanceStreamOrderUpdate { Symbol = "TRXETH", OrderCreationTime = DateTime.UtcNow, Side = Binance.Net.Objects.OrderSide.Buy, StopPrice = 15M, }; var order = BinanceUtilities.ToInternal(input); Assert.Equal(15M, order.StopPrice); Assert.Equal(0M, order.SetPrice); }
private void UpdateOrder(BinanceStreamOrderUpdate orderUpdate) { string oid = orderUpdate.OrderId.ToString(); if (m_order.ContainsKey(oid)) { if (IsUpdated(orderUpdate)) { m_order[oid] = orderUpdate; // order is updated } } else { m_order[oid] = orderUpdate; // order is added } }
public void SubscribingToUserStream_Should_TriggerWhenOrderUpdateStreamMessageIsReceived() { // arrange var socket = new TestSocket(); var client = TestHelpers.CreateSocketClient(socket); BinanceStreamOrderUpdate result = null; client.Spot.SubscribeToUserDataUpdatesAsync("test", (test) => result = test.Data, null, null, null); var data = new BinanceCombinedStream <BinanceStreamOrderUpdate> { Stream = "test", Data = new BinanceStreamOrderUpdate() { Event = "executionReport", EventTime = new DateTime(2017, 1, 1), BuyerIsMaker = true, Commission = 2.2m, CommissionAsset = "test", ExecutionType = ExecutionType.Trade, I = 100000000000, OrderId = 100000000000, Price = 6.6m, Quantity = 8.8m, RejectReason = OrderRejectReason.AccountCannotSettle, Side = OrderSide.Buy, Status = OrderStatus.Filled, Symbol = "test", TimeInForce = TimeInForce.GoodTillCancel, TradeId = 10000000000000, Type = OrderType.Limit, ClientOrderId = "123", IcebergQuantity = 9.9m, IsWorking = true, OriginalClientOrderId = "456", StopPrice = 10.10m } }; // act socket.InvokeMessage(data); // assert Assert.IsNotNull(result); Assert.IsTrue(TestHelpers.AreEqual(data.Data, result, "Balances")); }
public static Order ToOrder(this BinanceStreamOrderUpdate binanceOrder) { Order order = new Order(); order.Id = long.Parse(binanceOrder.ClientOrderId); order.ExchangeOrderId = binanceOrder.OrderId; order.Symbol = binanceOrder.Symbol; order.Updated = DateTime.Now; order.Price = binanceOrder.Price; order.Amount = binanceOrder.Quantity; order.OrderStatusCode = binanceOrder.Status.ToStatus().Code; order.ExchangeOrderStatusCode = (long)binanceOrder.Status; order.Fee = binanceOrder.Commission; order.Asset = binanceOrder.CommissionAsset; return(order); }
private void OrderStreamUpdate(BinanceStreamOrderUpdate obj) { switch (obj.Status) { case OrderStatus.Filled: if (obj.Side == OrderSide.Buy) { this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Sell); } if (obj.Side == OrderSide.Sell) { this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Buy); } break; Logger.Info(string.Format("TransactionTime received for : {0}", obj.Status)); Logger.Info(string.Format("ListOrderStatus received for : {0}", obj.Quantity)); } }
private BinanceStreamOrderUpdate OrderToOrderUpdate(BinanceOrder o) { var oup = new BinanceStreamOrderUpdate(); oup.ClientOrderId = o.ClientOrderId; oup.IcebergQuantity = o.IcebergQuantity; oup.IsWorking = o.IsWorking; oup.OrderId = o.OrderId; oup.Price = o.Price; oup.Quantity = o.Quantity; //o.OriginalQuantity oup.Side = o.Side; oup.Status = o.Status; oup.StopPrice = o.StopPrice; oup.Symbol = o.Symbol; oup.CreateTime = o.CreateTime; oup.TimeInForce = o.TimeInForce; oup.Type = o.Type; return(oup); }
private void OnOrderUpdate(BinanceStreamOrderUpdate data) { var symbol = AllPrices.SingleOrDefault(a => a.Symbol == data.Symbol); if (symbol == null) { return; } lock (orderLock) { var order = symbol.Orders.SingleOrDefault(o => o.Id == data.OrderId); if (order == null) { if (data.RejectReason != OrderRejectReason.None || data.ExecutionType != ExecutionType.New) { // Order got rejected, no need to show return; } Application.Current.Dispatcher.Invoke(() => { symbol.AddOrder(new OrderViewModel() { ExecutedQuantity = data.AccumulatedQuantityOfFilledTrades, Id = data.OrderId, OriginalQuantity = data.Quantity, Price = data.Price, Side = data.Side, Status = data.Status, Symbol = data.Symbol, Time = data.Time, Type = data.Type }); }); } else { order.ExecutedQuantity = data.AccumulatedQuantityOfFilledTrades; order.Status = data.Status; } } }
public Trade(BinanceStreamOrderUpdate binanceOrder, BinanceSymbol binanceSymbol) { Timestamp = binanceOrder.UpdateTime; ReferenceID = binanceOrder.OrderId.ToString(); if (binanceOrder.Side == Binance.Net.Enums.OrderSide.Buy) { BoughtAsset = binanceSymbol.BaseAsset; BoughtQuantity = binanceOrder.QuantityFilled; SoldAsset = binanceSymbol.QuoteAsset; SoldQuantity = binanceOrder.QuoteQuantityFilled; } else { SoldAsset = binanceSymbol.BaseAsset; SoldQuantity = binanceOrder.QuantityFilled; BoughtAsset = binanceSymbol.QuoteAsset; BoughtQuantity = binanceOrder.QuoteQuantityFilled; } }
public void ToInternalOrderUpdateConversionCommision() { var input = new BinanceStreamOrderUpdate { Symbol = "TRXETH", OrderCreationTime = DateTime.UtcNow, Commission = 0.08M, CommissionAsset = "EOS", Side = Binance.Net.Objects.OrderSide.Buy, }; var order = BinanceUtilities.ToInternal(input); Assert.Equal(OrderSide.Buy, OrderSide.Buy); Assert.Equal(0.08M, order.Commission); Assert.Equal(new Currency("EOS"), order.CommissionAsset); Assert.Equal( Math.Floor(DateTimeOffset.FromFileTime(DateTime.Now.ToFileTimeUtc()).ToUnixTimeMilliseconds() / 1000.0), Math.Floor(order.CreatedTimestamp / 1000.0)); }
private void OrderStreamUpdate(BinanceStreamOrderUpdate obj) { switch (obj.Status) { case OrderStatus.Filled: //if (obj.Side == OrderSide.Buy) //{ // this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Sell); //} //if (obj.Side == OrderSide.Sell) //{ // this.RemoveAllDirectionOrder(Binance.Net.Objects.OrderSide.Buy); //} break; _logger.LogInformation($"TransactionTime received for : {obj.Status}"); _logger.LogInformation($"ListOrderStatus received for : {obj.Quantity}"); } }
/// <summary> /// Convert a Binance.Net.Binance.StreamOrderUpdate to a SpreadShare.OrderUpdate. /// </summary> /// <param name="orderInfoUpdate">Binance.Net.StreamOrderUpdate.</param> /// <returns>OrderUpdate.</returns> public static OrderUpdate ToInternal(BinanceStreamOrderUpdate orderInfoUpdate) { var order = new OrderUpdate( orderId: orderInfoUpdate.OrderId, tradeId: 0, orderType: ToInternal(orderInfoUpdate.Type), orderStatus: ToInternal(orderInfoUpdate.Status), createdTimestamp: orderInfoUpdate.OrderCreationTime.ToUnixTimestampMilliseconds(), setPrice: orderInfoUpdate.Price, side: ToInternal(orderInfoUpdate.Side), pair: TradingPair.Parse(orderInfoUpdate.Symbol), setQuantity: orderInfoUpdate.Quantity) { LastFillIncrement = orderInfoUpdate.QuantityOfLastFilledTrade, LastFillPrice = orderInfoUpdate.PriceLastFilledTrade, AverageFilledPrice = HelperMethods.SafeDiv( orderInfoUpdate.CummulativeQuoteQuantity, orderInfoUpdate.AccumulatedQuantityOfFilledTrades), FilledQuantity = orderInfoUpdate.AccumulatedQuantityOfFilledTrades, StopPrice = orderInfoUpdate.StopPrice, }; if (order.Status == OrderUpdate.OrderStatus.Filled) { order.FilledTimestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds(); } try { order.Commission = orderInfoUpdate.Commission; order.CommissionAsset = new Currency(orderInfoUpdate.CommissionAsset); } catch (ArgumentException) { // ignored } return(order); }
private void OnOrderUpdate(BinanceStreamOrderUpdate data) { _logger.LogInfoMessage("OnOrderUpdate: " + JsonConvert.SerializeObject(data)); }