BL3P: Get full order book (#485)

* Add orderbook option

* Add call to fetch full orderbook from BL3P

* Remove configureawait from On* overrides

Author: Johnny A. dos Santos

ExchangeSharp/API/Exchanges/BL3P/ExchangeBL3PAPI.cs

@@ -62,14 +62,13 @@ public ExchangeBL3PAPI(ref string publicApiKey, ref string privateApiKey)
 
 		protected override async Task<IEnumerable<string>> OnGetMarketSymbolsAsync()
 		{
-			return (await OnGetMarketSymbolsMetadataAsync().ConfigureAwait(false))
+			return (await OnGetMarketSymbolsMetadataAsync())
 				.Select(em => em.MarketSymbol);
 		}
 
 		protected override async Task<ExchangeTicker> OnGetTickerAsync(string marketSymbol)
 		{
-			var result = await MakeJsonRequestAsync<JObject>($"/{marketSymbol}/ticker")
-				.ConfigureAwait(false);
+			var result = await MakeJsonRequestAsync<JObject>($"/{marketSymbol}/ticker");
 
 			return await this.ParseTickerAsync(
 				result,
@@ -80,7 +79,7 @@ protected override async Task<ExchangeTicker> OnGetTickerAsync(string marketSymb
 				baseVolumeKey: "volume.24h",
 				timestampKey: "timestamp",
 				timestampType: TimestampType.UnixSeconds
-			).ConfigureAwait(false);
+			);
 		}
 
 		protected internal override Task<IEnumerable<ExchangeMarket>> OnGetMarketSymbolsMetadataAsync()
@@ -131,27 +130,7 @@ Task MessageCallback(IWebSocket _, byte[] msg)
 			{
 				var bl3POrderBook = JsonConvert.DeserializeObject<BL3POrderBook>(msg.ToStringFromUTF8());
 
-				var exchangeOrderBook = new ExchangeOrderBook
-				{
-					MarketSymbol = bl3POrderBook.MarketSymbol,
-					LastUpdatedUtc = CryptoUtility.UtcNow
-				};
-
-				var asks = bl3POrderBook.Asks
-					.OrderBy(b => b.Price, exchangeOrderBook.Asks.Comparer)
-					.Take(maxCount);
-				foreach (var ask in asks)
-				{
-					exchangeOrderBook.Asks.Add(ask.Price, ask.ToExchangeOrder());
-				}
-
-				var bids = bl3POrderBook.Bids
-					.OrderBy(b => b.Price, exchangeOrderBook.Bids.Comparer)
-					.Take(maxCount);
-				foreach (var bid in bids)
-				{
-					exchangeOrderBook.Bids.Add(bid.Price, bid.ToExchangeOrder());
-				}
+				var exchangeOrderBook = ConvertToExchangeOrderBook(maxCount, bl3POrderBook);
 
 				callback(exchangeOrderBook);
 
@@ -161,7 +140,7 @@ Task MessageCallback(IWebSocket _, byte[] msg)
 			return new MultiWebsocketWrapper(
 				await Task.WhenAll(
 					marketSymbols.Select(ms => ConnectWebSocketAsync($"{ms}/orderbook", MessageCallback))
-				).ConfigureAwait(false)
+				)
 			);
 		}
 
@@ -173,9 +152,9 @@ protected override async Task<IWebSocket> OnGetTradesWebSocketAsync(Func<KeyValu
 			}
 			Task MessageCallback(IWebSocket _, byte[] msg)
 			{ // {{	"date": 1573255932, "marketplace": "BTCEUR", "price_int": 802466000, "type": "buy", "amount_int": 6193344 }	}
-				JToken token = JToken.Parse(msg.ToStringFromUTF8());
+				var token = JToken.Parse(msg.ToStringFromUTF8());
 				var symbol = token["marketplace"].ToStringInvariant();
-				ExchangeTrade trade = token.ParseTrade(amountKey: "amount_int", priceKey: "price_int", typeKey: "type", timestampKey: "date",
+				var trade = token.ParseTrade(amountKey: "amount_int", priceKey: "price_int", typeKey: "type", timestampKey: "date",
 					timestampType: TimestampType.UnixSeconds,
 					idKey: null, // + TODO: add Id Key when BL3P starts providing this info
 					typeKeyIsBuyValue: "buy");
@@ -186,10 +165,37 @@ Task MessageCallback(IWebSocket _, byte[] msg)
 			return new MultiWebsocketWrapper(
 				await Task.WhenAll(
 					marketSymbols.Select(ms => ConnectWebSocketAsync($"{ms}/trades", MessageCallback))
-				).ConfigureAwait(false)
+				)
 			);
 		}
 
+		private static ExchangeOrderBook ConvertToExchangeOrderBook(int maxCount, BL3POrderBook bl3POrderBook)
+		{
+			var exchangeOrderBook = new ExchangeOrderBook
+			{
+				MarketSymbol = bl3POrderBook.MarketSymbol,
+				LastUpdatedUtc = CryptoUtility.UtcNow
+			};
+
+			var asks = bl3POrderBook.Asks
+				.OrderBy(b => b.Price, exchangeOrderBook.Asks.Comparer)
+				.Take(maxCount);
+			foreach (var ask in asks)
+			{
+				exchangeOrderBook.Asks.Add(ask.Price, ask.ToExchangeOrder());
+			}
+
+			var bids = bl3POrderBook.Bids
+				.OrderBy(b => b.Price, exchangeOrderBook.Bids.Comparer)
+				.Take(maxCount);
+			foreach (var bid in bids)
+			{
+				exchangeOrderBook.Bids.Add(bid.Price, bid.ToExchangeOrder());
+			}
+
+			return exchangeOrderBook;
+		}
+
 		protected override bool CanMakeAuthenticatedRequest(IReadOnlyDictionary<string, object> payload)
 		{
 			return !(PublicApiKey is null) && !(PrivateApiKey is null);
@@ -258,18 +264,31 @@ protected override async Task<ExchangeOrderResult> OnPlaceOrderAsync(ExchangeOrd
 			var resultBody = await MakeRequestAsync(
 					$"/{order.MarketSymbol}/money/order/add",
 					payload: data
-				)
-				.ConfigureAwait(false);
+				);
 
 			var result = JsonConvert.DeserializeObject<BL3POrderAddResponse>(resultBody)
 				.Except();
 
-			var orderDetails = await GetOrderDetailsAsync(result.OrderId, order.MarketSymbol)
-				.ConfigureAwait(false);
+			var orderDetails = await GetOrderDetailsAsync(result.OrderId, order.MarketSymbol);
 
 			return orderDetails;
 		}
 
+		protected override async Task<ExchangeOrderBook> OnGetOrderBookAsync(string marketSymbol, int maxCount = 100)
+		{
+			if (string.IsNullOrWhiteSpace(marketSymbol))
+				throw new ArgumentException("Value cannot be null or whitespace.", nameof(marketSymbol));
+
+			var resultBody = await MakeRequestAsync($"/{marketSymbol}/money/depth/full");
+
+			var bl3pOrderBook = JsonConvert.DeserializeObject<BL3PReponseFullOrderBook>(resultBody)
+				.Except();
+
+			bl3pOrderBook.MarketSymbol??= marketSymbol;
+
+			return ConvertToExchangeOrderBook(maxCount, bl3pOrderBook);
+		}
+
 		protected override async Task OnCancelOrderAsync(string orderId, string marketSymbol = null)
 		{
 			if (string.IsNullOrWhiteSpace(marketSymbol))
@@ -281,14 +300,13 @@ protected override async Task OnCancelOrderAsync(string orderId, string marketSy
 					{
 						{"order_id", orderId}
 					}
-				)
-				.ConfigureAwait(false);
+				);
 
 			JsonConvert.DeserializeObject<BL3PEmptyResponse>(resultBody)
 				.Except();
 		}
 
-		public override async Task<ExchangeOrderResult> GetOrderDetailsAsync(string orderId, string marketSymbol = null)
+		protected override async Task<ExchangeOrderResult> OnGetOrderDetailsAsync(string orderId, string marketSymbol = null)
 		{
 			if (string.IsNullOrWhiteSpace(marketSymbol))
 				throw new ArgumentException("Value cannot be null or whitespace.", nameof(marketSymbol));
@@ -301,8 +319,7 @@ public override async Task<ExchangeOrderResult> GetOrderDetailsAsync(string orde
 			var resultBody = await MakeRequestAsync(
 					$"/{marketSymbol}/money/order/result",
 					payload: data
-				)
-				.ConfigureAwait(false);
+				);
 
 
 			var result = JsonConvert.DeserializeObject<BL3POrderResultResponse>(resultBody)

ExchangeSharp/API/Exchanges/BL3P/Models/BL3POrderBook.cs

@@ -3,7 +3,7 @@
 namespace ExchangeSharp.BL3P
 {
 	// ReSharper disable once InconsistentNaming
-	internal class BL3POrderBook
+	internal class BL3POrderBook : BL3PResponsePayload
 	{
 		[JsonProperty("marketplace")]
 		public string MarketSymbol { get; set; }

ExchangeSharp/API/Exchanges/BL3P/Models/BL3PReponseFullOrderBook.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace ExchangeSharp.BL3P
+{
+	internal class BL3PReponseFullOrderBook : BL3PResponse<BL3POrderBook>
+	{
+		[JsonConverter(typeof(BL3PResponseConverter<BL3POrderBook>))]
+		protected override BL3PResponsePayload Data { get; set; }
+	}
+}

ExchangeSharp/API/Exchanges/_Base/ExchangeAPI.cs

@@ -62,16 +62,20 @@ protected virtual async Task<IEnumerable<KeyValuePair<string, ExchangeTicker>>>
             return tickers;
         }
 
-        protected virtual async Task<IEnumerable<KeyValuePair<string, ExchangeOrderBook>>> OnGetOrderBooksAsync(int maxCount = 100)
-        {
-            List<KeyValuePair<string, ExchangeOrderBook>> books = new List<KeyValuePair<string, ExchangeOrderBook>>();
-            var marketSymbols = await GetMarketSymbolsAsync();
-            foreach (string marketSymbol in marketSymbols)
-            {
-                var book = await GetOrderBookAsync(marketSymbol);
-                books.Add(new KeyValuePair<string, ExchangeOrderBook>(marketSymbol, book));
-            }
-            return books;
+        protected virtual async Task<IEnumerable<KeyValuePair<string, ExchangeOrderBook>>> OnGetOrderBooksAsync(
+	        int maxCount = 100
+        )
+        {
+	        var marketSymbols = await GetMarketSymbolsAsync();
+	        var orderBooks = await Task.WhenAll(
+		        marketSymbols.Select(async ms =>
+		        {
+			        var orderBook = await GetOrderBookAsync(ms, maxCount);
+			        orderBook.MarketSymbol ??= ms;
+			        return orderBook;
+		        })
+	        );
+	        return orderBooks.ToDictionary(k => k.MarketSymbol, v => v);
         }
 
         protected virtual async Task<IEnumerable<ExchangeTrade>> OnGetRecentTradesAsync(string marketSymbol)

ExchangeSharp/ExchangeSharp.csproj.DotSettings

@@ -0,0 +1,3 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeEditing/Localization/Localizable/@EntryValue">No</s:String>
+</wpf:ResourceDictionary>

ExchangeSharpConsole/Constants.cs

@@ -0,0 +1,7 @@
+namespace ExchangeSharpConsole
+{
+	public static class Constants
+	{
+		public const string DefaultKeyPath = "keys.bin";
+	}
+}

ExchangeSharpConsole/Options/BaseOption.cs

@@ -214,5 +214,27 @@ string[] apiSymbols
 				);
 			}
 		}
+
+		protected void PrintOrderBook(ExchangeOrderBook orderBook)
+		{
+			Console.WriteLine($"{"BID",-22} | {"ASK",22}");
+
+			Console.WriteLine("---");
+
+			var length = orderBook.Asks.Count;
+
+			if (orderBook.Bids.Count > length)
+			{
+				length = orderBook.Bids.Count;
+			}
+
+			for (var i = 0; i < length; i++)
+			{
+				var (_, ask) = orderBook.Asks.ElementAtOrDefault(i);
+				var (_, bid) = orderBook.Bids.ElementAtOrDefault(i);
+				Console.WriteLine($"{bid.Price,10} ({bid.Amount,9:N2}) | " +
+				                  $"{ask.Price,10} ({ask.Amount,9:N})");
+			}
+		}
 	}
 }

ExchangeSharpConsole/Options/Interfaces/IOptionWithKey.cs

@@ -4,7 +4,7 @@ namespace ExchangeSharpConsole.Options.Interfaces
 {
 	public interface IOptionWithKey
 	{
-		[Option('k', "key", Default = "keys.bin",
+		[Option('k', "key", Default = Constants.DefaultKeyPath,
 			HelpText = "Path to key file (generated with the key utility).")]
 		string KeyPath { get; set; }
 	}

ExchangeSharpConsole/Options/Interfaces/IOptionWithMaximum.cs

@@ -0,0 +1,10 @@
+using CommandLine;
+
+namespace ExchangeSharpConsole.Options.Interfaces
+{
+	public interface IOptionWithMaximum
+	{
+		[Option("max", Default = 10, HelpText = "Sets the maximum.")]
+		int Max { get; set; }
+	}
+}

ExchangeSharpConsole/Options/OrderBookOption.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using CommandLine;
+using ExchangeSharp;
+using ExchangeSharpConsole.Options.Interfaces;
+
+namespace ExchangeSharpConsole.Options
+{
+	[Verb("orderbook", HelpText = "Prints the order book from an exchange.")]
+	public class OrderBookOption : BaseOption,
+		IOptionPerExchange, IOptionWithMultipleMarketSymbol, IOptionWithMaximum, IOptionWithKey
+	{
+		public override async Task RunCommand()
+		{
+			using var api = GetExchangeInstance(ExchangeName);
+
+			if (!string.IsNullOrWhiteSpace(KeyPath)
+			    && !KeyPath.Equals(Constants.DefaultKeyPath, StringComparison.Ordinal))
+			{
+				api.LoadAPIKeys(KeyPath);
+			}
+
+			var marketSymbols = MarketSymbols.ToArray();
+
+			var orderBooks = await GetOrderBooks(marketSymbols, api);
+
+			foreach (var (marketSymbol, orderBook) in orderBooks)
+			{
+				Console.WriteLine($"Order Book for market: {marketSymbol} {orderBook}");
+				PrintOrderBook(orderBook);
+				Console.WriteLine();
+			}
+		}
+
+		private async Task<IEnumerable<KeyValuePair<string, ExchangeOrderBook>>> GetOrderBooks(
+			string[] marketSymbols,
+			IExchangeAPI api
+		)
+		{
+			IEnumerable<KeyValuePair<string, ExchangeOrderBook>> orderBooks;
+
+			if (marketSymbols.Length == 0)
+			{
+				orderBooks = await api.GetOrderBooksAsync(Max);
+			}
+			else
+			{
+				var orderBooksList = await Task.WhenAll(
+					marketSymbols.Select(async ms =>
+					{
+						var orderBook = await api.GetOrderBookAsync(ms, Max);
+
+						orderBook.MarketSymbol ??= ms;
+
+						return orderBook;
+					})
+				);
+				orderBooks = orderBooksList.ToDictionary(k => k.MarketSymbol, v => v);
+			}
+
+			return orderBooks;
+		}
+
+		public string ExchangeName { get; set; }
+
+		public IEnumerable<string> MarketSymbols { get; set; }
+
+		public int Max { get; set; }
+
+		public string KeyPath { get; set; }
+	}
+}