public void should_subscribe_on_funding_with_arguments()
{
try
{
// arrange
var connected = Sut.Connect();
IEnumerable <FundingDto> dtos = null;
var dataReceived = new ManualResetEvent(false);
var subscription = BitmetSocketSubscriptions.CreateFundingSubscription(a =>
{
dtos = a.Data;
dataReceived.Set();
}).WithArgs("XBTUSD");
Subscription = subscription;
// act
Sut.Subscribe(subscription);
var received = dataReceived.WaitOne(TimeSpan.FromSeconds(60));
// assert
// no exception raised
connected.Should().BeTrue();
received.Should().BeTrue();
dtos.Should().NotBeNull();
dtos.Count().Should().BeGreaterThan(0);
dtos.All(a => a.Symbol == "XBTUSD").Should().BeTrue();
}
catch (BitmexWebSocketLimitReachedException)
{
Assert.Inconclusive("connection limit reached");
}
}
public void should_subscribe_on_funding()
{
try
{
// arrange
var connected = Sut.Connect();
IEnumerable <AnnouncementDto> dtos = null;
var dataReceived = new ManualResetEvent(false);
var subscription = BitmetSocketSubscriptions.CreateAnnouncementSubscription(a =>
{
dtos = a.Data;
dataReceived.Set();
});
Subscription = subscription;
// act
Sut.Subscribe(subscription);
// assert
// no exception raised
connected.Should().BeTrue();
}
catch (BitmexWebSocketLimitReachedException)
{
Assert.Inconclusive("connection limit reached");
}
}
public void should_subscribe_on_all_instruments()
{
try
{
// arrange
var connected = Sut.Connect();
// act
IEnumerable <InstrumentDto> dto = null;
var dataReceived = new ManualResetEvent(false);
var subscription = BitmetSocketSubscriptions.CreateInstrumentSubsription(a =>
{
dto = a.Data;
dataReceived.Set();
});
Subscription = subscription;
Sut.Subscribe(subscription);
var received = dataReceived.WaitOne(TimeSpan.FromSeconds(2));
// assert
// no exception raised
connected.Should().BeTrue();
received.Should().BeTrue();
dto.Should().NotBeNull();
dto.Count().Should().BeGreaterThan(0);
}
catch (BitmexWebSocketLimitReachedException)
{
Assert.Inconclusive("connection limit reached");
}
}
public void should_receive_position_change_notification()
{
try
{
// arrange
var connected = Sut.Connect();
var @params = OrderPOSTRequestParams.CreateSimpleMarket("XBTUSD", 3, OrderSide.Buy);
IList <PositionDto> dtos = null;
var dataReceived = new ManualResetEvent(false);
var subscription = BitmetSocketSubscriptions.CreatePositionSubsription(a =>
{
dtos = a.Data.ToList();
dataReceived.Set();
});
Subscription = subscription;
// act
Sut.Subscribe(subscription);
var result = _bitmexApiService.Execute(BitmexApiUrls.Order.PostOrder, @params).Result.Result;
result.Should().NotBeNull();
result.OrdType.Should().Be("Market");
result.OrdStatus.Should().Be("Filled");
result.OrderId.Should().NotBeNull();
var received = dataReceived.WaitOne(TimeSpan.FromSeconds(20));
// assert
// no exception raised
connected.Should().BeTrue();
received.Should().BeTrue("data hasn't received");
dtos.Should().NotBeNull();
dtos.Count().Should().BeGreaterThan(0);
}
catch (BitmexWebSocketLimitReachedException)
{
Assert.Inconclusive("connection limit reached");
}
}
private void InitializeSubs()
{
_subLiquidation = BitmetSocketSubscriptions.CreateLiquidationSubsription(message =>
{
foreach (var dto in message.Data)
{
dataQueue.Add(dto);
}
});
_bitmexApiSocketService.Subscribe(_subLiquidation);
_subInstrument = BitmetSocketSubscriptions.CreateInstrumentSubsription(message =>
{
foreach (var dto in message.Data)
{
_lastupdate = DateTime.Now;
}
});
_bitmexApiSocketService.Subscribe(_subInstrument);
dataQueue.CompleteAdding();
dataQueue = new BlockingCollection <LiquidationDto>(new ConcurrentQueue <LiquidationDto>());
Task.Run(async() =>
{
while (!dataQueue.IsCompleted)
{
LiquidationDto liquidationDto = null;
try
{
liquidationDto = dataQueue.Take();
}
catch (InvalidOperationException) { }
if (liquidationDto != null)
{
await HandleLiquidation(liquidationDto);
}
}
Console.WriteLine("\r\nNo more items to take.");
});
}
public BitmexDOMListener(IBitmexApiSocketService svc, StrategySettings settings)
{
_svc = svc;
_svc.Connect();
_svc.Subscribe(BitmetSocketSubscriptions.CreateOrderBookL2Subsription(
msg =>
{
foreach (var dto in msg.Data)
{
if (!string.Equals(dto.Symbol, settings.Instrument.Symbol, StringComparison.OrdinalIgnoreCase))
{
continue;
}
var tmp = OnDOMChanged;
if (tmp != null)
{
tmp();
}
}
}
));
}
public void should_subscribe_on_executions()
{
try
{
// arrange
var connected = Sut.Connect();
IEnumerable <ExecutionDto> dtos = null;
var dataReceived = new ManualResetEvent(false);
var subscription = BitmetSocketSubscriptions.CreateExecutionSubsription(a =>
{
if (a.Data.Any())
{
dtos = a.Data;
dataReceived.Set();
}
});
Subscription = subscription;
// act
Sut.Subscribe(subscription);
_bitmexApiService.Execute(BitmexApiUrls.Order.PostOrder,
OrderPOSTRequestParams.CreateSimpleMarket("XBTUSD", 10, OrderSide.Buy)).Wait();
var received = dataReceived.WaitOne(TimeSpan.FromSeconds(30));
// assert
// no exception raised
connected.Should().BeTrue();
received.Should().BeTrue();
dtos.Should().NotBeNull();
dtos.Count().Should().BeGreaterThan(0);
}
catch (BitmexWebSocketLimitReachedException)
{
Assert.Inconclusive("connection limit reached");
}
}
private void UnsubscribeOrderBookL2_25()
{
_bitmexApiSocketService.UnsubscribeAsync(BitmetSocketSubscriptions.CreateOrderBookL2_25Subsription(message =>
{ }, "XBTUSD"));
}
private void StartLoad()
{
try
{
IsConnected = _bitmexApiSocketService.Connect();
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
if (IsConnected)
{/*
* _bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateInstrumentSubsription(
* message =>
* {
* foreach (var instrumentDto in message.Data)
* {
* lock (_syncObj)
* {
* var existing = Instruments.FirstOrDefault(a => a.Symbol == instrumentDto.Symbol);
* if (existing != null && message.Action == BitmexActions.Update)
* {
* Mapper.Map<InstrumentDto, InstrumentModel>(instrumentDto, existing);
* }
* else if (message.Action != BitmexActions.Partial && message.Action != BitmexActions.Delete)
* {
* Instruments.Add(Mapper.Map<InstrumentDto, InstrumentModel>(instrumentDto));
* }
* }
* }
* }));
*/
_bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateOrderSubsription(
message =>
{
lock (_syncObjOrders)
{
if (message.Action == BitmexActions.Partial)
{
OrderUpdates.Clear();
}
foreach (var order in message.Data)
{
var existing = OrderUpdates.FirstOrDefault(a => a.OrderId == order.OrderId);
if (existing != null && message.Action == BitmexActions.Update)
{
if (order.LeavesQty != null && order.OrderQty != null)
{
Mapper.Map <OrderDto, OrderUpdateModel>(order, existing);
}
if (order.OrdStatus == "Canceled")
{
OrderUpdates.Remove(existing);
}
}
else if (message.Action == BitmexActions.Partial || message.Action == BitmexActions.Insert)
{
OrderUpdates.Add(Mapper.Map <OrderDto, OrderUpdateModel>(order));
}
}
OnPropertyChanged(nameof(OrderUpdates));
_listOrderID = "";
foreach (var order in OrderUpdates)
{
_listOrderID += order.OrderId.ToString() + "\n";
}
OnPropertyChanged(nameof(ListOrderID));
}
}, null));
/*
* _bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateOrderBook10Subsription(
* message =>
* {
* foreach (var dto in message.Data)
* {
* if (dto.Symbol != "XBTUSD")
* {
* continue;
* }
*
* lock (_syncObjOrderBook10)
* {
* OrderBook10 = dto.Asks.Select(a =>
* new OrderBookModel { Direction = "Sell", Price = a[0], Size = a[1] })
* .Union(dto.Bids.Select(a =>
* new OrderBookModel { Direction = "Buy", Price = a[0], Size = a[1] })).ToList();
* }
*
* OnPropertyChanged(nameof(OrderBook10));
* }
* }));*/
_bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateOrderBookL2_25Subsription(
message =>
{
List <OrderBookModel> tempBidWall = new List <OrderBookModel>();
List <OrderBookModel> tempAskWall = new List <OrderBookModel>();
lock (_syncObjOrderBookL2_25)
{
if (message.Action == BitmexActions.Partial)
{
OrderBookL2_25.Clear();
}
foreach (var dto in message.Data)
{
if (dto.Symbol != _pair)
{
continue;
}
if (message.Action == BitmexActions.Insert || message.Action == BitmexActions.Partial)
{
OrderBookL2_25.Add(Mapper.Map <OrderBookDto, OrderBookModel>(dto));
}
if (message.Action == BitmexActions.Delete)
{
var existing = OrderBookL2_25.FirstOrDefault(a => a.Id == dto.Id);
if (existing != null)
{
OrderBookL2_25.Remove(existing);
}
}
if (message.Action == BitmexActions.Update)
{
var existing = OrderBookL2_25.FirstOrDefault(a => a.Id == dto.Id);
if (existing == null)
{
//OrderBookL2.Add(Mapper.Map<OrderBookDto, OrderBookModel>(dto));
}
else
{
existing.Size = dto.Size;
}
}
OnPropertyChanged(nameof(OrderBookL2_25));
}
MakeBuyBookAndSellBook(tempBidWall, tempAskWall);
UpdateBidDepthChart(tempBidWall);
UpdateAskDepthChart(tempAskWall);
}
}, _pair));
}
}
private void StartLoad()
{
try
{
IsConnected = _bitmexApiSocketService.Connect();
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
if (IsConnected)
{
_bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateInstrumentSubsription(
message =>
{
foreach (var instrumentDto in message.Data)
{
lock (_syncObj)
{
var existing = Instruments.FirstOrDefault(a => a.Symbol == instrumentDto.Symbol);
if (existing != null && message.Action == BitmexActions.Update)
{
Mapper.Map <InstrumentDto, InstrumentModel>(instrumentDto, existing);
}
else if (message.Action != BitmexActions.Partial && message.Action != BitmexActions.Delete)
{
Instruments.Add(Mapper.Map <InstrumentDto, InstrumentModel>(instrumentDto));
}
}
}
}));
_bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateOrderSubsription(
message =>
{
foreach (var order in message.Data)
{
lock (_syncObjOrders)
{
var existing = OrderUpdates.FirstOrDefault(a => a.OrderId == order.OrderId);
if (existing != null && message.Action == BitmexActions.Update)
{
Mapper.Map <OrderDto, OrderUpdateModel>(order, existing);
}
else if (message.Action != BitmexActions.Partial && message.Action != BitmexActions.Delete)
{
OrderUpdates.Add(Mapper.Map <OrderDto, OrderUpdateModel>(order));
}
}
OnPropertyChanged(nameof(OrderUpdates));
}
}));
_bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateOrderBook10Subsription(
message =>
{
foreach (var dto in message.Data)
{
if (dto.Symbol != "XBTUSD")
{
continue;
}
lock (_syncObjOrderBook10)
{
OrderBook10 = dto.Asks.Select(a =>
new OrderBookModel {
Direction = "Sell", Price = a[0], Size = a[1]
})
.Union(dto.Asks.Select(a =>
new OrderBookModel {
Direction = "Buy", Price = a[0], Size = a[1]
})).ToList();
}
OnPropertyChanged(nameof(OrderBook10));
}
}));
_bitmexApiSocketService.Subscribe(BitmetSocketSubscriptions.CreateOrderBookL2Subsription(
message =>
{
foreach (var dto in message.Data)
{
if (dto.Symbol != "XBTUSD")
{
continue;
}
lock (_syncObjOrderBookL2)
{
if (message.Action == BitmexActions.Insert || message.Action == BitmexActions.Partial)
{
OrderBookL2.Add(Mapper.Map <OrderBookDto, OrderBookModel>(dto));
}
if (message.Action == BitmexActions.Delete)
{
var existing = OrderBookL2.FirstOrDefault(a => a.Id == dto.Id);
if (existing != null)
{
OrderBookL2.Remove(existing);
}
}
if (message.Action == BitmexActions.Update)
{
var existing = OrderBookL2.FirstOrDefault(a => a.Id == dto.Id);
if (existing == null)
{
OrderBookL2.Add(Mapper.Map <OrderBookDto, OrderBookModel>(dto));
}
else
{
Mapper.Map <OrderBookDto, OrderBookModel>(dto, existing);
}
}
}
OnPropertyChanged(nameof(OrderBook10));
}
}));
}
}
