Kraken symbol refactor (#449)

* Start work on kraken symbol overhaul

* Fix Kraken exchange to global market symbol

* Kraken global to market conversion working, except for .d pairs

* Simplify Kraken caching

* Better name

* Remove redundant code

Author: jjxtra

ExchangeSharp/API/Exchanges/Kraken/ExchangeKrakenAPI.cs

@@ -27,17 +27,6 @@ public sealed partial class ExchangeKrakenAPI : ExchangeAPI
     {
         public override string BaseUrl { get; set; } = "https://api.kraken.com";
 		public override string BaseUrlWebSocket { get; set; } = "wss://ws.kraken.com";
-		static ExchangeKrakenAPI()
-        {
-            Dictionary<string, string> d = normalizedSymbolToExchangeSymbol as Dictionary<string, string>;
-            foreach (KeyValuePair<string, string> kv in exchangeSymbolToNormalizedSymbol)
-            {
-                if (!d.ContainsKey(kv.Value))
-                {
-                    d.Add(kv.Value, kv.Key);
-                }
-            }
-        }
 
         public ExchangeKrakenAPI()
         {
@@ -47,164 +36,126 @@ public ExchangeKrakenAPI()
             NonceStyle = NonceStyle.UnixMilliseconds;
         }
 
-        public override async Task<string> ExchangeMarketSymbolToGlobalMarketSymbolAsync(string marketSymbol)
+        private IReadOnlyDictionary<string, string> exchangeCurrencyToNormalizedCurrency = new Dictionary<string, string>();
+        private IReadOnlyDictionary<string, string> normalizedCurrencyToExchangeCurrency = new Dictionary<string, string>();
+        private IReadOnlyDictionary<string, string> exchangeSymbolToNormalizedSymbol = new Dictionary<string, string>();
+        private IReadOnlyDictionary<string, string> normalizedSymbolToExchangeSymbol = new Dictionary<string, string>();
+        private IReadOnlyDictionary<string, string> exchangeCurrenciesToMarketSymbol = new Dictionary<string, string>();
+
+        static ExchangeKrakenAPI()
         {
-            if (exchangeSymbolToNormalizedSymbol.TryGetValue(marketSymbol, out string normalizedSymbol))
+            ExchangeGlobalCurrencyReplacements[typeof(ExchangeKrakenAPI)] = new KeyValuePair<string, string>[]
             {
-                int pos;
-                if (marketSymbol.StartsWith("WAVES"))
+                new KeyValuePair<string, string>("XBT", "BTC"),
+                new KeyValuePair<string, string>("XDG", "DOGE")
+            };
+        }
+
+        /// <summary>
+        /// Populate dictionaries to deal with Kraken weirdness in currency and market names, will use cache if it exists
+        /// </summary>
+        /// <returns>Task</returns>
+        private async Task PopulateLookupTables()
+        {
+            await Cache.Get<object>(nameof(PopulateLookupTables), async () =>
+            {
+                IReadOnlyDictionary<string, ExchangeCurrency> currencies = await GetCurrenciesAsync();
+                ExchangeMarket[] markets = (await GetMarketSymbolsMetadataAsync())?.ToArray();
+                if (markets == null || markets.Length == 0)
                 {
-                    pos = 5;
+                    return new CachedItem<object>();
                 }
-                else
+
+                Dictionary<string, string> exchangeCurrencyToNormalizedCurrencyNew = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> normalizedCurrencyToExchangeCurrencyNew = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> exchangeSymbolToNormalizedSymbolNew = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> normalizedSymbolToExchangeSymbolNew = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                Dictionary<string, string> exchangeCurrenciesToMarketSymbolNew = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+
+                foreach (KeyValuePair<string, ExchangeCurrency> kv in currencies)
                 {
-                    pos = (normalizedSymbol.Length == 6 ? 3 : (normalizedSymbol.Length == 7 ? 4 : throw new InvalidOperationException("Cannot normalize symbol " + normalizedSymbol)));
+                    string altName = kv.Value.AltName;
+                    switch (altName.ToLowerInvariant())
+                    {
+                        // wtf kraken...
+                        case "xbt": altName = "BTC"; break;
+                        case "xdg": altName = "DOGE"; break;
+                    }
+                    exchangeCurrencyToNormalizedCurrencyNew[kv.Value.Name] = altName;
+                    normalizedCurrencyToExchangeCurrencyNew[altName] = kv.Value.Name;
                 }
-                return await base.ExchangeMarketSymbolToGlobalMarketSymbolWithSeparatorAsync(normalizedSymbol.Substring(0, pos) + GlobalMarketSymbolSeparator + normalizedSymbol.Substring(pos), GlobalMarketSymbolSeparator);
-            }
 
-            # region if the initial fails, we try to use another method
-            var symbols = (await GetMarketSymbolsMetadataAsync()).ToList();
-            var symbol = symbols.FirstOrDefault(a => a.MarketSymbol.Replace("/", "").Equals(marketSymbol));
-            string _marketSymbol = symbol.BaseCurrency + symbol.QuoteCurrency;
-            if (exchangeSymbolToNormalizedSymbol.TryGetValue(_marketSymbol, out normalizedSymbol))
-            {
-                int pos = (normalizedSymbol.Length == 6 ? 3 : (normalizedSymbol.Length == 7 ? 4 : throw new InvalidOperationException("Cannot normalize symbol " + normalizedSymbol)));
-                return await base.ExchangeMarketSymbolToGlobalMarketSymbolWithSeparatorAsync(normalizedSymbol.Substring(0, pos) + GlobalMarketSymbolSeparator + normalizedSymbol.Substring(pos), GlobalMarketSymbolSeparator);
-            }
-            #endregion
+                foreach (ExchangeMarket market in markets.Where(m => !m.MarketSymbol.Contains(".d")))
+                {
+                    string baseSymbol = market.BaseCurrency;
+                    string quoteSymbol = market.QuoteCurrency;
+                    string baseNorm = exchangeCurrencyToNormalizedCurrencyNew[market.BaseCurrency];
+                    string quoteNorm = exchangeCurrencyToNormalizedCurrencyNew[market.QuoteCurrency];
+                    string marketSymbolNorm = baseNorm + quoteNorm;
+                    string marketSymbol = market.MarketSymbol;
+                    exchangeSymbolToNormalizedSymbolNew[marketSymbol] = marketSymbolNorm;
+                    normalizedSymbolToExchangeSymbolNew[marketSymbolNorm] = marketSymbol;
+                    exchangeCurrenciesToMarketSymbolNew[baseSymbol + quoteSymbol] = marketSymbol;
+                }
 
-            throw new ArgumentException($"Symbol {marketSymbol} not found in Kraken lookup table");
+                exchangeCurrencyToNormalizedCurrency = exchangeCurrencyToNormalizedCurrencyNew;
+                normalizedCurrencyToExchangeCurrency = normalizedCurrencyToExchangeCurrencyNew;
+                exchangeSymbolToNormalizedSymbol = exchangeSymbolToNormalizedSymbolNew;
+                normalizedSymbolToExchangeSymbol = normalizedSymbolToExchangeSymbolNew;
+                exchangeCurrenciesToMarketSymbol = exchangeCurrenciesToMarketSymbolNew;
+
+                return new CachedItem<object>(new object(), CryptoUtility.UtcNow.AddHours(4.0));
+            });
         }
 
-        public override Task<string> GlobalMarketSymbolToExchangeMarketSymbolAsync(string marketSymbol)
+        public override async Task<(string baseCurrency, string quoteCurrency)> ExchangeMarketSymbolToCurrenciesAsync(string marketSymbol)
         {
-            if (normalizedSymbolToExchangeSymbol.TryGetValue(marketSymbol.Replace(GlobalMarketSymbolSeparator.ToString(), string.Empty), out string exchangeSymbol))
+            ExchangeMarket market = await GetExchangeMarketFromCacheAsync(marketSymbol);
+            if (market == null)
             {
-                return Task.FromResult(exchangeSymbol);
+                throw new ArgumentException("Unable to get currencies for market symbol " + marketSymbol);
             }
+            return (market.BaseCurrency, market.QuoteCurrency);
+        }
 
-            // not found, reverse the pair
-            int idx = marketSymbol.IndexOf(GlobalMarketSymbolSeparator);
-            marketSymbol = marketSymbol.Substring(idx + 1) + marketSymbol.Substring(0, idx);
-            if (normalizedSymbolToExchangeSymbol.TryGetValue(marketSymbol.Replace(GlobalMarketSymbolSeparator.ToString(), string.Empty), out exchangeSymbol))
+        public override async Task<string> ExchangeMarketSymbolToGlobalMarketSymbolAsync(string marketSymbol)
+        {
+            await PopulateLookupTables();
+            var (baseCurrency, quoteCurrency) = await ExchangeMarketSymbolToCurrenciesAsync(marketSymbol);
+            if (!exchangeCurrencyToNormalizedCurrency.TryGetValue(baseCurrency, out string baseCurrencyNormalized))
             {
-                return Task.FromResult(exchangeSymbol);
+                baseCurrencyNormalized = baseCurrency;
             }
-
-            throw new ArgumentException($"Symbol {marketSymbol} not found in Kraken lookup table");
+            if (!exchangeCurrencyToNormalizedCurrency.TryGetValue(quoteCurrency, out string quoteCurrencyNormalized))
+            {
+                quoteCurrencyNormalized = quoteCurrency;
+            }
+            return baseCurrencyNormalized + GlobalMarketSymbolSeparatorString + quoteCurrencyNormalized;
         }
 
-        /// <summary>
-        /// Change Kraken symbols to more common sense symbols
-        /// </summary>
-        private static readonly IReadOnlyDictionary<string, string> exchangeSymbolToNormalizedSymbol = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        public override async Task<string> GlobalMarketSymbolToExchangeMarketSymbolAsync(string marketSymbol)
         {
-		   { "ADACAD" , "adacad" },
-			{ "ADAETH" , "adaeth" },
-			{ "ADAEUR" , "adaeur" },
-			{ "ADAUSD" , "adausd" },
-			{ "ADAXBT" , "adabtc" },
-            { "ATOMCAD", "atomcad" },
-            { "ATOMETH", "atometh" },
-            { "ATOMEUR", "atomeur" },
-            { "ATOMUSD", "atomusd" },
-            { "ATOMXBT", "atombtc" },
-            { "BATETH", "bateth" },
-            { "BATEUR", "bateur" },
-            { "BATUSD", "batusd" },
-            { "BATXBT", "batbtc" },
-            { "BCHEUR" , "bcheur" },
-			{ "BCHUSD" , "bchusd" },
-			{ "BCHXBT" , "bchbtc" },
-			{ "BSVEUR" , "bsveur" },
-			{ "BSVUSD" , "bsvusd" },
-			{ "BSVXBT" , "bsvbtc" },
-			{ "DASHEUR" , "dasheur" },
-			{ "DASHUSD" , "dashusd" },
-			{ "DASHXBT" , "dashbtc" },
-			{ "EOSETH" , "eoseth" },
-			{ "EOSEUR" , "eoseur" },
-			{ "EOSUSD" , "eosusd" },
-			{ "EOSXBT" , "eosbtc" },
-            { "ETCETH" , "etceth" },
-            { "ETCEUR" , "etceur" },
-            { "ETCUSD" , "etcusd" },
-            { "ETCXBT" , "etcbtc" },
-            { "ETHCAD" , "ethcad" },
-            { "GNOETH" , "gnoeth" },
-			{ "GNOEUR" , "gnoeur" },
-			{ "GNOUSD" , "gnousd" },
-			{ "GNOXBT" , "gnobtc" },
-			{ "QTUMCAD" , "qtumcad" },
-			{ "QTUMETH" , "qtumeth" },
-			{ "QTUMEUR" , "qtumeur" },
-			{ "QTUMUSD" , "qtumusd" },
-			{ "QTUMXBT" , "qtumbtc" },
-            { "USDTZUSD" , "usdtusd" },
-            { "WAVESETH" , "waveseth" },
-            { "WAVESEUR" , "waveseur" },
-            { "WAVESUSD" , "wavesusd" },
-            { "WAVESXBT" , "wavesbtc" },
-            { "XETCXETH" , "etceth" },
-			{ "XETCXXBT" , "etcbtc" },
-			{ "XETCZEUR" , "etceur" },
-			{ "XETCZUSD" , "etcusd" },
-			{ "XETHXXBT" , "ethbtc" },
-			{ "XETHXXBT.d" , "ethbtcd" },
-			{ "XETHZCAD" , "ethcad" },
-			{ "XETHZCAD.d" , "ethcadd" },
-			{ "XETHZEUR" , "etheur" },
-			{ "XETHZEUR.d" , "etheurd" },
-			{ "XETHZGBP" , "ethgbp" },
-			{ "XETHZGBP.d" , "ethgbpd" },
-			{ "XETHZJPY" , "ethjpy" },
-			{ "XETHZJPY.d" , "ethjpyd" },
-			{ "XETHZUSD" , "ethusd" },
-			{ "XETHZUSD.d" , "ethusdd" },
-			{ "XLTCXXBT" , "ltcbtc" },
-			{ "XLTCZEUR" , "ltceur" },
-			{ "XLTCZUSD" , "ltcusd" },
-			{ "XMLNXETH" , "mlneth" },
-			{ "XMLNXXBT" , "mlnbtc" },
-			{ "XREPXETH" , "repeth" },
-			{ "XREPXXBT" , "repbtc" },
-			{ "XREPZEUR" , "repeur" },
-			{ "XREPZUSD" , "repusd" },
-			{ "XTZCAD" , "xtzcad" },
-			{ "XTZETH" , "xtzeth" },
-			{ "XTZEUR" , "xtzeur" },
-			{ "XTZUSD" , "xtzusd" },
-			{ "XTZXBT" , "xtzbtc" },
-			{ "XXBTZCAD" , "btccad" },
-			{ "XXBTZCAD.d" , "btccadd" },
-			{ "XXBTZEUR" , "btceur" },
-			{ "XXBTZEUR.d" , "btceurd" },
-			{ "XXBTZGBP" , "btcgbp" },
-			{ "XXBTZGBP.d" , "btcgbpd" },
-			{ "XXBTZJPY" , "btcjpy" },
-			{ "XXBTZJPY.d" , "btcjpyd" },
-			{ "XXBTZUSD" , "btcusd" },
-			{ "XXBTZUSD.d" , "btcusdd" },
-			{ "XXDGXXBT" , "xdgbtc" },
-			{ "XXLMXXBT" , "xlmbtc" },
-			{ "XXLMZEUR" , "xlmeur" },
-			{ "XXLMZUSD" , "xlmusd" },
-			{ "XXMRXXBT" , "xmrbtc" },
-			{ "XXMRZEUR" , "xmreur" },
-			{ "XXMRZUSD" , "xmrusd" },
-			{ "XXRPXXBT" , "xrpbtc" },
-			{ "XXRPZCAD" , "xrpcad" },
-			{ "XXRPZEUR" , "xrpeur" },
-			{ "XXRPZJPY" , "xrpjpy" },
-			{ "XXRPZUSD" , "xrpusd" },
-			{ "XZECXXBT" , "zecbtc" },
-			{ "XZECZEUR" , "zeceur" },
-			{ "XZECZJPY" , "zecjpy" },
-			{ "XZECZUSD" , "zecusd" }
-		};
-
-        private static readonly IReadOnlyDictionary<string, string> normalizedSymbolToExchangeSymbol = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            await PopulateLookupTables();
+            string[] pieces = marketSymbol.Split('-');
+            if (pieces.Length < 2)
+            {
+                throw new ArgumentException("Market symbol must be at least two pieces");
+            }
+            string marketSymbol2 = pieces[0] + pieces[1];
+            if (!normalizedCurrencyToExchangeCurrency.TryGetValue(pieces[0], out string baseCurrencyExchange))
+            {
+                baseCurrencyExchange = pieces[0];
+            }
+            if (!normalizedCurrencyToExchangeCurrency.TryGetValue(pieces[1], out string quoteCurrencyExchange))
+            {
+                quoteCurrencyExchange = pieces[1];
+            }
+            if (!exchangeCurrenciesToMarketSymbol.TryGetValue(baseCurrencyExchange + quoteCurrencyExchange, out string exchangeMarketSymbol))
+            {
+                throw new ArgumentException("Unable to find exchange market for global market symbol " + marketSymbol);
+            }
+            return exchangeMarketSymbol;
+        }
 
         protected override JToken CheckJsonResponse(JToken json)
         {
@@ -280,6 +231,7 @@ private async Task<ExchangeOrderResult> ParseHistoryOrder(string orderId, JToken
 
         private async Task<IEnumerable<ExchangeOrderResult>> QueryOrdersAsync(string symbol, string path)
         {
+            await PopulateLookupTables();
             List<ExchangeOrderResult> orders = new List<ExchangeOrderResult>();
             JToken result = await MakeJsonRequestAsync<JToken>(path, null, await GetNoncePayloadAsync());
             result = result["open"];
@@ -299,6 +251,7 @@ private async Task<IEnumerable<ExchangeOrderResult>> QueryOrdersAsync(string sym
 
         private async Task<IEnumerable<ExchangeOrderResult>> QueryClosedOrdersAsync(string symbol, string path)
         {
+            await PopulateLookupTables();
             List<ExchangeOrderResult> orders = new List<ExchangeOrderResult>();
             JToken result = await MakeJsonRequestAsync<JToken>(path, null, await GetNoncePayloadAsync());
             result = result["closed"];
@@ -325,6 +278,7 @@ private async Task<IEnumerable<ExchangeOrderResult>> QueryClosedOrdersAsync(stri
 
         private async Task<IEnumerable<ExchangeOrderResult>> QueryHistoryOrdersAsync(string symbol, string path)
         {
+            await PopulateLookupTables();
             List<ExchangeOrderResult> orders = new List<ExchangeOrderResult>();
             JToken result = await MakeJsonRequestAsync<JToken>(path, null, await GetNoncePayloadAsync());
             result = result["trades"];
@@ -421,7 +375,8 @@ protected override async Task<IReadOnlyDictionary<string, ExchangeCurrency>> OnG
                 {
                     CoinType = token.Value["aclass"].ToStringInvariant(),
                     Name = token.Name,
-                    FullName = token.Value["altname"].ToStringInvariant()
+                    FullName = token.Name,
+                    AltName = token.Value["altname"].ToStringInvariant()
                 };
 
                 currencies[coin.Name] = coin;
@@ -433,9 +388,7 @@ protected override async Task<IReadOnlyDictionary<string, ExchangeCurrency>> OnG
         protected override async Task<IEnumerable<string>> OnGetMarketSymbolsAsync()
         {
             JToken result = await MakeJsonRequestAsync<JToken>("/0/public/AssetPairs");
-            return (from prop in result.Children<JProperty>()
-					where !prop.Name.Contains(".d")
-					select prop.Value["wsname"].ToStringInvariant()).ToArray();
+            return result.Children<JProperty>().Where(p => !p.Name.Contains(".d")).Select(p => p.Name).ToArray();
         }
 
         protected override async Task<IEnumerable<ExchangeMarket>> OnGetMarketSymbolsMetadataAsync()
@@ -536,15 +489,14 @@ protected override async Task<IEnumerable<ExchangeMarket>> OnGetMarketSymbolsMet
             JToken allPairs = await MakeJsonRequestAsync<JToken>("/0/public/AssetPairs");
             var res = (from prop in allPairs.Children<JProperty>() select prop).ToArray();
 
-            foreach (JProperty prop in res)
+            foreach (JProperty prop in res.Where(p => !p.Name.EndsWith(".d")))
             {
                 JToken pair = prop.Value;
                 var quantityStepSize = Math.Pow(0.1, pair["lot_decimals"].ConvertInvariant<int>()).ConvertInvariant<decimal>();
                 var market = new ExchangeMarket
                 {
-                    IsActive = !prop.Name.Contains(".d"),
-                    MarketSymbol = (pair["wsname"].ToStringInvariant() != "" ? 
-						pair["wsname"].ToStringInvariant() : pair["altname"].ToStringInvariant()).Replace("/", string.Empty),
+                    IsActive = true,
+                    MarketSymbol = prop.Name,
                     MinTradeSize = quantityStepSize,
                     MarginEnabled = pair["leverage_buy"].Children().Any() || pair["leverage_sell"].Children().Any(),
                     BaseCurrency = pair["base"].ToStringInvariant(),

ExchangeSharp/API/Exchanges/_Base/ExchangeAPI.cs

@@ -429,10 +429,10 @@ public virtual async Task<string> ExchangeMarketSymbolToGlobalMarketSymbolAsync(
         /// <param name="baseCurrency">Base currency</param>
         /// <param name="quoteCurrency">Quote currency</param>
         /// <returns>Exchange market symbol</returns>
-        public virtual string CurrenciesToExchangeMarketSymbol(string baseCurrency, string quoteCurrency)
+        public virtual Task<string> CurrenciesToExchangeMarketSymbol(string baseCurrency, string quoteCurrency)
         {
             string symbol = (MarketSymbolIsReversed ? $"{quoteCurrency}{MarketSymbolSeparator}{baseCurrency}" : $"{baseCurrency}{MarketSymbolSeparator}{quoteCurrency}");
-            return (MarketSymbolIsUppercase ? symbol.ToUpperInvariant() : symbol);
+            return Task.FromResult(MarketSymbolIsUppercase ? symbol.ToUpperInvariant() : symbol);
         }
 
         /// <summary>

ExchangeSharp/Model/ExchangeCurrency.cs

@@ -20,6 +20,9 @@ public sealed class ExchangeCurrency
         /// <summary>Full name of the currency. Eg. Ethereum</summary>
         public string FullName { get; set; }
 
+        /// <summary>Alternate name, null if none</summary>
+        public string AltName { get; set; }
+
         /// <summary>The transaction fee.</summary>
         public decimal TxFee { get; set; }