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));
}
