Updated to version 7.11.1

CryptoExchange.Net.UnitTests/OptionsTests.cs

@@ -51,8 +51,8 @@ namespace CryptoExchange.Net.UnitTests
 
             // assert
             Assert.That(options.ReceiveWindow == TimeSpan.FromSeconds(10));
-            Assert.That(options.ApiCredentials.Key.GetString() == "123");
-            Assert.That(options.ApiCredentials.Secret.GetString() == "456");
+            Assert.That(options.ApiCredentials.Key == "123");
+            Assert.That(options.ApiCredentials.Secret == "456");
         }
 
         [Test]
@@ -64,10 +64,10 @@ namespace CryptoExchange.Net.UnitTests
             options.Api2Options.ApiCredentials = new ApiCredentials("789", "101");
 
             // assert
-            Assert.That(options.Api1Options.ApiCredentials.Key.GetString() == "123");
-            Assert.That(options.Api1Options.ApiCredentials.Secret.GetString() == "456");
-            Assert.That(options.Api2Options.ApiCredentials.Key.GetString() == "789");
-            Assert.That(options.Api2Options.ApiCredentials.Secret.GetString() == "101");
+            Assert.That(options.Api1Options.ApiCredentials.Key == "123");
+            Assert.That(options.Api1Options.ApiCredentials.Secret == "456");
+            Assert.That(options.Api2Options.ApiCredentials.Key == "789");
+            Assert.That(options.Api2Options.ApiCredentials.Secret == "101");
         }
 
         [Test]

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -176,12 +176,12 @@ namespace CryptoExchange.Net.UnitTests
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);             
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);             
                 Assert.That(i == requests? triggered : !triggered);
             }
             triggered = false;
             await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1,  RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1,  RateLimitingBehaviour.Wait, default);
             Assert.That(!triggered);
         }
 
@@ -201,7 +201,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 bool expected = i == 1 ? (expectLimiting ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
@@ -222,9 +222,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimiting ? evnt != null : evnt == null);
         }
 
@@ -243,12 +243,12 @@ namespace CryptoExchange.Net.UnitTests
 
             for (var i = 0; i < requests + 1; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 Assert.That(i == requests ? triggered : !triggered);
             }
             triggered = false;
             await Task.Delay((int)Math.Round(perSeconds * 1000) + 10);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(!triggered);
         }
 
@@ -266,7 +266,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
@@ -286,7 +286,7 @@ namespace CryptoExchange.Net.UnitTests
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
             for (var i = 0; i < 2; i++)
             {
-                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+                var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
                 bool expected = i == 1 ? (expectLimited ? evnt.DelayTime > TimeSpan.Zero : evnt == null) : evnt == null;
                 Assert.That(expected);
             }
@@ -309,9 +309,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", key1?.ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", key1, 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", key2?.ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", key2, 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -328,7 +328,7 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, "https://test.com", "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
             var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition2, "https://test.com", null, 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
@@ -348,9 +348,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host1, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host1, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host2, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Request, requestDefinition1, host2, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
 
@@ -365,9 +365,9 @@ namespace CryptoExchange.Net.UnitTests
             RateLimitEvent evnt = null;
             rateLimiter.RateLimitTriggered += (x) => { evnt = x; };
 
-            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host1, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result1 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host1, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(evnt == null);
-            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host2, "123".ToSecureString(), 1, RateLimitingBehaviour.Wait, default);
+            var result2 = await rateLimiter.ProcessAsync(new TraceLogger(), 1, RateLimitItemType.Connection, new RequestDefinition("1", HttpMethod.Get), host2, "123", 1, RateLimitingBehaviour.Wait, default);
             Assert.That(expectLimited ? evnt != null : evnt == null);
         }
     }

CryptoExchange.Net.UnitTests/SystemTextJsonConverterTests.cs

@@ -163,6 +163,20 @@ namespace CryptoExchange.Net.UnitTests
             Assert.That(output.Value == expected);
         }
 
+        [TestCase("1", TestEnum.One)]
+        [TestCase("2", TestEnum.Two)]
+        [TestCase("3", TestEnum.Three)]
+        [TestCase("three", TestEnum.Three)]
+        [TestCase("Four", TestEnum.Four)]
+        [TestCase("four", TestEnum.Four)]
+        [TestCase("Four1", TestEnum.One)]
+        [TestCase(null, TestEnum.One)]
+        public void TestEnumConverterParseStringTests(string value, TestEnum? expected)
+        {
+            var result = EnumConverter.ParseString<TestEnum>(value);
+            Assert.That(result == expected);
+        }
+
         [TestCase("1", true)]
         [TestCase("true", true)]
         [TestCase("yes", true)]
@@ -200,6 +214,41 @@ namespace CryptoExchange.Net.UnitTests
             var output = JsonSerializer.Deserialize<NotNullableSTJBoolObject>($"{{ \"Value\": {val} }}");
             Assert.That(output.Value == expected);
         }
+
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase(null, null)]
+        [TestCase("", null)]
+        [TestCase("null", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterString(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": \""+ value + "\"}");
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+        }
+
+        [TestCase("1", 1)]
+        [TestCase("1.1", 1.1)]
+        [TestCase("-1.1", -1.1)]
+        [TestCase("null", null)]
+        [TestCase("1E+2", 100)]
+        [TestCase("1E-2", 0.01)]
+        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        public void TestDecimalConverterNumber(string value, decimal? expected)
+        {
+            var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": " + value + "}");
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+        }
+    }
+
+    public class STJDecimalObject
+    {
+        [JsonConverter(typeof(DecimalConverter))]
+        [JsonPropertyName("test")]
+        public decimal? Test { get; set; }
     }
 
     public class STJTimeObject

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -68,11 +68,11 @@ namespace CryptoExchange.Net.UnitTests
         {
         }
 
-        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, IDictionary<string, object> uriParams, IDictionary<string, object> bodyParams, Dictionary<string, string> headers, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, RequestBodyFormat bodyFormat)
+        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, ref IDictionary<string, object> uriParams, ref IDictionary<string, object> bodyParams, ref Dictionary<string, string> headers, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, RequestBodyFormat bodyFormat)
         {
         }
 
-        public string GetKey() => _credentials.Key.GetString();
-        public string GetSecret() => _credentials.Secret.GetString();
+        public string GetKey() => _credentials.Key;
+        public string GetSecret() => _credentials.Secret;
     }
 }

CryptoExchange.Net/Authentication/ApiCredentials.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Security;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Converters.MessageParsing;
 
@@ -9,48 +8,23 @@ namespace CryptoExchange.Net.Authentication
     /// <summary>
     /// Api credentials, used to sign requests accessing private endpoints
     /// </summary>
-    public class ApiCredentials: IDisposable
+    public class ApiCredentials
     {
         /// <summary>
         /// The api key to authenticate requests
         /// </summary>
-        public SecureString? Key { get; }
+        public string Key { get; }
 
         /// <summary>
         /// The api secret to authenticate requests
         /// </summary>
-        public SecureString? Secret { get; }
+        public string Secret { get; }
 
         /// <summary>
         /// Type of the credentials
         /// </summary>
         public ApiCredentialsType CredentialType { get; }
 
-        /// <summary>
-        /// Create Api credentials providing an api key and secret for authentication
-        /// </summary>
-        /// <param name="key">The api key used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
-        public ApiCredentials(SecureString key, SecureString secret) : this(key, secret, ApiCredentialsType.Hmac)
-        {
-        }
-
-        /// <summary>
-        /// Create Api credentials providing an api key and secret for authentication
-        /// </summary>
-        /// <param name="key">The api key used for identification</param>
-        /// <param name="secret">The api secret used for signing</param>
-        /// <param name="credentialsType">The type of credentials</param>
-        public ApiCredentials(SecureString key, SecureString secret, ApiCredentialsType credentialsType)
-        {
-            if (key == null || secret == null)
-                throw new ArgumentException("Key and secret can't be null/empty");
-
-            CredentialType = credentialsType;
-            Key = key;
-            Secret = secret;
-        }
-
         /// <summary>
         /// Create Api credentials providing an api key and secret for authentication
         /// </summary>
@@ -72,8 +46,8 @@ namespace CryptoExchange.Net.Authentication
                 throw new ArgumentException("Key and secret can't be null/empty");
 
             CredentialType = credentialsType;
-            Key = key.ToSecureString();
-            Secret = secret.ToSecureString();
+            Key = key;
+            Secret = secret;
         }
 
         /// <summary>
@@ -82,8 +56,7 @@ namespace CryptoExchange.Net.Authentication
         /// <returns></returns>
         public virtual ApiCredentials Copy()
         {
-            // Use .GetString() to create a copy of the SecureString
-            return new ApiCredentials(Key!.GetString(), Secret!.GetString(), CredentialType);
+            return new ApiCredentials(Key, Secret, CredentialType);
         }
 
         /// <summary>
@@ -103,19 +76,10 @@ namespace CryptoExchange.Net.Authentication
             if (key == null || secret == null)
                 throw new ArgumentException("apiKey or apiSecret value not found in Json credential file");
 
-            Key = key.ToSecureString();
-            Secret = secret.ToSecureString();
+            Key = key;
+            Secret = secret;
 
             inputStream.Seek(0, SeekOrigin.Begin);
         }
-
-        /// <summary>
-        /// Dispose
-        /// </summary>
-        public void Dispose()
-        {
-            Key?.Dispose();
-            Secret?.Dispose();
-        }
     }
 }

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -14,7 +14,7 @@ namespace CryptoExchange.Net.Authentication
     /// <summary>
     /// Base class for authentication providers
     /// </summary>
-    public abstract class AuthenticationProvider : IDisposable
+    public abstract class AuthenticationProvider
     {
         internal IAuthTimeProvider TimeProvider { get; set; } = new AuthTimeProvider();
 
@@ -28,6 +28,11 @@ namespace CryptoExchange.Net.Authentication
         /// </summary>
         protected byte[] _sBytes;
 
+        /// <summary>
+        /// Get the API key of the current credentials
+        /// </summary>
+        public string ApiKey => _credentials.Key;
+
         /// <summary>
         /// ctor
         /// </summary>
@@ -38,7 +43,7 @@ namespace CryptoExchange.Net.Authentication
                 throw new ArgumentException("ApiKey/Secret needed");
 
             _credentials = credentials;
-            _sBytes = Encoding.UTF8.GetBytes(credentials.Secret.GetString());
+            _sBytes = Encoding.UTF8.GetBytes(credentials.Secret);
         }
 
         /// <summary>
@@ -58,9 +63,9 @@ namespace CryptoExchange.Net.Authentication
             RestApiClient apiClient,
             Uri uri,
             HttpMethod method,
-            IDictionary<string, object> uriParameters,
-            IDictionary<string, object> bodyParameters,
-            Dictionary<string, string> headers,
+            ref IDictionary<string, object>? uriParameters,
+            ref IDictionary<string, object>? bodyParameters,
+            ref Dictionary<string, string>? headers,
             bool auth,
             ArrayParametersSerialization arraySerialization,
             HttpMethodParameterPosition parameterPosition,
@@ -366,7 +371,7 @@ namespace CryptoExchange.Net.Authentication
             {
 #if NETSTANDARD2_1_OR_GREATER
                 // Read from pem private key
-                var key = _credentials.Secret!.GetString()
+                var key = _credentials.Secret!
                         .Replace("\n", "")
                         .Replace("-----BEGIN PRIVATE KEY-----", "")
                         .Replace("-----END PRIVATE KEY-----", "")
@@ -381,7 +386,7 @@ namespace CryptoExchange.Net.Authentication
             else if (_credentials.CredentialType == ApiCredentialsType.RsaXml)
             {
                 // Read from xml private key format
-                rsa.FromXmlString(_credentials.Secret!.GetString());
+                rsa.FromXmlString(_credentials.Secret!);
             }
             else
             {
@@ -447,12 +452,6 @@ namespace CryptoExchange.Net.Authentication
             else
                 return serializer.Serialize(parameters);
         }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            _credentials?.Dispose();
-        }
     }
 
     /// <inheritdoc />

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -65,10 +65,7 @@ namespace CryptoExchange.Net.Clients
             BaseAddress = baseAddress;
 
             if (apiCredentials != null)
-            {
-                AuthenticationProvider?.Dispose();
                 AuthenticationProvider = CreateAuthenticationProvider(apiCredentials.Copy());
-            }
         }
 
         /// <summary>
@@ -85,10 +82,7 @@ namespace CryptoExchange.Net.Clients
         public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
         {
             if (credentials != null)
-            {
-                AuthenticationProvider?.Dispose();
                 AuthenticationProvider = CreateAuthenticationProvider(credentials.Copy());
-            }
         }
 
         /// <summary>
@@ -97,7 +91,6 @@ namespace CryptoExchange.Net.Clients
         public virtual void Dispose()
         {
             _disposing = true;
-            AuthenticationProvider?.Dispose();
         }
     }
 }

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -196,19 +196,20 @@ namespace CryptoExchange.Net.Clients
             Dictionary<string, string>? additionalHeaders = null,
             int? weight = null) where T : class
         {
-            var key = baseAddress + definition + uriParameters?.ToFormData();
+            string? cacheKey = null;
             if (ShouldCache(definition))
             {
-                _logger.CheckingCache(key);
-                var cachedValue = _cache.Get(key, ClientOptions.CachingMaxAge);
+                cacheKey = baseAddress + definition + uriParameters?.ToFormData();
+                _logger.CheckingCache(cacheKey);
+                var cachedValue = _cache.Get(cacheKey, ClientOptions.CachingMaxAge);
                 if (cachedValue != null)
                 {
-                    _logger.CacheHit(key);
+                    _logger.CacheHit(cacheKey);
                     var original = (WebCallResult<T>)cachedValue;
                     return original.Cached();
                 }
 
-                _logger.CacheNotHit(key);
+                _logger.CacheNotHit(cacheKey);
             }
 
             int currentTry = 0;
@@ -228,7 +229,7 @@ namespace CryptoExchange.Net.Clients
                     uriParameters,
                     bodyParameters,
                     additionalHeaders);
-                _logger.RestApiSendRequest(request.RequestId, definition, request.Content, request.Uri.Query, string.Join(", ", request.GetHeaders().Select(h => h.Key + $"=[{string.Join(",", h.Value)}]")));
+                _logger.RestApiSendRequest(request.RequestId, definition, request.Content, string.IsNullOrEmpty(request.Uri.Query) ? "-" : request.Uri.Query, string.Join(", ", request.GetHeaders().Select(h => h.Key + $"=[{string.Join(",", h.Value)}]")));
                 TotalRequestsMade++;
                 var result = await GetResponseAsync<T>(request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
                 if (!result)
@@ -242,7 +243,7 @@ namespace CryptoExchange.Net.Clients
                 if (result.Success &&
                     ShouldCache(definition))
                 {
-                    _cache.Add(key, result);
+                    _cache.Add(cacheKey!, result);
                 }
 
                 return result;
@@ -343,15 +344,15 @@ namespace CryptoExchange.Net.Clients
             ParameterCollection? bodyParameters,
             Dictionary<string, string>? additionalHeaders)
         {
-            var uriParams = uriParameters == null ? new ParameterCollection() : CreateParameterDictionary(uriParameters);
-            var bodyParams = bodyParameters == null ? new ParameterCollection() : CreateParameterDictionary(bodyParameters);
+            var uriParams = uriParameters == null ? null : CreateParameterDictionary(uriParameters);
+            var bodyParams = bodyParameters == null ? null : CreateParameterDictionary(bodyParameters);
 
             var uri = new Uri(baseAddress.AppendPath(definition.Path));
             var arraySerialization = definition.ArraySerialization ?? ArraySerialization;
             var bodyFormat = definition.RequestBodyFormat ?? RequestBodyFormat;
             var parameterPosition = definition.ParameterPosition ?? ParameterPositions[definition.Method];
 
-            var headers = new Dictionary<string, string>();
+            Dictionary<string, string>? headers = null;
             if (AuthenticationProvider != null)
             {
                 try
@@ -360,9 +361,9 @@ namespace CryptoExchange.Net.Clients
                         this,
                         uri,
                         definition.Method,
-                        uriParams,
-                        bodyParams,
-                        headers,
+                        ref uriParams,
+                        ref bodyParams,
+                        ref headers,
                         definition.Authenticated,
                         arraySerialization,
                         parameterPosition,
@@ -375,14 +376,18 @@ namespace CryptoExchange.Net.Clients
                 }
             }
 
-            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters            
-            uri = uri.SetParameters(uriParams, arraySerialization);
+            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters
+            if (uriParams != null)
+                uri = uri.SetParameters(uriParams, arraySerialization);
 
             var request = RequestFactory.Create(definition.Method, uri, requestId);
             request.Accept = Constants.JsonContentHeader;
 
-            foreach (var header in headers)
-                request.AddHeader(header.Key, header.Value);
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                    request.AddHeader(header.Key, header.Value);
+            }
 
             if (additionalHeaders != null)
             {
@@ -403,7 +408,7 @@ namespace CryptoExchange.Net.Clients
             if (parameterPosition == HttpMethodParameterPosition.InBody)
             {
                 var contentType = bodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
-                if (bodyParams.Count != 0)
+                if (bodyParams != null && bodyParams.Count != 0)
                     WriteParamBody(request, bodyParams, contentType);
                 else
                     request.SetContent(RequestBodyEmptyContent, contentType);
@@ -807,8 +812,8 @@ namespace CryptoExchange.Net.Clients
             }
 
             var headers = new Dictionary<string, string>();
-            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? CreateParameterDictionary(parameters) : new Dictionary<string, object>();
-            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? CreateParameterDictionary(parameters) : new Dictionary<string, object>();
+            var uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? CreateParameterDictionary(parameters) : null;
+            var bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? CreateParameterDictionary(parameters) : null;
             if (AuthenticationProvider != null)
             {
                 try
@@ -817,9 +822,9 @@ namespace CryptoExchange.Net.Clients
                         this,
                         uri,
                         method,
-                        uriParameters,
-                        bodyParameters,
-                        headers,
+                        ref uriParameters,
+                        ref bodyParameters,
+                        ref headers,
                         signed,
                         arraySerialization,
                         parameterPosition,
@@ -832,24 +837,18 @@ namespace CryptoExchange.Net.Clients
                 }
             }
 
-            // Sanity check
-            foreach (var param in parameters)
-            {
-                if (!uriParameters.ContainsKey(param.Key) && !bodyParameters.ContainsKey(param.Key))
-                {
-                    throw new Exception($"Missing parameter {param.Key} after authentication processing. AuthenticationProvider implementation " +
-                        $"should return provided parameters in either the uri or body parameters output");
-                }
-            }
-
             // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters            
-            uri = uri.SetParameters(uriParameters, arraySerialization);
+            if (uriParameters != null)
+                uri = uri.SetParameters(uriParameters, arraySerialization);
 
             var request = RequestFactory.Create(method, uri, requestId);
             request.Accept = Constants.JsonContentHeader;
 
-            foreach (var header in headers)
-                request.AddHeader(header.Key, header.Value);
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                    request.AddHeader(header.Key, header.Value);
+            }
 
             if (additionalHeaders != null)
             {
@@ -870,7 +869,7 @@ namespace CryptoExchange.Net.Clients
             if (parameterPosition == HttpMethodParameterPosition.InBody)
             {
                 var contentType = bodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
-                if (bodyParameters.Any())
+                if (bodyParameters?.Any() == true)
                     WriteParamBody(request, bodyParameters, contentType);
                 else
                     request.SetContent(RequestBodyEmptyContent, contentType);

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -189,7 +189,10 @@ namespace CryptoExchange.Net.Clients
                 return new CallResult<UpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
 
             if (subscription.Authenticated && AuthenticationProvider == null)
+            {
+                _logger.LogWarning("Failed to subscribe, private subscription but no API credentials set");
                 return new CallResult<UpdateSubscription>(new NoApiCredentialsError());
+            }
 
             SocketConnection socketConnection;
             var released = false;
@@ -786,9 +789,10 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Preprocess a stream message
         /// </summary>
+        /// <param name="connection"></param>
         /// <param name="type"></param>
         /// <param name="data"></param>
         /// <returns></returns>
-        public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
+        public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
     }
 }

CryptoExchange.Net/Converters/JsonNet/BigDecimalConverter.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Globalization;
+using Newtonsoft.Json;
+
+namespace CryptoExchange.Net.Converters.JsonNet
+{
+    /// <summary>
+    /// Decimal converter that handles overflowing decimal values (by setting it to decimal.MaxValue)
+    /// </summary>
+    public class BigDecimalConverter : JsonConverter
+    {
+        /// <inheritdoc />
+        public override bool CanConvert(Type objectType)
+        {
+            if (Nullable.GetUnderlyingType(objectType) != null)
+                return Nullable.GetUnderlyingType(objectType) == typeof(decimal);
+            return objectType == typeof(decimal);
+        }
+
+        /// <inheritdoc />
+        public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+                return null;
+
+            if (reader.TokenType == JsonToken.Float || reader.TokenType == JsonToken.Integer)
+            {
+                try
+                {
+                    return decimal.Parse(reader.Value!.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture);
+                }
+                catch (OverflowException) 
+                {
+                    // Value doesn't fit decimal; set it to max value
+                    return decimal.MaxValue;
+                }
+            }
+
+            if (reader.TokenType == JsonToken.String)
+            {
+                try
+                {
+                    var value = reader.Value!.ToString();
+                    return decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture);
+                }
+                catch (OverflowException)
+                {
+                    // Value doesn't fit decimal; set it to max value
+                    return decimal.MaxValue;
+                }
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc />
+        public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+        {
+            writer.WriteValue(value);
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/ArrayConverter.cs

@@ -96,7 +96,10 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
                     var attribute = attributes.SingleOrDefault(a => a.ArrayProperty.Index == index);
                     if (attribute == null)
+                    {
+                        index++;
                         continue;
+                    }
 
                     var targetType = attribute.TargetType;
                     object? value = null;

CryptoExchange.Net/Converters/SystemTextJson/BigDecimalConverter.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Decimal converter that handles overflowing decimal values (by setting it to decimal.MaxValue)
+    /// </summary>
+    public class BigDecimalConverter : JsonConverter<decimal>
+    {
+        /// <inheritdoc />
+        public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                try
+                {
+                    return decimal.Parse(reader.GetString(), NumberStyles.Float, CultureInfo.InvariantCulture);
+                }
+                catch(OverflowException)
+                {
+                    // Value doesn't fit decimal, default to max value
+                    return decimal.MaxValue;
+                }
+            }
+
+            try
+            {
+                return reader.GetDecimal();
+            }
+            catch(FormatException)
+            {
+                // Format issue, assume value is too large
+                return decimal.MaxValue;
+            }
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
+        {
+            writer.WriteNumberValue(value);
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/DecimalConverter.cs

@@ -19,13 +19,29 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (reader.TokenType == JsonTokenType.String)
             {
                 var value = reader.GetString();
-                if (string.IsNullOrEmpty(value))
+                if (string.IsNullOrEmpty(value) || string.Equals("null", value))
                     return null;
 
-                return decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture);
+                try
+                {
+                    return decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture);
+                }
+                catch(OverflowException)
+                {
+                    // Value doesn't fit decimal, default to max value
+                    return decimal.MaxValue;
+                }
             }
 
-            return reader.GetDecimal();
+            try
+            {
+                return reader.GetDecimal();
+            }
+            catch(FormatException)
+            {
+                // Format issue, assume value is too large
+                return decimal.MaxValue;
+            }
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Converters/SystemTextJson/EnumConverter.cs

@@ -211,5 +211,37 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
             return enumValue == null ? null : (mapping.FirstOrDefault(v => v.Key.Equals(enumValue)).Value ?? enumValue.ToString());
         }
+
+        /// <summary>
+        /// Get the enum value from a string
+        /// </summary>
+        /// <typeparam name="T">Enum type</typeparam>
+        /// <param name="value">String value</param>
+        /// <returns></returns>
+        public static T? ParseString<T>(string value) where T : Enum
+        {
+            var type = typeof(T);
+            if (!_mapping.TryGetValue(type, out var enumMapping))
+                enumMapping = AddMapping(type);
+
+            var mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
+            if (mapping.Equals(default(KeyValuePair<object, string>)))
+                mapping = enumMapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+
+            if (!mapping.Equals(default(KeyValuePair<object, string>)))
+            {
+                return (T)mapping.Key;
+            }
+
+            try
+            {
+                // If no explicit mapping is found try to parse string
+                return (T)Enum.Parse(type, value, true);
+            }
+            catch (Exception)
+            {
+                return default;
+            }
+        }
     }
 }

CryptoExchange.Net/Converters/SystemTextJson/NumberStringConverter.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Read string or number as string
+    /// </summary>
+    public class NumberStringConverter : JsonConverter<string?>
+    {
+        /// <inheritdoc />
+        public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+                return null;
+
+            if (reader.TokenType == JsonTokenType.Number)
+            {
+                if (reader.TryGetInt64(out var value))
+                    return value.ToString();
+
+                return reader.GetDecimal().ToString();
+            }
+
+            return reader.GetString();
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, string? value, JsonSerializerOptions options)
+        {
+            writer.WriteStringValue(value);
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

@@ -123,6 +123,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (value.Value.ValueKind == JsonValueKind.Object || value.Value.ValueKind == JsonValueKind.Array)
                 return default;
 
+            if (typeof(T) == typeof(string))
+            {
+                if (value.Value.ValueKind == JsonValueKind.Number)
+                    return (T)(object)value.Value.GetInt64().ToString();
+            }
+
             return value.Value.Deserialize<T>();
         }
 

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -6,9 +6,9 @@
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
     <Description>CryptoExchange.Net is a base library which is used to implement different cryptocurrency (exchange) API's. It provides a standardized way of implementing different API's, which results in a very similar experience for users of the API implementations.</Description>
-    <PackageVersion>7.9.0</PackageVersion>
-    <AssemblyVersion>7.9.0</AssemblyVersion>
-    <FileVersion>7.9.0</FileVersion>
+    <PackageVersion>7.11.1</PackageVersion>
+    <AssemblyVersion>7.11.1</AssemblyVersion>
+    <FileVersion>7.11.1</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange</PackageTags>
     <RepositoryType>git</RepositoryType>

CryptoExchange.Net/ExchangeHelpers.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Objects;
 using System;
 using System.Security.Cryptography;
+using System.Threading;
 
 namespace CryptoExchange.Net
 {
@@ -15,10 +16,6 @@ namespace CryptoExchange.Net
         /// The last used id, use NextId() to get the next id and up this
         /// </summary>
         private static int _lastId;
-        /// <summary>
-        /// Lock for id generating
-        /// </summary>
-        private static object _idLock = new();
 
         /// <summary>
         /// Clamp a value between a min and max
@@ -135,24 +132,13 @@ namespace CryptoExchange.Net
         /// Generate a new unique id. The id is staticly stored so it is guarenteed to be unique
         /// </summary>
         /// <returns></returns>
-        public static int NextId()
-        {
-            lock (_idLock)
-            {
-                _lastId += 1;
-                return _lastId;
-            }
-        }
+        public static int NextId() => Interlocked.Increment(ref _lastId);
 
         /// <summary>
         /// Return the last unique id that was generated
         /// </summary>
         /// <returns></returns>
-        public static int LastId()
-        {
-            lock (_idLock)
-                return _lastId;
-        }
+        public static int LastId() => _lastId;
 
         /// <summary>
         /// Generate a random string of specified length

CryptoExchange.Net/ExtensionMethods.cs

@@ -113,92 +113,6 @@ namespace CryptoExchange.Net
             return formData.ToString();
         }
 
-        /// <summary>
-        /// Get the string the secure string is representing
-        /// </summary>
-        /// <param name="source">The source secure string</param>
-        /// <returns></returns>
-        public static string GetString(this SecureString source)
-        {
-            lock (source)
-            {
-                string result;
-                var length = source.Length;
-                var pointer = IntPtr.Zero;
-                var chars = new char[length];
-
-                try
-                {
-                    pointer = Marshal.SecureStringToBSTR(source);
-                    Marshal.Copy(pointer, chars, 0, length);
-
-                    result = string.Join("", chars);
-                }
-                finally
-                {
-                    if (pointer != IntPtr.Zero)
-                    {
-                        Marshal.ZeroFreeBSTR(pointer);
-                    }
-                }
-
-                return result;
-            }
-        }
-
-        /// <summary>
-        /// Are 2 secure strings equal
-        /// </summary>
-        /// <param name="ss1">Source secure string</param>
-        /// <param name="ss2">Compare secure string</param>
-        /// <returns>True if equal by value</returns>
-        public static bool IsEqualTo(this SecureString ss1, SecureString ss2)
-        {
-            IntPtr bstr1 = IntPtr.Zero;
-            IntPtr bstr2 = IntPtr.Zero;
-            try
-            {
-                bstr1 = Marshal.SecureStringToBSTR(ss1);
-                bstr2 = Marshal.SecureStringToBSTR(ss2);
-                int length1 = Marshal.ReadInt32(bstr1, -4);
-                int length2 = Marshal.ReadInt32(bstr2, -4);
-                if (length1 == length2)
-                {
-                    for (int x = 0; x < length1; ++x)
-                    {
-                        byte b1 = Marshal.ReadByte(bstr1, x);
-                        byte b2 = Marshal.ReadByte(bstr2, x);
-                        if (b1 != b2) return false;
-                    }
-                }
-                else
-                {
-                    return false;
-                }
-
-                return true;
-            }
-            finally
-            {
-                if (bstr2 != IntPtr.Zero) Marshal.ZeroFreeBSTR(bstr2);
-                if (bstr1 != IntPtr.Zero) Marshal.ZeroFreeBSTR(bstr1);
-            }
-        }
-
-        /// <summary>
-        /// Create a secure string from a string
-        /// </summary>
-        /// <param name="source"></param>
-        /// <returns></returns>
-        public static SecureString ToSecureString(this string source)
-        {
-            var secureString = new SecureString();
-            foreach (var c in source)
-                secureString.AppendChar(c);
-            secureString.MakeReadOnly();
-            return secureString;
-        }
-
         /// <summary>
         /// Validates an int is one of the allowed values
         /// </summary>
@@ -318,26 +232,6 @@ namespace CryptoExchange.Net
             return url.TrimEnd('/');
         }
 
-        /// <summary>
-        /// Fill parameters in a path. Parameters are specified by '{}' and should be specified in occuring sequence
-        /// </summary>
-        /// <param name="path">The total path string</param>
-        /// <param name="values">The values to fill</param>
-        /// <returns></returns>
-        public static string FillPathParameters(this string path, params string[] values)
-        {
-            foreach (var value in values)
-            {
-                var index = path.IndexOf("{}", StringComparison.Ordinal);
-                if (index >= 0)
-                {
-                    path = path.Remove(index, 2);
-                    path = path.Insert(index, value);
-                }
-            }
-            return path;
-        }
-
         /// <summary>
         /// Create a new uri with the provided parameters as query
         /// </summary>
@@ -453,7 +347,7 @@ namespace CryptoExchange.Net
         }
 
         /// <summary>
-        /// Decompress using Gzip
+        /// Decompress using GzipStream
         /// </summary>
         /// <param name="data"></param>
         /// <returns></returns>
@@ -467,6 +361,23 @@ namespace CryptoExchange.Net
             deflateStream.CopyTo(decompressedStream);
             return new ReadOnlyMemory<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
         }
+
+        /// <summary>
+        /// Decompress using DeflateStream
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static ReadOnlyMemory<byte> Decompress(this ReadOnlyMemory<byte> input)
+        {
+            var output = new MemoryStream();
+
+            using (var compressStream = new MemoryStream(input.ToArray()))
+            using (var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress))
+                decompressor.CopyTo(output);
+
+            output.Position = 0;
+            return new ReadOnlyMemory<byte>(output.GetBuffer(), 0, (int)output.Length);
+        }
     }
 }
 

CryptoExchange.Net/Interfaces/IRateLimiter.cs

@@ -24,6 +24,6 @@ namespace CryptoExchange.Net.Interfaces
         /// <param name="requestWeight">The weight of the request</param>
         /// <param name="ct">Cancellation token to cancel waiting</param>
         /// <returns>The time in milliseconds spend waiting</returns>
-        Task<CallResult<int>> LimitRequestAsync(ILogger log, string endpoint, HttpMethod method, bool signed, SecureString? apiKey, RateLimitingBehaviour limitBehaviour, int requestWeight, CancellationToken ct);
+        Task<CallResult<int>> LimitRequestAsync(ILogger log, string endpoint, HttpMethod method, bool signed, string? apiKey, RateLimitingBehaviour limitBehaviour, int requestWeight, CancellationToken ct);
     }
 }

CryptoExchange.Net/Logging/Extensions/CryptoExchangeWebSocketClientLoggingExtension.cs

@@ -25,6 +25,7 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, int, string, Exception?> _sendLoopStoppedWithException;
         private static readonly Action<ILogger, int, Exception?> _sendLoopFinished;
         private static readonly Action<ILogger, int, string, string ,Exception?> _receivedCloseMessage;
+        private static readonly Action<ILogger, int, string, string ,Exception?> _receivedCloseConfirmation;
         private static readonly Action<ILogger, int, int, Exception?> _receivedPartialMessage;
         private static readonly Action<ILogger, int, int, Exception?> _receivedSingleMessage;
         private static readonly Action<ILogger, int, long, Exception?> _reassembledMessage;
@@ -33,6 +34,7 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, int, Exception?> _receiveLoopFinished;
         private static readonly Action<ILogger, int, TimeSpan?, Exception?> _startingTaskForNoDataReceivedCheck;
         private static readonly Action<ILogger, int, TimeSpan?, Exception?> _noDataReceiveTimoutReconnect;
+        private static readonly Action<ILogger, int, string, string, Exception?> _socketProcessingStateChanged;
 
         static CryptoExchangeWebSocketClientLoggingExtension()
         {
@@ -170,6 +172,17 @@ namespace CryptoExchange.Net.Logging.Extensions
                 LogLevel.Debug,
                 new EventId(1027, "NoDataReceiveTimeoutReconnect"),
                 "[Sckt {SocketId}] no data received for {Timeout}, reconnecting socket");
+
+            _receivedCloseConfirmation = LoggerMessage.Define<int, string, string>(
+                LogLevel.Debug,
+                new EventId(1028, "ReceivedCloseMessage"),
+                "[Sckt {SocketId}] received `Close` message confirming our close request, CloseStatus: {CloseStatus}, CloseStatusDescription: {CloseStatusDescription}");
+
+            _socketProcessingStateChanged = LoggerMessage.Define<int, string, string>(
+                LogLevel.Trace,
+                new EventId(1028, "SocketProcessingStateChanged"),
+                "[Sckt {Id}] processing state change: {PreviousState} -> {NewState}");
+
         }
 
         public static void SocketConnecting(
@@ -286,6 +299,12 @@ namespace CryptoExchange.Net.Logging.Extensions
             _receivedCloseMessage(logger, socketId, webSocketCloseStatus, closeStatusDescription, null);
         }
 
+        public static void SocketReceivedCloseConfirmation(
+            this ILogger logger, int socketId, string webSocketCloseStatus, string closeStatusDescription)
+        {
+            _receivedCloseConfirmation(logger, socketId, webSocketCloseStatus, closeStatusDescription, null);
+        }
+
         public static void SocketReceivedPartialMessage(
             this ILogger logger, int socketId, int countBytes)
         {
@@ -333,5 +352,11 @@ namespace CryptoExchange.Net.Logging.Extensions
         {
             _noDataReceiveTimoutReconnect(logger, socketId, timeSpan, null);
         }
+
+        public static void SocketProcessingStateChanged(
+            this ILogger logger, int socketId, string prevState, string newState)
+        {
+            _socketProcessingStateChanged(logger, socketId, prevState, newState, null);
+        }
     }
 }

CryptoExchange.Net/Objects/ApiProxy.cs

@@ -24,14 +24,14 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// The password of the proxy
         /// </summary>
-        public SecureString? Password { get; }
+        public string? Password { get; }
 
         /// <summary>
         /// Create new settings for a proxy
         /// </summary>
         /// <param name="host">The proxy hostname/ip</param>
         /// <param name="port">The proxy port</param>
-        public ApiProxy(string host, int port): this(host, port, null, (SecureString?)null)
+        public ApiProxy(string host, int port): this(host, port, null, null)
         {
         }
 
@@ -42,18 +42,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="port">The proxy port</param>
         /// <param name="login">The proxy login</param>
         /// <param name="password">The proxy password</param>
-        public ApiProxy(string host, int port, string? login, string? password) : this(host, port, login, password?.ToSecureString())
-        {
-        }
-
-        /// <summary>
-        /// Create new settings for a proxy
-        /// </summary>
-        /// <param name="host">The proxy hostname/ip</param>
-        /// <param name="port">The proxy port</param>
-        /// <param name="login">The proxy login</param>
-        /// <param name="password">The proxy password</param>
-        public ApiProxy(string host, int port, string? login, SecureString? password)
+        public ApiProxy(string host, int port, string? login, string? password)
         {
             Host = host;
             Port = port;

CryptoExchange.Net/Objects/ParameterCollection.cs

@@ -149,6 +149,27 @@ namespace CryptoExchange.Net.Objects
                 Add(key, DateTimeConverter.ConvertToSeconds(value));
         }
 
+        /// <summary>
+        /// Add a datetime value as string seconds timestamp
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        public void AddSecondsString(string key, DateTime value)
+        {
+            Add(key, DateTimeConverter.ConvertToSeconds(value).ToString());
+        }
+
+        /// <summary>
+        /// Add a datetime value as string seconds timestamp. Not added if value is null
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        public void AddOptionalSecondsString(string key, DateTime? value)
+        {
+            if (value != null)
+                Add(key, DateTimeConverter.ConvertToSeconds(value).ToString());
+        }
+
         /// <summary>
         /// Add an enum value as the string value as mapped using the <see cref="MapAttribute" />
         /// </summary>
@@ -167,7 +188,7 @@ namespace CryptoExchange.Net.Objects
         public void AddEnumAsInt<T>(string key, T value)
         {
             var stringVal = EnumConverter.GetString(value);
-            Add(key, EnumConverter.GetString(int.Parse(stringVal))!);
+            Add(key, int.Parse(stringVal)!);
         }
 
         /// <summary>

CryptoExchange.Net/OrderBook/SymbolOrderBook.cs

@@ -810,7 +810,7 @@ namespace CryptoExchange.Net.OrderBook
         {
             if (lastUpdateId <= LastSequenceNumber)
             {
-                _logger.OrderBookUpdateSkipped(Api, Symbol, firstUpdateId, lastUpdateId);
+                _logger.OrderBookUpdateSkipped(Api, Symbol, lastUpdateId, LastSequenceNumber);
                 return;
             }
 

CryptoExchange.Net/RateLimiting/Filters/AuthenticatedEndpointFilter.cs

@@ -21,7 +21,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => definition.Authenticated == _authenticated;
     }
 }

CryptoExchange.Net/RateLimiting/Filters/ExactPathFilter.cs

@@ -24,7 +24,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => string.Equals(definition.Path, _path, StringComparison.OrdinalIgnoreCase);
     }
 }

CryptoExchange.Net/RateLimiting/Filters/ExactPathsFilter.cs

@@ -22,7 +22,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => _paths.Contains(definition.Path);
     }
 }

CryptoExchange.Net/RateLimiting/Filters/HostFilter.cs

@@ -21,7 +21,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => host == _host;
 
     }

CryptoExchange.Net/RateLimiting/Filters/LimitItemTypeFilter.cs

@@ -21,7 +21,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => type == _type;
     }
 }

CryptoExchange.Net/RateLimiting/Filters/PathStartFilter.cs

@@ -22,7 +22,7 @@ namespace CryptoExchange.Net.RateLimiting.Filters
         }
 
         /// <inheritdoc />
-        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey)
+        public bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey)
             => definition.Path.StartsWith(_path, StringComparison.OrdinalIgnoreCase);
     }
 }

CryptoExchange.Net/RateLimiting/Guards/RateLimitGuard.cs

@@ -14,26 +14,26 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <summary>
         /// Apply guard per host
         /// </summary>
-        public static Func<RequestDefinition, string, SecureString?, string> PerHost { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => host);
+        public static Func<RequestDefinition, string, string?, string> PerHost { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => host);
         /// <summary>
         /// Apply guard per endpoint
         /// </summary>
-        public static Func<RequestDefinition, string, SecureString?, string> PerEndpoint { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => def.Path + def.Method);
+        public static Func<RequestDefinition, string, string?, string> PerEndpoint { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => def.Path + def.Method);
         /// <summary>
         /// Apply guard per API key
         /// </summary>
-        public static Func<RequestDefinition, string, SecureString?, string> PerApiKey { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => key!.GetString());
+        public static Func<RequestDefinition, string, string?, string> PerApiKey { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => key!);
         /// <summary>
         /// Apply guard per API key per endpoint
         /// </summary>
-        public static Func<RequestDefinition, string, SecureString?, string> PerApiKeyPerEndpoint { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => key!.GetString() + def.Path + def.Method);
+        public static Func<RequestDefinition, string, string?, string> PerApiKeyPerEndpoint { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => key! + def.Path + def.Method);
 
         private readonly IEnumerable<IGuardFilter> _filters;
         private readonly Dictionary<string, IWindowTracker> _trackers;
         private RateLimitWindowType _windowType;
         private double? _decayRate;
         private int? _connectionWeight;
-        private readonly Func<RequestDefinition, string, SecureString?, string> _keySelector;
+        private readonly Func<RequestDefinition, string, string?, string> _keySelector;
 
         /// <inheritdoc />
         public string Name => "RateLimitGuard";
@@ -60,7 +60,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <param name="windowType">Type of rate limit window</param>
         /// <param name="decayPerTimeSpan">The decay per timespan if windowType is DecayWindowTracker</param>
         /// <param name="connectionWeight">The weight of a new connection</param>
-        public RateLimitGuard(Func<RequestDefinition, string, SecureString?, string> keySelector, IGuardFilter filter, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null)
+        public RateLimitGuard(Func<RequestDefinition, string, string?, string> keySelector, IGuardFilter filter, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null)
             : this(keySelector, new[] { filter }, limit, timeSpan, windowType, decayPerTimeSpan, connectionWeight)
         {
         }
@@ -75,7 +75,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <param name="windowType">Type of rate limit window</param>
         /// <param name="decayPerTimeSpan">The decay per timespan if windowType is DecayWindowTracker</param>
         /// <param name="connectionWeight">The weight of a new connection</param>
-        public RateLimitGuard(Func<RequestDefinition, string, SecureString?, string> keySelector, IEnumerable<IGuardFilter> filters, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null)
+        public RateLimitGuard(Func<RequestDefinition, string, string?, string> keySelector, IEnumerable<IGuardFilter> filters, int limit, TimeSpan timeSpan, RateLimitWindowType windowType, double? decayPerTimeSpan = null, int? connectionWeight = null)
         {
             _filters = filters;
             _trackers = new Dictionary<string, IWindowTracker>();
@@ -88,7 +88,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             foreach(var filter in _filters)
             {
@@ -114,7 +114,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             foreach (var filter in _filters)
             {

CryptoExchange.Net/RateLimiting/Guards/RetryAfterGuard.cs

@@ -38,7 +38,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             var dif = (After + _windowBuffer) - DateTime.UtcNow;
             if (dif <= TimeSpan.Zero)
@@ -48,7 +48,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             return RateLimitState.NotApplied;
         }

CryptoExchange.Net/RateLimiting/Guards/SingleLimitGuard.cs

@@ -15,19 +15,19 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         /// <summary>
         /// Default endpoint limit
         /// </summary>
-        public static Func<RequestDefinition, string, SecureString?, string> Default { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => def.Path + def.Method);
+        public static Func<RequestDefinition, string, string?, string> Default { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => def.Path + def.Method);
 
         /// <summary>
         /// Endpoint limit per API key
         /// </summary>
-        public static Func<RequestDefinition, string, SecureString?, string> PerApiKey { get; } = new Func<RequestDefinition, string, SecureString?, string>((def, host, key) => def.Path + def.Method);
+        public static Func<RequestDefinition, string, string?, string> PerApiKey { get; } = new Func<RequestDefinition, string, string?, string>((def, host, key) => def.Path + def.Method);
 
         private readonly Dictionary<string, IWindowTracker> _trackers;
         private readonly RateLimitWindowType _windowType;
         private readonly double? _decayRate;
         private readonly int _limit;
         private readonly TimeSpan _period;
-        private readonly Func<RequestDefinition, string, SecureString?, string> _keySelector;
+        private readonly Func<RequestDefinition, string, string?, string> _keySelector;
 
         /// <inheritdoc />
         public string Name => "EndpointLimitGuard";
@@ -43,7 +43,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
             TimeSpan period,
             RateLimitWindowType windowType,
             double? decayRate = null,
-            Func<RequestDefinition, string, SecureString?, string>? keySelector = null)
+            Func<RequestDefinition, string, string?, string>? keySelector = null)
         {
             _limit = limit;
             _period = period;
@@ -54,7 +54,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             var key = _keySelector(definition, host, apiKey);
             if (!_trackers.TryGetValue(key, out var tracker))
@@ -71,7 +71,7 @@ namespace CryptoExchange.Net.RateLimiting.Guards
         }
 
         /// <inheritdoc />
-        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight)
+        public RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight)
         {
             var key = _keySelector(definition, host, apiKey);
             var tracker = _trackers[key];

CryptoExchange.Net/RateLimiting/Interfaces/IGuardFilter.cs

@@ -16,6 +16,6 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="host">The host address</param>
         /// <param name="apiKey">The API key</param>
         /// <returns>True if passed</returns>
-        bool Passes(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey);
+        bool Passes(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey);
     }
 }

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGate.cs

@@ -51,7 +51,7 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="behaviour">Behaviour when rate limit is hit</param>
         /// <param name="ct">Cancelation token</param>
         /// <returns>Error if RateLimitingBehaviour is Fail and rate limit is hit</returns>
-        Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string baseAddress, SecureString? apiKey, int requestWeight, RateLimitingBehaviour behaviour, CancellationToken ct);
+        Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string baseAddress, string? apiKey, int requestWeight, RateLimitingBehaviour behaviour, CancellationToken ct);
 
         /// <summary>
         /// Enforces the rate limit as defined in the request definition. When a rate limit is hit will wait for the rate limit to pass if RateLimitingBehaviour is Wait, or return an error if it is set to Fail
@@ -66,6 +66,6 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="behaviour">Behaviour when rate limit is hit</param>
         /// <param name="ct">Cancelation token</param>
         /// <returns>Error if RateLimitingBehaviour is Fail and rate limit is hit</returns>
-        Task<CallResult> ProcessSingleAsync(ILogger logger, int itemId, IRateLimitGuard guard, RateLimitItemType type, RequestDefinition definition, string baseAddress, SecureString? apiKey, RateLimitingBehaviour behaviour, CancellationToken ct);
+        Task<CallResult> ProcessSingleAsync(ILogger logger, int itemId, IRateLimitGuard guard, RateLimitItemType type, RequestDefinition definition, string baseAddress, string? apiKey, RateLimitingBehaviour behaviour, CancellationToken ct);
     }
 }

CryptoExchange.Net/RateLimiting/Interfaces/IRateLimitGuard.cs

@@ -28,7 +28,7 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="apiKey">The API key</param>
         /// <param name="requestWeight">The request weight</param>
         /// <returns></returns>
-        LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight);
+        LimitCheck Check(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight);
 
         /// <summary>
         /// Apply the request to this guard with the specified weight
@@ -39,6 +39,6 @@ namespace CryptoExchange.Net.RateLimiting.Interfaces
         /// <param name="apiKey">The API key</param>
         /// <param name="requestWeight">The request weight</param>
         /// <returns></returns>
-        RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight);
+        RateLimitState ApplyWeight(RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight);
     }
 }

CryptoExchange.Net/RateLimiting/RateLimitGate.cs

@@ -36,7 +36,7 @@ namespace CryptoExchange.Net.RateLimiting
         }
 
         /// <inheritdoc />
-        public async Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
+        public async Task<CallResult> ProcessAsync(ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
         {
             await _semaphore.WaitAsync(ct).ConfigureAwait(false);
             _waitingCount++;
@@ -58,8 +58,8 @@ namespace CryptoExchange.Net.RateLimiting
             IRateLimitGuard guard,
             RateLimitItemType type,
             RequestDefinition definition, 
-            string host, 
-            SecureString? apiKey,
+            string host,
+            string? apiKey,
             RateLimitingBehaviour rateLimitingBehaviour,
             CancellationToken ct)
         {
@@ -77,7 +77,7 @@ namespace CryptoExchange.Net.RateLimiting
             }
         }
 
-        private async Task<CallResult> CheckGuardsAsync(IEnumerable<IRateLimitGuard> guards, ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, SecureString? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
+        private async Task<CallResult> CheckGuardsAsync(IEnumerable<IRateLimitGuard> guards, ILogger logger, int itemId, RateLimitItemType type, RequestDefinition definition, string host, string? apiKey, int requestWeight, RateLimitingBehaviour rateLimitingBehaviour, CancellationToken ct)
         {
             foreach (var guard in guards)
             {

CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs

@@ -233,14 +233,14 @@ namespace CryptoExchange.Net.Sockets
             while (!_stopRequested)
             {
                 _logger.SocketStartingProcessing(Id);
-                _processState = ProcessState.Processing;
+                SetProcessState(ProcessState.Processing);
                 var sendTask = SendLoopAsync();
                 var receiveTask = ReceiveLoopAsync();
                 var timeoutTask = Parameters.Timeout != null && Parameters.Timeout > TimeSpan.FromSeconds(0) ? CheckTimeoutAsync() : Task.CompletedTask;
                 await Task.WhenAll(sendTask, receiveTask, timeoutTask).ConfigureAwait(false);
                 _logger.SocketFinishedProcessing(Id);
 
-                _processState = ProcessState.WaitingForClose;
+                SetProcessState(ProcessState.WaitingForClose);
                 while (_closeTask == null)
                     await Task.Delay(50).ConfigureAwait(false);
 
@@ -250,14 +250,14 @@ namespace CryptoExchange.Net.Sockets
 
                 if (Parameters.ReconnectPolicy == ReconnectPolicy.Disabled)
                 {
-                    _processState = ProcessState.Idle;
+                    SetProcessState(ProcessState.Idle);
                     await (OnClose?.Invoke() ?? Task.CompletedTask).ConfigureAwait(false);
                     return;
                 }
 
                 if (!_stopRequested)
                 {
-                    _processState = ProcessState.Reconnecting;
+                    SetProcessState(ProcessState.Reconnecting);
                     await (OnReconnecting?.Invoke() ?? Task.CompletedTask).ConfigureAwait(false);                    
                 }
 
@@ -296,12 +296,15 @@ namespace CryptoExchange.Net.Sockets
 
                     _reconnectAttempt = 0;
                     _lastReconnectTime = DateTime.UtcNow;
+
+                    // Set to processing before reconnect handling
+                    SetProcessState(ProcessState.Processing);
                     await (OnReconnected?.Invoke() ?? Task.CompletedTask).ConfigureAwait(false);
                     break;
                 }
             }
 
-            _processState = ProcessState.Idle;
+            SetProcessState(ProcessState.Idle);
         }
 
         private TimeSpan GetReconnectDelay()
@@ -391,34 +394,33 @@ namespace CryptoExchange.Net.Sockets
             if (_disposed)
                 return;
 
-            _ctsSource.Cancel();
-
-            if (_socket.State == WebSocketState.Open)
+            try
             {
-                try
-                {
-                    await _socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Closing", default).ConfigureAwait(false);
-                }
-                catch (Exception)
-                {
-                    // Can sometimes throw an exception when socket is in aborted state due to timing
-                    // Websocket is set to Aborted state when the cancelation token is set during SendAsync/ReceiveAsync
-                    // So socket might go to aborted state, might still be open
-                }
-            }
-            else if(_socket.State == WebSocketState.CloseReceived)
-            {
-                try
+                if (_socket.State == WebSocketState.CloseReceived)
                 {
                     await _socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", default).ConfigureAwait(false);
                 }
-                catch (Exception)
+                else if (_socket.State == WebSocketState.Open)
                 {
-                    // Can sometimes throw an exception when socket is in aborted state due to timing
-                    // Websocket is set to Aborted state when the cancelation token is set during SendAsync/ReceiveAsync
-                    // So socket might go to aborted state, might still be open
+                    await _socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Closing", default).ConfigureAwait(false);
+                    var startWait = DateTime.UtcNow;
+                    while (_socket.State != WebSocketState.Closed && _socket.State != WebSocketState.Aborted)
+                    {
+                        // Wait until we receive close confirmation
+                        await Task.Delay(10).ConfigureAwait(false);
+                        if (DateTime.UtcNow - startWait > TimeSpan.FromSeconds(5))
+                            break; // Wait for max 5 seconds, then just abort the connection
+                    }
                 }
             }
+            catch (Exception)
+            {
+                // Can sometimes throw an exception when socket is in aborted state due to timing
+                // Websocket is set to Aborted state when the cancelation token is set during SendAsync/ReceiveAsync
+                // So socket might go to aborted state, might still be open
+            }
+
+            _ctsSource.Cancel();
         }
 
         /// <summary>
@@ -565,10 +567,20 @@ namespace CryptoExchange.Net.Sockets
 
                         if (receiveResult.MessageType == WebSocketMessageType.Close)
                         {
-                            // Connection closed unexpectedly
-                            _logger.SocketReceivedCloseMessage(Id, receiveResult.CloseStatus.ToString(), receiveResult.CloseStatusDescription);
-                            if (_closeTask?.IsCompleted != false)
-                                _closeTask = CloseInternalAsync();
+                            // Connection closed
+                            if (_socket.State == WebSocketState.CloseReceived)
+                            {
+                                // Close received means it server initiated, we should send a confirmation and close the socket
+                                _logger.SocketReceivedCloseMessage(Id, receiveResult.CloseStatus.ToString(), receiveResult.CloseStatusDescription);
+                                if (_closeTask?.IsCompleted != false)
+                                    _closeTask = CloseInternalAsync();
+                            }
+                            else
+                            {
+                                // Means the socket is now closed and we were the one initiating it
+                                _logger.SocketReceivedCloseConfirmation(Id, receiveResult.CloseStatus.ToString(), receiveResult.CloseStatusDescription);
+                            }
+
                             break;
                         }
 
@@ -758,6 +770,15 @@ namespace CryptoExchange.Net.Sockets
             if (proxy.Login != null)
                 socket.Options.Proxy.Credentials = new NetworkCredential(proxy.Login, proxy.Password);
         }
+
+        private void SetProcessState(ProcessState state)
+        {
+            if (_processState == state)
+                return;
+
+            _logger.SocketProcessingStateChanged(Id, _processState.ToString(), state.ToString());
+            _processState = state;
+        }
     }
 
     /// <summary>

CryptoExchange.Net/Sockets/SocketConnection.cs

@@ -420,7 +420,7 @@ namespace CryptoExchange.Net.Sockets
             string? originalData = null;
 
             // 1. Decrypt/Preprocess if necessary
-            data = ApiClient.PreprocessStreamMessage(type, data);
+            data = ApiClient.PreprocessStreamMessage(this, type, data);
 
             // 2. Read data into accessor
             _accessor.Read(data);
@@ -590,12 +590,16 @@ namespace CryptoExchange.Net.Sockets
             bool anyDuplicateSubscription;
             lock (_listenersLock)
                 anyDuplicateSubscription = _listeners.OfType<Subscription>().Any(x => x != subscription && x.ListenerIdentifiers.All(l => subscription.ListenerIdentifiers.Contains(l)));
+
+            bool shouldCloseConnection;
+            lock (_listenersLock)
+                shouldCloseConnection = _listeners.OfType<Subscription>().All(r => !r.UserSubscription || r.Closed) && !DedicatedRequestConnection;
             
             if (!anyDuplicateSubscription)
             {
                 bool needUnsub;
                 lock (_listenersLock)
-                    needUnsub = _listeners.Contains(subscription);
+                    needUnsub = _listeners.Contains(subscription) && !shouldCloseConnection;
 
                 if (needUnsub && _socket.IsOpen)
                     await UnsubscribeAsync(subscription).ConfigureAwait(false);
@@ -611,16 +615,9 @@ namespace CryptoExchange.Net.Sockets
                 return;
             }
 
-            bool shouldCloseConnection;
-            lock (_listenersLock)
-            {
-                shouldCloseConnection = _listeners.OfType<Subscription>().All(r => !r.UserSubscription || r.Closed) && !DedicatedRequestConnection;
-                if (shouldCloseConnection)
-                    Status = SocketStatus.Closing;
-            }
-
             if (shouldCloseConnection)
             {
+                Status = SocketStatus.Closing;
                 _logger.ClosingNoMoreSubscriptions(SocketId);
                 await CloseAsync().ConfigureAwait(false);
             }
@@ -854,31 +851,32 @@ namespace CryptoExchange.Net.Sockets
                 _logger.AuthenticationSucceeded(SocketId);
             }
 
-            // Get a list of all subscriptions on the socket
-            List<Subscription> subList;
-            lock (_listenersLock)
-                subList = _listeners.OfType<Subscription>().ToList();
-
-            foreach(var subscription in subList)
-            {
-                subscription.ConnectionInvocations = 0;
-                var result = await ApiClient.RevitalizeRequestAsync(subscription).ConfigureAwait(false);
-                if (!result)
-                {
-                    _logger.FailedRequestRevitalization(SocketId, result.Error?.ToString());
-                    return result;
-                }
-            }
-
             // Foreach subscription which is subscribed by a subscription request we will need to resend that request to resubscribe
-            for (var i = 0; i < subList.Count; i += ApiClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket)
+            int batch = 0;
+            int batchSize = ApiClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket;
+            while (true)
             {
                 if (!_socket.IsOpen)
                     return new CallResult(new WebError("Socket not connected"));
 
+                List<Subscription> subList;
+                lock (_listenersLock)
+                    subList = _listeners.OfType<Subscription>().Skip(batch * batchSize).Take(batchSize).ToList();
+
+                if (subList.Count == 0)
+                    break;
+
                 var taskList = new List<Task<CallResult>>();
-                foreach (var subscription in subList.Skip(i).Take(ApiClient.ClientOptions.MaxConcurrentResubscriptionsPerSocket))
+                foreach (var subscription in subList)
                 {
+                    subscription.ConnectionInvocations = 0;
+                    var result = await ApiClient.RevitalizeRequestAsync(subscription).ConfigureAwait(false);
+                    if (!result)
+                    {
+                        _logger.FailedRequestRevitalization(SocketId, result.Error?.ToString());
+                        return result;
+                    }
+
                     var subQuery = subscription.GetSubQuery(this);
                     if (subQuery == null)
                         continue;
@@ -897,6 +895,8 @@ namespace CryptoExchange.Net.Sockets
                 await Task.WhenAll(taskList).ConfigureAwait(false);
                 if (taskList.Any(t => !t.Result.Success))
                     return taskList.First(t => !t.Result.Success).Result;
+
+                batch++;
             }
 
             if (!_socket.IsOpen)

CryptoExchange.Net/Testing/Comparers/SystemTextJsonComparer.cs

@@ -151,17 +151,35 @@ namespace CryptoExchange.Net.Testing.Comparers
 
         private static void CheckObject(string method, JProperty prop, object obj, List<string>? ignoreProperties)
         {
-            var resultProperties = obj.GetType().GetProperties().Select(p => (p, ((JsonPropertyNameAttribute?)p.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).SingleOrDefault())?.Name));
+            var publicProperties = obj.GetType().GetProperties(
+                System.Reflection.BindingFlags.Public 
+                | System.Reflection.BindingFlags.GetProperty 
+                | System.Reflection.BindingFlags.SetProperty
+                | System.Reflection.BindingFlags.Instance).Select(p => (p, ((JsonPropertyNameAttribute?)p.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).SingleOrDefault())?.Name));
+
+            var internalProperties = obj.GetType().GetProperties(
+                System.Reflection.BindingFlags.NonPublic
+                | System.Reflection.BindingFlags.GetProperty
+                | System.Reflection.BindingFlags.SetProperty
+                | System.Reflection.BindingFlags.Instance)
+                .Where(p => p.CustomAttributes.Any(x => x.AttributeType == typeof(JsonIncludeAttribute)))
+                .Select(p => (p, ((JsonPropertyNameAttribute?)p.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).SingleOrDefault())?.Name));
+
+            var resultProperties = publicProperties.Concat(internalProperties);
 
             // Property has a value
             var property = resultProperties.SingleOrDefault(p => p.Name == prop.Name).p;
             property ??= resultProperties.SingleOrDefault(p => p.p.Name == prop.Name).p;
-            property ??= resultProperties.SingleOrDefault(p => p.p.Name.Equals(prop.Name, StringComparison.InvariantCultureIgnoreCase)).p;
 
             if (property is null)
                 // Property not found
                 throw new Exception($"{method}: Missing property `{prop.Name}` on `{obj.GetType().Name}`");
 
+            var getMethod = property.GetGetMethod();
+            if (getMethod is null)
+                // There is no getter, so probably just a set for an alternative json name
+                return;
+
             var propertyValue = property.GetValue(obj);
             CheckPropertyValue(method, prop.Value, propertyValue, property.PropertyType, property.Name, prop.Name, ignoreProperties);
         }
@@ -357,6 +375,14 @@ namespace CryptoExchange.Net.Testing.Comparers
                     if (time != DateTimeConverter.ParseFromString(jsonValue.Value<string>()!))
                         throw new Exception($"{method}: {property} not equal: {jsonValue.Value<string>()} vs {time}");
                 }
+                else if (objectValue is bool bl)
+                {
+                    var jsonStr = jsonValue.Value<string>();
+                    if (bl && (jsonStr != "1" && jsonStr != "true" && jsonStr != "True"))
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<string>()} vs {bl}");
+                    if (!bl && (jsonStr != "0" && jsonStr != "-1" && jsonStr != "false" && jsonStr != "False"))
+                        throw new Exception($"{method}: {property} not equal: {jsonValue.Value<string>()} vs {bl}");
+                }
                 else if (propertyType.IsEnum || Nullable.GetUnderlyingType(propertyType)?.IsEnum == true)
                 {
                     // TODO enum comparing

CryptoExchange.Net/Testing/EnumValueTraceListener.cs

@@ -9,12 +9,18 @@ namespace CryptoExchange.Net.Testing
         {
             if (message.Contains("Cannot map"))
                 throw new Exception("Enum value error: " + message);
+
+            if (message.Contains("Received null enum value"))
+                throw new Exception("Enum null error: " + message);
         }
 
         public override void WriteLine(string message)
         {
             if (message.Contains("Cannot map"))
                 throw new Exception("Enum value error: " + message);
+
+            if (message.Contains("Received null enum value"))
+                throw new Exception("Enum null error: " + message);
         }
     }
 }

CryptoExchange.Net/Testing/RestIntergrationTest.cs

@@ -0,0 +1,100 @@
+using CryptoExchange.Net.Objects;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Diagnostics;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Testing
+{
+    /// <summary>
+    /// Base class for executing REST API integration tests
+    /// </summary>
+    /// <typeparam name="TClient">Client type</typeparam>
+    public abstract class RestIntergrationTest<TClient>
+    {
+        /// <summary>
+        /// Get a client instance
+        /// </summary>
+        /// <param name="loggerFactory"></param>
+        /// <returns></returns>
+        public abstract TClient GetClient(ILoggerFactory loggerFactory);
+
+        /// <summary>
+        /// Whether the test should be run. By default integration tests aren't executed, can be set to true to force execution.
+        /// </summary>
+        public virtual bool Run { get; set; }
+
+        /// <summary>
+        /// Whether API credentials are provided and thus authenticated calls can be executed. Should be set in the GetClient implementation.
+        /// </summary>
+        public bool Authenticated { get; set; }
+
+        /// <summary>
+        /// Create a client
+        /// </summary>
+        /// <returns></returns>
+        protected TClient CreateClient()
+        {
+            var fact = new LoggerFactory();
+            fact.AddProvider(new TraceLoggerProvider());
+            return GetClient(fact);
+        }
+
+        /// <summary>
+        /// Check if integration tests should be executed
+        /// </summary>
+        /// <returns></returns>
+        protected bool ShouldRun()
+        {
+            var integrationTests = Environment.GetEnvironmentVariable("INTEGRATION");
+            if (!Run && integrationTests != "1")
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Execute a REST endpoint call and check for any errors or warnings.
+        /// </summary>
+        /// <typeparam name="T">Type of response</typeparam>
+        /// <param name="expression">The call expression</param>
+        /// <param name="authRequest">Whether this is an authenticated request</param>
+        public async Task RunAndCheckResult<T>(Expression<Func<TClient, Task<WebCallResult<T>>>> expression, bool authRequest)
+        {
+            if (!ShouldRun())
+                return;
+
+            var client = CreateClient();
+
+            var expressionBody = (MethodCallExpression)expression.Body;
+            if (authRequest && !Authenticated)
+            {
+                Debug.WriteLine($"Skipping {expressionBody.Method.Name}, not authenticated");
+                return;
+            }
+
+            var listener = new EnumValueTraceListener();
+            Trace.Listeners.Add(listener);
+
+            WebCallResult<T> result;
+            try
+            {
+                result = await expression.Compile().Invoke(client).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Method {expressionBody.Method.Name} threw an exception: " + ex.ToLogString());
+            }
+            finally
+            {
+                Trace.Listeners.Remove(listener);
+            }
+
+            if (!result.Success)
+                throw new Exception($"Method {expressionBody.Method.Name} returned error: " + result.Error);
+
+            Debug.WriteLine($"{expressionBody.Method.Name} {result}");
+        }
+    }
+}

CryptoExchange.Net/Testing/TestHelpers.cs

@@ -121,8 +121,8 @@ namespace CryptoExchange.Net.Testing
             if (disableOrdering)
                 client.OrderParameters = false;
 
-            var uriParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InUri ? client.CreateParameterDictionary(parameters) : new Dictionary<string, object>();
-            var bodyParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InBody ? client.CreateParameterDictionary(parameters) : new Dictionary<string, object>();
+            var uriParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InUri ? client.CreateParameterDictionary(parameters) : null;
+            var bodyParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InBody ? client.CreateParameterDictionary(parameters) : null;
 
             var headers = new Dictionary<string, string>();
 
@@ -131,9 +131,9 @@ namespace CryptoExchange.Net.Testing
                 client, 
                 new Uri(host.AppendPath(path)), 
                 method,
-                uriParams,
-                bodyParams,
-                headers,
+                ref uriParams,
+                ref bodyParams,
+                ref headers,
                 true,
                 client.ArraySerialization, 
                 client.ParameterPositions[method],

README.md

@@ -1,4 +1,4 @@
-# CryptoExchange.Net  
+# ![.CryptoExchange.Net](https://github.com/JKorf/CryptoExchange.Net/blob/ffcb7db8ff597c2f14982d68464015a748815580/CryptoExchange.Net/Icon/icon.png) CryptoExchange.Net  
 
 [![.NET](https://img.shields.io/github/actions/workflow/status/JKorf/CryptoExchange.Net/dotnet.yml?style=for-the-badge)](https://github.com/JKorf/CryptoExchange.Net/actions/workflows/dotnet.yml) [![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.Net.svg?style=for-the-badge)](https://www.nuget.org/packages/CryptoExchange.Net) ![License](https://img.shields.io/github/license/JKorf/CryptoExchange.Net?style=for-the-badge)
 
@@ -16,6 +16,7 @@ The following API's are directly supported. Note that there are 3rd party implem
 |BingX|[JKorf/BingX.Net](https://github.com/JKorf/BingX.Net)|[![Nuget version](https://img.shields.io/nuget/v/JK.BingX.net.svg?style=flat-square)](https://www.nuget.org/packages/JK.BingX.Net)|
 |Bitfinex|[JKorf/Bitfinex.Net](https://github.com/JKorf/Bitfinex.Net)|[![Nuget version](https://img.shields.io/nuget/v/Bitfinex.net.svg?style=flat-square)](https://www.nuget.org/packages/Bitfinex.Net)|
 |Bitget|[JKorf/Bitget.Net](https://github.com/JKorf/Bitget.Net)|[![Nuget version](https://img.shields.io/nuget/v/JK.Bitget.net.svg?style=flat-square)](https://www.nuget.org/packages/JK.Bitget.Net)|
+|BitMart|[JKorf/BitMart.Net](https://github.com/JKorf/BitMart.Net)|[![Nuget version](https://img.shields.io/nuget/v/BitMart.net.svg?style=flat-square)](https://www.nuget.org/packages/BitMart.Net)|
 |Bybit|[JKorf/Bybit.Net](https://github.com/JKorf/Bybit.Net)|[![Nuget version](https://img.shields.io/nuget/v/Bybit.net.svg?style=flat-square)](https://www.nuget.org/packages/Bybit.Net)|
 |CoinEx|[JKorf/CoinEx.Net](https://github.com/JKorf/CoinEx.Net)|[![Nuget version](https://img.shields.io/nuget/v/CoinEx.net.svg?style=flat-square)](https://www.nuget.org/packages/CoinEx.Net)|
 |CoinGecko|[JKorf/CoinGecko.Net](https://github.com/JKorf/CoinGecko.Net)|[![Nuget version](https://img.shields.io/nuget/v/CoinGecko.net.svg?style=flat-square)](https://www.nuget.org/packages/CoinGecko.Net)|
@@ -46,6 +47,32 @@ Make a one time donation in a crypto currency of your choice. If you prefer to d
 Alternatively, sponsor me on Github using [Github Sponsors](https://github.com/sponsors/JKorf). 
 
 ## Release notes
+* Version 7.11.1 - 25 Aug 2024
+    * Improved closing logic websockets
+
+* Version 7.11.0 - 07 Aug 2024
+    * Added ParseString static method on EnumConverter for parsing strings manually
+    * Added support for decimal values in System.Text.Json NumberStringConverter
+    * Added support for `null` string values in System.Text.Json DecimalConverter
+    * Added support for number deserialization when requesting string in System.Text.Json MessageAccessor.GetValue
+    * Added deserialization handling of json values too big to fit decimal value
+    * Decreased some memory allocations during rest request authentication
+    * Fixed subscriptions trying to send unsubscribe request when the socket connection will be closed anyway
+    * Removed SecureString usage in credentials; it's not recommended to be used
+    * Removed some extension methods no longer relevant
+    * Improved testing checks
+
+* Version 7.10.0 - 26 Jul 2024
+    * Added System.Text.Json NumberStringConverter
+    * Added integration testing base class
+    * Added AddSecondsString and AddOptionalSecondsString to ParameterCollection
+    * Added Decompress method for ReadOnlyMemory using non-GZip deflate
+    * Added SocketConnection parameter to SocketConnection PreprocessStreamMessage
+    * Fixed websocket reconnect/unsubscribe timing bug
+    * Fixed issue in System.Text.Json array object deserialization skipping property when skipping an index
+    * Fixed order book logging bug
+    * Fixed bug in ParameterCollection AddEnumAsInt
+
 * Version 7.9.0 - 16 Jul 2024
     * Added some checks in websocket connection handling
     * Added As<T> and AsError<T> methods on untyped WebCallResult

docs/index.html

@@ -141,6 +141,7 @@
 			<tr><td>BingX</td><td><a href="https://github.com/JKorf/BingX.Net">JKorf/BingX.Net</a></td><td><a href="https://www.nuget.org/packages/JK.BingX.Net" target="_blank"><img src="https://img.shields.io/nuget/v/JK.BingX.net.svg?style=flat-square" /></a></td></tr>
 			<tr><td>Bitfinex</td><td><a href="https://github.com/JKorf/Bitfinex.Net">JKorf/Bitfinex.Net</a></td><td><a href="https://www.nuget.org/packages/Bitfinex.Net" target="_blank"><img src="https://img.shields.io/nuget/v/Bitfinex.net.svg?style=flat-square" /></a></td></tr>
 			<tr><td>Bitget</td><td><a href="https://github.com/JKorf/Bitget.Net">JKorf/Bitget.Net</a></td><td><a href="https://www.nuget.org/packages/JK.Bitget.Net" target="_blank"><img src="https://img.shields.io/nuget/v/JK.Bitget.net.svg?style=flat-square" /></a></td></tr>
+			<tr><td>BitMart</td><td><a href="https://github.com/JKorf/BitMart.Net">JKorf/BitMart.Net</a></td><td><a href="https://www.nuget.org/packages/BitMart.Net" target="_blank"><img src="https://img.shields.io/nuget/v/BitMart.net.svg?style=flat-square" /></a></td></tr>
 			<tr><td>Bybit</td><td><a href="https://github.com/JKorf/Bybit.Net">JKorf/Bybit.Net</a></td><td><a href="https://www.nuget.org/packages/Bybit.Net" target="_blank"><img src="https://img.shields.io/nuget/v/Bybit.net.svg?style=flat-square" /></a></td></tr>
 			<tr><td>CoinEx</td><td><a href="https://github.com/JKorf/CoinEx.Net">JKorf/CoinEx.Net</a></td><td><a href="https://www.nuget.org/packages/CoinEx.Net" target="_blank"><img src="https://img.shields.io/nuget/v/CoinEx.net.svg?style=flat-square" /></a></td></tr>
 			<tr><td>CoinGecko</td><td><a href="https://github.com/JKorf/CoinGecko.Net">JKorf/CoinGecko.Net</a></td><td><a href="https://www.nuget.org/packages/CoinGecko.Net" target="_blank"><img src="https://img.shields.io/nuget/v/CoinGecko.net.svg?style=flat-square" /></a></td></tr>
@@ -1389,7 +1390,7 @@ await client.UnsubscribeAllAsync();</code></pre>
 		============================ -->
         <section id="idocs_common">
           <h2>Common Clients</h2>
-		  <p>The CryptoClients.Net client exposes some common client classes. These clients aim to make using the different API's easier.</p>
+		  <p>The CryptoClients.Net library exposes two client classes. These clients aim to make using the different API's easier.</p>
 		  
           <p><b>(I)ExchangeRestClient</b><br />
 			The <code>IExchangeRestClient</code> (or <code>ExchangeRestClient</code> when used directly) can be used to easily access REST clients for different API's.
@@ -2071,7 +2072,10 @@ var client = new OKXRestClient();</code></pre>
 			<div class="tab-wrap">
 			<ul class="nav nav-tabs" id="book" role="tablist" style="margin-bottom: -16px;">
 			  <li class="nav-item" role="presentation">
-				<a class="nav-link active" id="book-binance-tab" data-toggle="tab" href="#book-binance" role="tab" aria-controls="book-binance" aria-selected="true">Binance</a>
+				<a class="nav-link active" id="book-cryptoclients-tab" data-toggle="tab" href="#book-cryptoclients" role="tab" aria-controls="book-cryptoclients" aria-selected="true">CryptoClients</a>
+			  </li>
+			  <li class="nav-item" role="presentation">
+				<a class="nav-link" id="book-binance-tab" data-toggle="tab" href="#book-binance" role="tab" aria-controls="book-binance" aria-selected="false">Binance</a>
 			  </li>
 			  <li class="nav-item" role="presentation">
 				<a class="nav-link" id="book-bingx-tab" data-toggle="tab" href="#book-bingx" role="tab" aria-controls="book-bingx" aria-selected="false">BingX</a>
@@ -2105,7 +2109,21 @@ var client = new OKXRestClient();</code></pre>
 			  </li>
 			</ul>
 			<div class="tab-content my-3" id="myTabContent">
-			  <div class="tab-pane fade show active" id="book-binance" role="tabpanel" aria-labelledby="book-binance-tab">
+			<div class="tab-pane fade show active" id="book-cryptoclients" role="tabpanel" aria-labelledby="book-cryptoclients-tab">
+<pre><code>// Assuming IExchangeOrderBookFactory is injected as bookFactoryClient
+var book = bookFactoryClient.Binance.Spot.Create("ETH", "USDT");
+var startResult = await book.StartAsync();
+if (!startResult.Success)
+{
+    // Handle error, error info available in startResult.Error
+}
+// Book has successfully started and synchronized
+
+// Once no longer needed you can stop the live sync functionality by calling StopAsync()
+await book.StopAsync();
+</code></pre>
+			  </div>
+			  <div class="tab-pane fade" id="book-binance" role="tabpanel" aria-labelledby="book-binance-tab">
 <pre><code>var book = new BinanceSpotSymbolOrderBook("ETHUSDT");
 var startResult = await book.StartAsync();
 if (!startResult.Success)