Add ExchangeKrakenAPI.OnGetCandlesWebSocketAsync implementation (#600)

The kraken API (https://docs.kraken.com/websockets/#message-ohlc) actually only sends one candle at a time, not an array of candles, so I changed the interface accordingly
The API also requires the candle interval parameter which is part of the channel name, so this was also added to the interface
Provided an implementation for Kraken exchange. There is one quirk* mentioned below
Added ws-candles to ExchangeSharpConsole. Also added a IOptionWithPeriod so the candle interval can be specified on commandline - and applied this to the REST-based CandlesOption with the same default value of 1800
I'm not sure if we have formal tests but I tested from the console app and all looked good except for:

*Note that Kraken sends updates to the current candle when there are new trades, and when it does the open-time is the current time, i.e. the open time changes over the life-time of the candle but the close-time does not. Current implementation passes open-time to ParseCandle extension method as MarketCandle.TimeStamp is specified as the open time of the OHLC candle. So you'll see candle updates with new candle timestamp come through.
I do not know if this would be consider correct/desired functionality by the community, or if the open-time should be set as close-time - period so it is constant? It would be a trivial change to var candle = this.ParseCandle(token[1], marketSymbol, interval * 60, 2, 3, 4, 5, 0, TimestampType.UnixSeconds, 7, null, 6); you are welcome to make.

* Update .gitignore

Navigating to a folder using the "Finder" on Mac generates a .DS_Store file holding metadata about the folder (e.g. thumbnails etc.). These files can pollute your git commits and are annoying.

* Update MovingAverageCalculator.cs

Pull methods and expose accessors on base class for consistency.

* Implemented ws-candles for Kraken

* Update ExchangeKrakenAPI.cs

fix candle open time as close time  -interval

Author: jdx-john

src/ExchangeSharp/API/Exchanges/Kraken/ExchangeKrakenAPI.cs

@@ -843,30 +843,77 @@ protected override async Task OnCancelOrderAsync(string orderId, string marketSy
 			await MakeJsonRequestAsync<JToken>("/0/private/CancelOrder", null, payload);
 		}
 
+		protected override async Task<IWebSocket> OnGetCandlesWebSocketAsync(Func<MarketCandle, Task> callbackAsync, int periodSeconds, params string[] marketSymbols)
+		{
+			if (marketSymbols == null || marketSymbols.Length == 0)
+			{
+				marketSymbols = (await GetMarketSymbolsAsync(true)).ToArray();
+			}
+			//kraken has multiple OHLC channels named ohlc-1|5|15|30|60|240|1440|10080|21600 with interval specified in minutes
+			int interval = periodSeconds / 60;
+
+			return await ConnectWebSocketAsync(null, messageCallback: async (_socket, msg) =>
+			{
+				/*
+				https://docs.kraken.com/websockets/#message-ohlc
+				[0]channelID integer Channel ID of subscription -deprecated, use channelName and pair
+				[1]Array array
+				-time    decimal Begin time of interval, in seconds since epoch
+				-etime   decimal End time of interval, in seconds since epoch
+				-open    decimal Open price of interval
+				-high    decimal High price within interval
+				-low decimal Low price within interval
+				-close   decimal Close price of interval
+				-vwap    decimal Volume weighted average price within interval
+				-volume  decimal Accumulated volume within interval
+				-count   integer Number of trades within interval
+				[2]channelName string Channel Name of subscription
+				[3]pair    string Asset pair
+				*/
+				if (JToken.Parse(msg.ToStringFromUTF8()) is JArray token && token[2].ToStringInvariant() == ($"ohlc-{interval}"))
+				{
+					string marketSymbol = token[3].ToStringInvariant();
+					//Kraken updates the candle open time to the current time, but we want it as open-time i.e. close-time - interval
+					token[1][0] = token[1][1].ConvertInvariant<long>() - interval * 60;
+					var candle = this.ParseCandle(token[1], marketSymbol, interval * 60, 2, 3, 4, 5, 0, TimestampType.UnixSeconds, 7, null, 6);
+					await callbackAsync(candle);
+				}
+			}, connectCallback: async (_socket) =>
+			{
+				List<string> marketSymbolList = await GetMarketSymbolList(marketSymbols);
+				await _socket.SendMessageAsync(new
+				{
+					@event = "subscribe",
+					pair = marketSymbolList,
+					subscription = new { name = "ohlc", interval = interval }
+				});
+			});
+		}
+
 		protected override async Task<IWebSocket> OnGetTickersWebSocketAsync(Action<IReadOnlyCollection<KeyValuePair<string, ExchangeTicker>>> tickers, params string[] marketSymbols)
 		{
 			if (marketSymbols == null || marketSymbols.Length == 0)
 			{
 				marketSymbols = (await GetMarketSymbolsAsync(true)).ToArray();
 			}
 			return await ConnectWebSocketAsync(null, messageCallback: async (_socket, msg) =>
-		   {
-			   if (JToken.Parse(msg.ToStringFromUTF8()) is JArray token)
-			   {
-				   var exchangeTicker = await ConvertToExchangeTickerAsync(token[3].ToString(), token[1]);
-				   var kv = new KeyValuePair<string, ExchangeTicker>(exchangeTicker.MarketSymbol, exchangeTicker);
-				   tickers(new List<KeyValuePair<string, ExchangeTicker>> { kv });
-			   }
-		   }, connectCallback: async (_socket) =>
-		   {
-			   List<string> marketSymbolList = await GetMarketSymbolList(marketSymbols);
-			   await _socket.SendMessageAsync(new
-			   {
-				   @event = "subscribe",
-				   pair = marketSymbolList,
-				   subscription = new { name = "ticker" }
-			   });
-		   });
+			{
+				if (JToken.Parse(msg.ToStringFromUTF8()) is JArray token)
+				{
+					var exchangeTicker = await ConvertToExchangeTickerAsync(token[3].ToString(), token[1]);
+					var kv = new KeyValuePair<string, ExchangeTicker>(exchangeTicker.MarketSymbol, exchangeTicker);
+					tickers(new List<KeyValuePair<string, ExchangeTicker>> { kv });
+				}
+			}, connectCallback: async (_socket) =>
+			{
+				List<string> marketSymbolList = await GetMarketSymbolList(marketSymbols);
+				await _socket.SendMessageAsync(new
+				{
+					@event = "subscribe",
+					pair = marketSymbolList,
+					subscription = new { name = "ticker" }
+				});
+			});
 		}
 
 		protected override async Task<IWebSocket> OnGetTradesWebSocketAsync(Func<KeyValuePair<string, ExchangeTrade>, Task> callback, params string[] marketSymbols)

src/ExchangeSharp/API/Exchanges/_Base/ExchangeAPI.cs

@@ -178,7 +178,7 @@ protected virtual Task<ExchangeMarginPositionResult> OnGetOpenPositionAsync(stri
 			throw new NotImplementedException();
 		protected virtual Task<ExchangeCloseMarginPositionResult> OnCloseMarginPositionAsync(string marketSymbol) =>
 			throw new NotImplementedException();
-		protected virtual Task<IWebSocket> OnGetCandlesWebSocketAsync(Func<IReadOnlyCollection<MarketCandle>, Task> callbackAsync, params string[] marketSymbols) =>
+		protected virtual Task<IWebSocket> OnGetCandlesWebSocketAsync(Func<MarketCandle, Task> callbackAsync, int periodSeconds, params string[] marketSymbols) =>
 			throw new NotImplementedException();
 		protected virtual Task<IWebSocket> OnGetTickersWebSocketAsync(Action<IReadOnlyCollection<KeyValuePair<string, ExchangeTicker>>> tickers, params string[] marketSymbols) =>
 			throw new NotImplementedException();
@@ -1005,10 +1005,10 @@ public virtual async Task<ExchangeCloseMarginPositionResult> CloseMarginPosition
 		/// <param name="callbackAsync">Callback</param>
 		/// <param name="marketSymbols">Market Symbols</param>
 		/// <returns>Web socket, call Dispose to close</returns>
-		public virtual Task<IWebSocket> GetCandlesWebSocketAsync(Func<IReadOnlyCollection<MarketCandle>, Task> callbackAsync, params string[] marketSymbols)
+		public virtual Task<IWebSocket> GetCandlesWebSocketAsync(Func<MarketCandle, Task> callbackAsync, int periodSeconds, params string[] marketSymbols)
 		{
 			callbackAsync.ThrowIfNull(nameof(callbackAsync), "Callback must not be null");
-			return OnGetCandlesWebSocketAsync(callbackAsync, marketSymbols);
+			return OnGetCandlesWebSocketAsync(callbackAsync, periodSeconds, marketSymbols);
 		}
 
 		/// <summary>

src/ExchangeSharp/API/Exchanges/_Base/IExchangeAPI.cs

@@ -241,9 +241,10 @@ public interface IExchangeAPI : IDisposable, IBaseAPI, IOrderBookProvider
 		/// Gets Candles (OHLC) websocket
 		/// </summary>
 		/// <param name="callbackAsync">Callback</param>
+		/// <param name="periodSeconds">Candle interval in seconds</param>
 		/// <param name="marketSymbols">Market Symbols</param>
 		/// <returns>Web socket, call Dispose to close</returns>
-		Task<IWebSocket> GetCandlesWebSocketAsync(Func<IReadOnlyCollection<MarketCandle>, Task> callbackAsync, params string[] marketSymbols);
+		Task<IWebSocket> GetCandlesWebSocketAsync(Func<MarketCandle, Task> callbackAsync, int periodSeconds, params string[] marketSymbols);
 
 		/// <summary>
 		/// Get all tickers via web socket

src/ExchangeSharpConsole/Options/CandlesOption.cs

@@ -7,15 +7,15 @@
 namespace ExchangeSharpConsole.Options
 {
 	[Verb("candles", HelpText = "Prints all candle data from a 12 days period for the given exchange.")]
-	public class CandlesOption : BaseOption, IOptionPerExchange, IOptionPerMarketSymbol
+	public class CandlesOption : BaseOption, IOptionPerExchange, IOptionPerMarketSymbol, IOptionWithPeriod
 	{
 		public override async Task RunCommand()
 		{
 			using var api = GetExchangeInstance(ExchangeName);
 
 			var candles = await api.GetCandlesAsync(
 				MarketSymbol,
-				1800,
+				Period,
 				//TODO: Add interfaces for start and end date
 				CryptoUtility.UtcNow.AddDays(-12),
 				CryptoUtility.UtcNow
@@ -32,5 +32,7 @@ public override async Task RunCommand()
 		public string ExchangeName { get; set; }
 
 		public string MarketSymbol { get; set; }
+
+		public int Period { get; set; }
 	}
 }

src/ExchangeSharpConsole/Options/Interfaces/IOptionWithPeriod.cs

@@ -0,0 +1,11 @@
+using CommandLine;
+
+namespace ExchangeSharpConsole.Options.Interfaces
+{
+	public interface IOptionWithPeriod
+	{
+		[Option('p', "period", Default = 1800,
+			HelpText = "Period in seconds.")]
+		int Period { get; set; }
+	}
+}

src/ExchangeSharpConsole/Options/WebSocketsCandesOption.cs

@@ -0,0 +1,41 @@
+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("ws-candles", HelpText =
+		"Connects to the given exchange websocket and keeps printing the candles from that exchange." +
+		"If market symbol is not set then uses all.")]
+	public class WebSocketsCandlesOption : BaseOption, IOptionPerExchange, IOptionWithMultipleMarketSymbol, IOptionWithPeriod
+	{
+		public override async Task RunCommand()
+		{
+			async Task<IWebSocket> GetWebSocket(IExchangeAPI api)
+			{
+				var symbols = await ValidateMarketSymbolsAsync(api, MarketSymbols.ToArray(), true);
+
+				return await api.GetCandlesWebSocketAsync(candle =>
+				{
+					Console.WriteLine($"Market {candle.Name,8}: {candle}");
+					return Task.CompletedTask;
+				},
+				Period,
+				symbols
+				);
+			}
+
+			await RunWebSocket(ExchangeName, GetWebSocket);
+		}
+
+		public string ExchangeName { get; set; }
+
+		public IEnumerable<string> MarketSymbols { get; set; }
+
+		public int Period { get; set; }
+	}
+}

src/ExchangeSharpConsole/Program.cs

@@ -35,7 +35,8 @@ public partial class Program
 			typeof(TradeHistoryOption),
 			typeof(WebSocketsOrderbookOption),
 			typeof(WebSocketsTickersOption),
-			typeof(WebSocketsTradesOption)
+			typeof(WebSocketsTradesOption),
+			typeof(WebSocketsCandlesOption)
 		};
 
 		public Program()