CryptoExchange.Net V12 (#97)

* Result types:
  * (Web)CallResult types are replaced by HttpResult, WebSocketResult and QueryResult with the same logic
  * WebSocketResult and QueryResult now return additional info for websocket operations
  * Updated result types to record type
  * Removed implicit result type conversion to bool, `if (result)` no longer works, instead use `if (result.Success)`
  * Fixed result object nullability hinting, for example Data might be null if Success isn't checked for true

* Clients:
  * Added ToString overrides on base API types
  * Added Exchange property on BaseApiClient
  * Added ApiCredentials property on Api clients
  * Updated ILogger source from client name to topic specific client name
  * Removed logging from client creation
  * Fixed issue in SocketApiClient.GetSocketConnection causing requests to always wait the full max 10 seconds when there was a reconnecting socket

* Shared APIs:
  * Added missing dedicated option types
  * Added Discover method on ISharedClient interface, returning info on supported capabilities and operations
  * Added ResetStaticExchangeParameters method on ExchangeParameters
  * Added Status property to SharedWithdrawal model
  * Added TradingModes property to SharedBalance model
  * Updated Shared ExchangeParameters parameter names to be case insensitive
  * Updated code comments
  * Replaced ExchangeResult with ExchangeCallResult type
  * Removed TradingMode from the response model, only maintained on models where it makes sense

* Added async streaming on UserDataTracker items with StreamUpdatesAsync
* Added cancellation token support to UserDataTracker starting
* Added SupportedEnvironments property to PlatformInfo
* Added Clear() method on UserClientProvider to clear all cached clients
* Added setter to CoinExExchange.RateLimiter to allow custom rate limit settings
* Various small performance improvements
* Fixed websocket connection attempts counting towards rate limit even when server could not be reached

Author: JKorf

AGENTS.md

@@ -9,7 +9,7 @@ description: Use CoinEx.Net when generating C#/.NET code that interacts with the
 
 If the user asks for CoinEx API access in C#/.NET, **use CoinEx.Net**. Do not write raw `HttpClient` calls to CoinEx endpoints. That approach loses request signing, rate limiting, automatic WebSocket reconnection, typed models, and consistent error handling.
 
-For multi-exchange code, additionally use `CryptoExchange.Net.SharedApis` interfaces. CoinEx exposes shared clients for both Spot V2 and Futures.
+For multi-exchange code, additionally use `CryptoExchange.Net.SharedApis` interfaces. CoinEx exposes shared clients for both Spot V2 and Futures. Use `.SharedClient.Discover()` to inspect supported shared features at runtime.
 
 ## Installation
 
@@ -41,7 +41,7 @@ var publicClient = new CoinExRestClient();
 
 ## Core Pattern: Result Handling
 
-REST methods return `WebCallResult<T>` or `WebCallResult`. WebSocket subscriptions return `CallResult<UpdateSubscription>`. Always check `.Success` before accessing `.Data`.
+REST methods return `HttpResult<T>` or `HttpResult`. WebSocket subscriptions return `WebSocketResult<UpdateSubscription>`. Shared non-I/O symbol/cache helpers return `ExchangeCallResult<T>`. Always check `.Success` before accessing `.Data`.
 
 ```csharp
 var tickers = await restClient.SpotApiV2.ExchangeData.GetTickersAsync(new[] { "BTCUSDT" });
@@ -159,6 +159,9 @@ using CoinEx.Net.Clients;
 using CryptoExchange.Net.SharedApis;
 
 var coinexShared = new CoinExRestClient().SpotApiV2.SharedClient;
+var info = coinexShared.Discover();
+Console.WriteLine(info);
+
 var symbol = new SharedSymbol(TradingMode.Spot, "BTC", "USDT");
 
 var ticker = await coinexShared.GetSpotTickerAsync(new GetTickerRequest(symbol));

CoinEx.Net.UnitTests/CoinExClientTests.cs

@@ -34,16 +34,15 @@ public void CheckSignatureExample1()
                     return headers["X-COINEX-SIGN"].ToString();
                 },
                 "444976F4F21D422AB7091B47D9201EB02A6614FF1F4C7B9F6CA57BFF632030A5",
-                new Dictionary<string, object>
+                new Parameters(CoinExExchange._parameterSerializationSettings)
                 {
                     { "market", "BTCUSDT" },
                     { "market_type", "SPOT" },
                     { "side", "buy" },
                     { "page", "1" },
                     { "limit", "10" },
                 },
-                time: DateTimeConverter.ParseFromDouble(1700490704564),
-                disableOrdering: true);
+                time: DateTimeConverter.ParseFromDouble(1700490704564));
         }
 
         [Test]
@@ -64,16 +63,15 @@ public void CheckSignatureExample2()
                     return headers["X-COINEX-SIGN"].ToString();
                 },
                 "5128936CEDB75A512991A47BCCB0A78F6D9F6F540C07A17AE68D31F16E06A17F",
-                new Dictionary<string, object>
+                new Parameters(CoinExExchange._parameterSerializationSettings)
                 {
                     { "market", "BTCUSDT" },
                     { "market_type", "SPOT" },
                     { "side", "buy" },
                     { "page", "1" },
                     { "limit", "10" },
                 },
-                time: DateTimeConverter.ParseFromDouble(1700490704564),
-                disableOrdering: true);
+                time: DateTimeConverter.ParseFromDouble(1700490704564));
         }
 
         [Test]

CoinEx.Net.UnitTests/RestRequestTests.cs

@@ -174,7 +174,7 @@ public async Task ValidateFuturesTradingCalls()
             await tester.ValidateAsync(client => client.FuturesApi.Trading.GetAutoSettlementHistoryAsync("ETHUSDT", 1), "GetAutoSettlementHistory");
         }
 
-        private bool IsAuthenticated(WebCallResult result)
+        private bool IsAuthenticated(IHttpResult result)
         {
             return result.RequestHeaders.Any(x => x.Key == "X-COINEX-KEY");
         }

CoinEx.Net.UnitTests/SocketSubscriptionTests.cs

@@ -26,7 +26,7 @@ public async Task ValidateConcurrentSpotSubscriptions()
                 OutputOriginalData = true
             }), logger);
 
-            var tester = new SocketSubscriptionValidator<CoinExSocketClient>(client, "Subscriptions/SpotApi", "wss://socket.coinex.com", "data");
+            var tester = new SocketSubscriptionValidator<CoinExSocketClient>(client, "Subscriptions/SpotApi", "wss://socket.coinex.com/v2/spot", "data");
             await tester.ValidateConcurrentAsync<CoinExTrade[]>(
                 (client, handler) => client.SpotApiV2.SubscribeToTradeUpdatesAsync("ETHUSDT", handler),
                 (client, handler) => client.SpotApiV2.SubscribeToTradeUpdatesAsync("BTCUSDT", handler),

CoinEx.Net/Clients/CoinExRestClient.cs

@@ -43,8 +43,8 @@ public CoinExRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, I
         {
             Initialize(options.Value);
 
-            FuturesApi = AddApiClient(new CoinExRestClientFuturesApi(_logger, httpClient, options.Value));
-            SpotApiV2 = AddApiClient(new SpotApiV2.CoinExRestClientSpotApi(_logger, httpClient, options.Value));
+            FuturesApi = AddApiClient(new CoinExRestClientFuturesApi(loggerFactory, httpClient, options.Value));
+            SpotApiV2 = AddApiClient(new SpotApiV2.CoinExRestClientSpotApi(loggerFactory, httpClient, options.Value));
         }
         #endregion
 

CoinEx.Net/Clients/CoinExSocketClient.cs

@@ -43,8 +43,8 @@ public CoinExSocketClient(IOptions<CoinExSocketOptions> options, ILoggerFactory?
         {
             Initialize(options.Value);
 
-            FuturesApi = AddApiClient(new CoinExSocketClientFuturesApi(_logger, options.Value));
-            SpotApiV2 = AddApiClient(new SpotApiV2.CoinExSocketClientSpotApi(_logger, options.Value));
+            FuturesApi = AddApiClient(new CoinExSocketClientFuturesApi(loggerFactory, options.Value));
+            SpotApiV2 = AddApiClient(new SpotApiV2.CoinExSocketClientSpotApi(loggerFactory, options.Value));
         }
         #endregion
 

CoinEx.Net/Clients/CoinExUserClientProvider.cs

@@ -1,6 +1,7 @@
 using CoinEx.Net.Interfaces.Clients;
 using CoinEx.Net.Objects.Options;
 using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Clients;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -12,18 +13,17 @@
 namespace CoinEx.Net.Clients
 {
     /// <inheritdoc />
-    public class CoinExUserClientProvider : ICoinExUserClientProvider
+    public class CoinExUserClientProvider : UserClientProvider<
+        ICoinExRestClient,
+        ICoinExSocketClient,
+        CoinExRestOptions,
+        CoinExSocketOptions,
+        CoinExCredentials,
+        CoinExEnvironment
+        >, ICoinExUserClientProvider
     {
-        private ConcurrentDictionary<string, ICoinExRestClient> _restClients = new ConcurrentDictionary<string, ICoinExRestClient>();
-        private ConcurrentDictionary<string, ICoinExSocketClient> _socketClients = new ConcurrentDictionary<string, ICoinExSocketClient>();
-
-        private readonly IOptions<CoinExRestOptions> _restOptions;
-        private readonly IOptions<CoinExSocketOptions> _socketOptions;
-        private readonly HttpClient _httpClient;
-        private readonly ILoggerFactory? _loggerFactory;
-
         /// <inheritdoc />
-        public string ExchangeName => CoinExExchange.ExchangeName;
+        public override string ExchangeName => CoinExExchange.ExchangeName;
 
         /// <summary>
         /// ctor
@@ -42,97 +42,15 @@ public CoinExUserClientProvider(
             ILoggerFactory? loggerFactory,
             IOptions<CoinExRestOptions> restOptions,
             IOptions<CoinExSocketOptions> socketOptions)
+            : base(httpClient, loggerFactory, restOptions, socketOptions)
         {
-            _httpClient = httpClient ?? new HttpClient();
-            _httpClient.Timeout = restOptions.Value.RequestTimeout;
-            _loggerFactory = loggerFactory;
-            _restOptions = restOptions;
-            _socketOptions = socketOptions;
         }
 
         /// <inheritdoc />
-        public void InitializeUserClient(string userIdentifier, CoinExCredentials credentials, CoinExEnvironment? environment = null)
-        {
-            CreateRestClient(userIdentifier, credentials, environment);
-            CreateSocketClient(userIdentifier, credentials, environment);
-        }
-
-        /// <inheritdoc />
-        public void ClearUserClients(string userIdentifier)
-        {
-            _restClients.TryRemove(userIdentifier, out _);
-            _socketClients.TryRemove(userIdentifier, out _);
-        }
-
+        protected override ICoinExRestClient ConstructRestClient(HttpClient client, ILoggerFactory? loggerFactory, IOptions<CoinExRestOptions> options)
+            => new CoinExRestClient(client, loggerFactory, options);
         /// <inheritdoc />
-        public ICoinExRestClient GetRestClient(string userIdentifier, CoinExCredentials? credentials = null, CoinExEnvironment? environment = null)
-        {
-            if (!_restClients.TryGetValue(userIdentifier, out var client) || client.Disposed)
-                client = CreateRestClient(userIdentifier, credentials, environment);
-
-            return client;
-        }
-
-        /// <inheritdoc />
-        public ICoinExSocketClient GetSocketClient(string userIdentifier, CoinExCredentials? credentials = null, CoinExEnvironment? environment = null)
-        {
-            if (!_socketClients.TryGetValue(userIdentifier, out var client) || client.Disposed)
-                client = CreateSocketClient(userIdentifier, credentials, environment);
-
-            return client;
-        }
-
-        private ICoinExRestClient CreateRestClient(string userIdentifier, CoinExCredentials? credentials, CoinExEnvironment? environment)
-        {
-            var clientRestOptions = SetRestEnvironment(environment);
-            var client = new CoinExRestClient(_httpClient, _loggerFactory, clientRestOptions);
-            if (credentials != null)
-            {
-                client.SetApiCredentials(credentials);
-                _restClients[userIdentifier] = client;
-            }
-            return client;
-        }
-
-        private ICoinExSocketClient CreateSocketClient(string userIdentifier, CoinExCredentials? credentials, CoinExEnvironment? environment)
-        {
-            var clientSocketOptions = SetSocketEnvironment(environment);
-            var client = new CoinExSocketClient(clientSocketOptions!, _loggerFactory);
-            if (credentials != null)
-            {
-                client.SetApiCredentials(credentials);
-                _socketClients[userIdentifier] = client;
-            }
-            return client;
-        }
-
-        private IOptions<CoinExRestOptions> SetRestEnvironment(CoinExEnvironment? environment)
-        {
-            if (environment == null)
-                return _restOptions;
-
-            var newRestClientOptions = new CoinExRestOptions();
-            var restOptions = _restOptions.Value.Set(newRestClientOptions);
-            newRestClientOptions.Environment = environment;
-            return Options.Create(newRestClientOptions);
-        }
-
-        private IOptions<CoinExSocketOptions> SetSocketEnvironment(CoinExEnvironment? environment)
-        {
-            if (environment == null)
-                return _socketOptions;
-
-            var newSocketClientOptions = new CoinExSocketOptions();
-            var restOptions = _socketOptions.Value.Set(newSocketClientOptions);
-            newSocketClientOptions.Environment = environment;
-            return Options.Create(newSocketClientOptions);
-        }
-
-        private static T ApplyOptionsDelegate<T>(Action<T>? del) where T : new()
-        {
-            var opts = new T();
-            del?.Invoke(opts);
-            return opts;
-        }
+        protected override ICoinExSocketClient ConstructSocketClient(ILoggerFactory? loggerFactory, IOptions<CoinExSocketOptions> options)
+            => new CoinExSocketClient(options, loggerFactory);
     }
 }

CoinEx.Net/Clients/FuturesApi/CoinExRestClientFuturesApi.cs

@@ -34,9 +34,6 @@ internal partial class CoinExRestClientFuturesApi : RestApiClient<CoinExEnvironm
         protected override ErrorMapping ErrorMapping => CoinExErrors.RestErrorMapping;
         #endregion
 
-        /// <inheritdoc />
-        public string ExchangeName => "CoinEx";
-
         #region Api clients
         /// <inheritdoc />
         public ICoinExRestClientFuturesApiAccount Account { get; }
@@ -47,8 +44,8 @@ internal partial class CoinExRestClientFuturesApi : RestApiClient<CoinExEnvironm
         #endregion
 
         #region ctor
-        internal CoinExRestClientFuturesApi(ILogger logger, HttpClient? httpClient, CoinExRestOptions options) :
-            base(logger, httpClient, options.Environment.RestBaseAddress, options, options.FuturesOptions)
+        internal CoinExRestClientFuturesApi(ILoggerFactory? loggerFactory, HttpClient? httpClient, CoinExRestOptions options) :
+            base(loggerFactory, CoinExExchange.Metadata.Id, httpClient, options.Environment.RestBaseAddress, options, options.FuturesOptions)
         {
             Account = new CoinExRestClientFuturesApiAccount(this);
             ExchangeData = new CoinExRestClientFuturesApiExchangeData(this);
@@ -75,44 +72,38 @@ protected override CoinExV2AuthenticationProvider CreateAuthenticationProvider(C
 
         #region methods
 
-        internal Task<WebCallResult> SendAsync(RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null)
-            => SendToAddressAsync(BaseAddress, definition, parameters, cancellationToken, weight);
-
-        internal async Task<WebCallResult> SendToAddressAsync(string baseAddress, RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null)
+        internal async Task<HttpResult> SendAsync(RequestDefinition definition, Parameters? parameters, CancellationToken cancellationToken, int? weight = null)
         {
-            var result = await base.SendAsync<CoinExApiResult>(baseAddress, definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
-            if (!result)
-                return result.AsDataless();
+            var result = await base.SendAsync<CoinExApiResult>(definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
+            if (!result.Success)
+                return result;
 
             if (result.Data.Code != 0)
-                return result.AsDatalessError(new ServerError(result.Data.Code, GetErrorInfo(result.Data.Code, result.Data.Message!)));
+                return HttpResult.Fail(result, new ServerError(result.Data.Code, GetErrorInfo(result.Data.Code, result.Data.Message!)));
 
-            return result.AsDataless();
+            return result;
         }
 
-        internal Task<WebCallResult<T>> SendAsync<T>(RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null) where T : class
-            => SendToAddressAsync<T>(BaseAddress, definition, parameters, cancellationToken, weight);
-
-        internal async Task<WebCallResult<T>> SendToAddressAsync<T>(string baseAddress, RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null) where T : class
+        internal async Task<HttpResult<T>> SendAsync<T>(RequestDefinition definition, Parameters? parameters, CancellationToken cancellationToken, int? weight = null) where T : class
         {
-            var result = await base.SendAsync<CoinExApiResult<T>>(baseAddress, definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
-            if (!result)
-                return result.As<T>(default);
+            var result = await base.SendAsync<CoinExApiResult<T>>(definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
+            if (!result.Success)
+                return HttpResult.Fail<T>(result);
 
             if (result.Data.Code != 0)
-                return result.AsError<T>(new ServerError(result.Data.Code, GetErrorInfo(result.Data.Code, result.Data.Message!)));
+                return HttpResult.Fail<T>(result, new ServerError(result.Data.Code, GetErrorInfo(result.Data.Code, result.Data.Message!)));
 
-            return result.As(result.Data.Data);
+            return HttpResult.Ok(result, result.Data.Data);
         }
 
-        internal async Task<WebCallResult<CoinExPaginated<T>>> SendPaginatedAsync<T>(RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null) where T : class
+        internal async Task<HttpResult<CoinExPaginated<T>>> SendPaginatedAsync<T>(RequestDefinition definition, Parameters? parameters, CancellationToken cancellationToken, int? weight = null) where T : class
         {
-            var result = await base.SendAsync<CoinExPageApiResult<T[]>>(BaseAddress, definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
-            if (!result)
-                return result.As<CoinExPaginated<T>>(default);
+            var result = await base.SendAsync<CoinExPageApiResult<T[]>>(definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
+            if (!result.Success)
+                return HttpResult.Fail<CoinExPaginated<T>>(result);
 
             if (result.Data.Code != 0)
-                return result.AsError<CoinExPaginated<T>>(new ServerError(result.Data.Code, GetErrorInfo(result.Data.Code, result.Data.Message!)));
+                return HttpResult.Fail<CoinExPaginated<T>>(result, new ServerError(result.Data.Code, GetErrorInfo(result.Data.Code, result.Data.Message!)));
 
             var resultPage = new CoinExPaginated<T>
             {
@@ -121,12 +112,12 @@ internal async Task<WebCallResult<CoinExPaginated<T>>> SendPaginatedAsync<T>(Req
                 Items = result.Data.Data
             };
 
-            return result.As(resultPage);
+            return HttpResult.Ok(result, resultPage);
         }
         #endregion
 
         /// <inheritdoc />
-        protected override async Task<WebCallResult<DateTime>> GetServerTimestampAsync() => await ExchangeData.GetServerTimeAsync().ConfigureAwait(false);
+        protected override async Task<HttpResult<DateTime>> GetServerTimestampAsync() => await ExchangeData.GetServerTimeAsync().ConfigureAwait(false);
 
     }
 }