Feature/user provider (#13)

Added SetApiCredentials(ExchagneCredentials credentials) to ExchangeRestClient and ExchangeSocketClient
Added single exchange subscription methods to ExchangeSocketClient
Added (I)ExchangeUserClientProvider allowing for easy client management when handling multiple users
Added constructor to ExchangeCredentials for Dictionary<string, ApiCredentials>

Author: JKorf

CryptoClients.Net/Clients/ExchangeUserClientProvider.cs

@@ -366,6 +366,39 @@ public IEnumerable<ISharedClient> GetExchangeSharedClients(string name, TradingM
             return result.ToList();
         }
 
+        /// <inheritdoc />
+        public void SetApiCredentials(ExchangeCredentials credentials)
+        {
+            void SetCredentialsIfNotNull(string exchange, ApiCredentials? credentials)
+            {
+                if (credentials == null)
+                    return;
+
+                SetApiCredentials(exchange, credentials.Key, credentials.Secret, credentials.Pass);
+            }
+
+            SetCredentialsIfNotNull(Exchange.Binance, credentials.Binance);
+            SetCredentialsIfNotNull(Exchange.BingX, credentials.BingX);
+            SetCredentialsIfNotNull(Exchange.Bitfinex, credentials.Bitfinex);
+            SetCredentialsIfNotNull(Exchange.Bitget, credentials.Bitget);
+            SetCredentialsIfNotNull(Exchange.BitMart, credentials.BitMart);
+            SetCredentialsIfNotNull(Exchange.BitMEX, credentials.BitMEX);
+            SetCredentialsIfNotNull(Exchange.Bybit, credentials.Bybit);
+            SetCredentialsIfNotNull(Exchange.Coinbase, credentials.Coinbase);
+            SetCredentialsIfNotNull(Exchange.CoinEx, credentials.CoinEx);
+            SetCredentialsIfNotNull(Exchange.CryptoCom, credentials.CryptoCom);
+            SetCredentialsIfNotNull(Exchange.DeepCoin, credentials.DeepCoin);
+            SetCredentialsIfNotNull(Exchange.GateIo, credentials.GateIo);
+            SetCredentialsIfNotNull(Exchange.HTX, credentials.HTX);
+            SetCredentialsIfNotNull(Exchange.HyperLiquid, credentials.HyperLiquid);
+            SetCredentialsIfNotNull(Exchange.Kraken, credentials.Kraken);
+            SetCredentialsIfNotNull(Exchange.Kucoin, credentials.Kucoin);
+            SetCredentialsIfNotNull(Exchange.Mexc, credentials.Mexc);
+            SetCredentialsIfNotNull(Exchange.OKX, credentials.OKX);
+            SetCredentialsIfNotNull(Exchange.WhiteBit, credentials.WhiteBit);
+            SetCredentialsIfNotNull(Exchange.XT, credentials.XT);
+        }
+
         /// <inheritdoc />
         public void SetApiCredentials(string exchange, string apiKey, string apiSecret, string? apiPass = null)
         {

CryptoClients.Net/Clients/Rest/ExchangeRestClient.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -21,6 +22,18 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Balance
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToBalanceUpdatesAsync(
+            string exchange,
+            SubscribeBalancesRequest request,
+            Action<ExchangeEvent<SharedBalance[]>> handler,
+            ExchangeWebResult<string>[]? listenKeyResults = null,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToBalanceUpdatesAsync(request, handler, new[] { exchange }, listenKeyResults, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToBalanceUpdatesAsync(
             SubscribeBalancesRequest request,

CryptoClients.Net/Clients/Socket/ExchangeSocketClient.Balance.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -20,6 +21,17 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Book Ticker
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToBookTickerUpdatesAsync(
+            string exchange,
+            SubscribeBookTickerRequest request,
+            Action<ExchangeEvent<SharedBookTicker>> handler,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToBookTickerUpdatesAsync(request, handler, new[] { exchange }, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToBookTickerUpdatesAsync(SubscribeBookTickerRequest request, Action<ExchangeEvent<SharedBookTicker>> handler, IEnumerable<string>? exchanges = null, CancellationToken ct = default)
         {

CryptoClients.Net/Clients/Socket/ExchangeSocketClient.BookTicker.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -20,6 +21,18 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Futures Order
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToFuturesOrderUpdatesAsync(
+            string exchange,
+            SubscribeFuturesOrderRequest request,
+            Action<ExchangeEvent<SharedFuturesOrder[]>> handler,
+            ExchangeWebResult<string>[]? listenKeyResults = null,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToFuturesOrderUpdatesAsync(request, handler, new[] { exchange }, listenKeyResults, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToFuturesOrderUpdatesAsync(
             SubscribeFuturesOrderRequest request,

CryptoClients.Net/Clients/Socket/ExchangeSocketClient.FuturesOrder.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -21,6 +22,17 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Kline
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToKlineUpdatesAsync(
+            string exchange,
+            SubscribeKlineRequest request,
+            Action<ExchangeEvent<SharedKline>> handler,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToKlineUpdatesAsync(request, handler, new[] { exchange }, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToKlineUpdatesAsync(SubscribeKlineRequest request, Action<ExchangeEvent<SharedKline>> handler, IEnumerable<string>? exchanges = null, CancellationToken ct = default)
         {

CryptoClients.Net/Clients/Socket/ExchangeSocketClient.Kline.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -20,6 +21,17 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Order Book
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToOrderBookUpdatesAsync(
+            string exchange,
+            SubscribeOrderBookRequest request,
+            Action<ExchangeEvent<SharedOrderBook>> handler,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToOrderBookUpdatesAsync(request, handler, new[] { exchange }, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToOrderBookUpdatesAsync(SubscribeOrderBookRequest request, Action<ExchangeEvent<SharedOrderBook>> handler, IEnumerable<string>? exchanges = null, CancellationToken ct = default)
         {

CryptoClients.Net/Clients/Socket/ExchangeSocketClient.OrderBook.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -20,6 +21,18 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Position
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToPositionUpdatesAsync(
+            string exchange,
+            SubscribePositionRequest request,
+            Action<ExchangeEvent<SharedPosition[]>> handler,
+            ExchangeWebResult<string>[]? listenKeyResults = null,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToPositionUpdatesAsync(request, handler, new[] { exchange }, listenKeyResults, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToPositionUpdatesAsync(
             SubscribePositionRequest request,

CryptoClients.Net/Clients/Socket/ExchangeSocketClient.Position.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -18,6 +19,18 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Spot Order
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToSpotOrderUpdatesAsync(
+            string exchange,
+            SubscribeSpotOrderRequest request,
+            Action<ExchangeEvent<SharedSpotOrder[]>> handler,
+            ExchangeWebResult<string>[]? listenKeyResults = null,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToSpotOrderUpdatesAsync(request, handler, new[] { exchange }, listenKeyResults, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToSpotOrderUpdatesAsync(
             SubscribeSpotOrderRequest request,

CryptoClients.Net/Clients/Socket/ExchangeSocketClient.SpotOrder.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
@@ -20,6 +21,17 @@ public partial class ExchangeSocketClient
 
         #region Subscribe Ticker
 
+        /// <inheritdoc />
+        public async Task<ExchangeResult<UpdateSubscription>> SubscribeToTickerUpdatesAsync(
+            string exchange,
+            SubscribeTickerRequest request,
+            Action<ExchangeEvent<SharedSpotTicker>> handler,
+            CancellationToken ct = default)
+        {
+            var result = await SubscribeToTickerUpdatesAsync(request, handler, new[] { exchange }, ct).ConfigureAwait(false);
+            return result.SingleOrDefault() ?? new ExchangeResult<UpdateSubscription>(exchange, new InvalidOperationError($"Subscription not supported for {exchange}"));
+        }
+
         /// <inheritdoc />
         public async Task<ExchangeResult<UpdateSubscription>[]> SubscribeToTickerUpdatesAsync(SubscribeTickerRequest request, Action<ExchangeEvent<SharedSpotTicker>> handler, IEnumerable<string>? exchanges = null, CancellationToken ct = default)
         {