private static OrderBook ParseOrderBook(OrderBookResponse response)
{
var bids = response.Bids.Select(ParseOrder);
var asks = response.Asks.Select(ParseOrder);
return(new OrderBook(bids.ToArray(), asks.ToArray()));
}
private void HandleSnapshot(OrderBookResponse response)
{
// received snapshot, convert and stream
var levels = ConvertLevels(response);
var bulk = new OrderBookLevelBulk(OrderBookAction.Insert, levels, CryptoOrderBookType.L2);
FillBulk(response, bulk);
StreamSnapshot(bulk);
}
private void FillBulk(OrderBookResponse response, OrderBookLevelBulk bulk)
{
if (response == null)
{
return;
}
bulk.ExchangeName = ExchangeName;
bulk.ServerTimestamp = response.Data?.Microtimestamp;
}
private OrderBookLevel[] ConvertLevels(OrderBookResponse response)
{
var bids = response.Data?.Bids
.Select(x => ConvertLevel(x, CryptoOrderSide.Bid, response.Symbol))
.ToArray() ?? Array.Empty <OrderBookLevel>();
var asks = response.Data?.Asks
.Select(x => ConvertLevel(x, CryptoOrderSide.Ask, response.Symbol))
.ToArray() ?? Array.Empty <OrderBookLevel>();
return(bids.Concat(asks).ToArray());
}
internal OrderBook(int instrumentId, double groupSize, int levelCount, OrderBookResponse message)
{
InstrumentId = instrumentId;
GroupSize = groupSize;
LevelCount = levelCount;
#if NETSTANDARD1_5
Asks = message.Asks.Select(e => new OrderLevel(e)).ToArray();
Bids = message.Bids.Select(e => new OrderLevel(e)).ToArray();
#else
Asks = Array.AsReadOnly(message.Asks.Select(e => new OrderLevel(e)).ToArray());
Bids = Array.AsReadOnly(message.Bids.Select(e => new OrderLevel(e)).ToArray());
#endif
}
/// <summary>
/// Build <see cref="MarketDepth"/>
/// </summary>
/// <param name="marketDepth">Market depth</param>
/// <param name="limit">Limit of returned orders count</param>
public async Task BuildAsync(MarketDepth marketDepth, int limit = 100)
{
if (marketDepth == null)
{
throw new ArgumentNullException(nameof(marketDepth));
}
if (limit <= 0)
{
throw new ArgumentOutOfRangeException(nameof(limit));
}
OrderBookResponse orderBook = await _restClient.GetOrderBookAsync(marketDepth.Symbol, false, limit);
marketDepth.UpdateDepth(orderBook.Asks, orderBook.Bids, orderBook.LastUpdateId);
}
private void RefreshOrderBook(ListView lv, OrderBookResponse r)
{
lv.Items.Clear();
var index = 1;
foreach (var offer in r.Offers)
{
var text = (offer.IsSell ? "Sell " : "Buy ") + (index++).ToString();
var value = offer.IsSell ? offer.TakerGets.Value : offer.TakerPays.Value;
var price = offer.Price;
var item = new ListViewItem(text);
item.SubItems.Add(value);
item.SubItems.Add(price);
lv.Items.Add(item);
}
}
public static void AssertTestData(OrderBookResponse orderBook)
{
Assert.AreEqual(orderBook.OrderBookBase, new AssetTypeNative());
Assert.AreEqual(orderBook.Counter, Asset.CreateNonNativeAsset("DEMO", KeyPair.FromAccountId("GBAMBOOZDWZPVV52RCLJQYMQNXOBLOXWNQAY2IF2FREV2WL46DBCH3BE")));
Assert.AreEqual(orderBook.Bids[0].Amount, "31.4007644");
Assert.AreEqual(orderBook.Bids[0].Price, "0.0024224");
Assert.AreEqual(orderBook.Bids[0].PriceR.Numerator, 4638606);
Assert.AreEqual(orderBook.Bids[0].PriceR.Denominator, 1914900241);
Assert.AreEqual(orderBook.Bids[1].Amount, "5.9303650");
Assert.AreEqual(orderBook.Bids[1].Price, "0.0024221");
Assert.AreEqual(orderBook.Asks[0].Amount, "541.4550766");
Assert.AreEqual(orderBook.Asks[0].Price, "0.0025093");
Assert.AreEqual(orderBook.Asks[1].Amount, "121.9999600");
Assert.AreEqual(orderBook.Asks[1].Price, "0.0025093");
}
private bool HandleObjectMessage(string msg)
{
var response = BitstampJsonSerializer.Deserialize <JObject>(msg);
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(SubscriptionSucceeded.TryHandle(response, Streams.SubscriptionSucceededSubject) ||
UnsubscriptionSucceeded.TryHandle(response, Streams.UnsubscriptionSucceededSubject) ||
//OrderBookSnapshotResponse.TryHandle(response, Streams.OrderBookSnapshotSubject) ||
Ticker.TryHandle(response, Streams.TickerSubject) ||
OrderBookResponse.TryHandle(response, Streams.OrderBookSubject) ||
OrderBookDetailResponse.TryHandle(response, Streams.OrderBookDetailSubject) ||
OrderBookDiffResponse.TryHandle(response, Streams.OrderBookDiffSubject) ||
ErrorResponse.TryHandle(response, Streams.ErrorSubject) ||
OrderResponse.TryHandle(response, Streams.OrdersSubject) ||
false);
}
static void Main(string[] args)
{
TradeioApi api = new TradeioApi("aaaaaaaa-bbbb-cccc-dddd-eeeeeeee", "aaaaaaaa-bbbb-cccc-dddd-eeeeeeee");
string symbol = "btc_usdt";
Console.WriteLine("******PAIRS******");
PairsResponse pairsResponse = api.GetPairs().Result;
Console.WriteLine(string.Join(',', pairsResponse.Pairs));
Console.WriteLine("******CANDLES******");
CandlesResponse candles = api.GetCandles("btc_usdt", CandleInterval.OneDay, DateTime.UtcNow.AddMonths(-1), DateTime.UtcNow, 20).Result;
foreach (CandleInfo candle in candles.Candles)
{
Console.WriteLine($"open: {candle.Open}; close: {candle.Close}; low: {candle.Low}; high: {candle.High}");
}
Console.WriteLine("******ORDER BOOK******");
OrderBookResponse orderBookResponse = api.GetOrderBook(symbol, 2).Result;
Console.WriteLine("***ASK***");
foreach (var askArray in orderBookResponse.Book.Asks)
{
Console.WriteLine($"Price: {askArray[0]}; Count: {askArray[1]}");
}
Console.WriteLine("***BID***");
foreach (var bidArray in orderBookResponse.Book.Bids)
{
Console.WriteLine($"Price: {bidArray[0]}; Count: {bidArray[1]}");
}
Console.WriteLine("******TICKER******");
TickerResponse tickerResponse = api.GetTicker(symbol).Result;
Console.WriteLine($"ASK price: {tickerResponse.Ticker.AskPrice}, qty: {tickerResponse.Ticker.AskQty}; BID price: {tickerResponse.Ticker.BidPrice}, qty: {tickerResponse.Ticker.BidQty}");
//tickers for all pairs
//var tickers = api.GetTickers().Result;
Console.WriteLine("******RECENT TRADES******");
TradesResponse tradesResponse = api.GetRecentTrades("btc_usdt", 2).Result;
foreach (TradeInfo trade in tradesResponse.Trades)
{
Console.WriteLine($"{trade.Symbol} price: {trade.Price}, qty: {trade.Quantity}, side: {trade.Type}, date: {UnixTime.GetDateTime(trade.Time)} UTC");
}
//PRIVATE METHODS. NOT WORKING WITHOUT PUBLIC AND PRIVATE KEY
Console.WriteLine("******CURRENT BALANCES******");
AccountBalanceResponse accountBalance = api.GetAccount().Result;
foreach (BalanceInfo balanceInfo in accountBalance.Balances)
{
Console.WriteLine($"{balanceInfo.Asset}:{balanceInfo.Available} (locked: {balanceInfo.Locked})");
}
Console.WriteLine("******OPEN ORDERS******");
OrdersResponse ordersResponse = api.GetOpenOrders(symbol).Result;
foreach (OrderInfoResponse order in ordersResponse.Orders)
{
Console.WriteLine($"{order.Side} {order.Instrument} for {order.Price}. Filled: {order.UnitsFilled}");
}
Console.WriteLine("******CLOSED ORDERS******");
FilteredResponse <OrderInfoResponse> closeOrdersResponse = api.GetClosedOrders(symbol, UnixTime.Get(DateTime.UtcNow.AddDays(-1)), UnixTime.Get(DateTime.UtcNow)).Result;
foreach (OrderInfoResponse order in closeOrdersResponse.Data)
{
Console.WriteLine($"{order.Side} {order.Instrument} for {order.Price}. Filled: {order.UnitsFilled}. Status: {order.Status}");
}
Console.WriteLine("******PLACE ORDER******");
var orderResponse = api.PlaceOrder(new Models.OrderRequest()
{
Price = 4000,
Quantity = 10,
Side = Models.OrderSide.Buy,
Symbol = symbol,
Type = Models.OrderType.Limit
}).Result;
Console.WriteLine("******CANCEL ORDER******");
Response response = api.CancelOrder(orderResponse.Order.OrderId).Result;
if (response.Code == 200)
{
Console.WriteLine("Order canceled");
}
Console.ReadLine();
}
// OrderBook Websocket
private void OrderBookMessageHandler(OrderBookResponse messageData)
{
var data = messageData;
}
