Updated to version 9.6.0

Updated websocket message to listener matching logic to be more flexible

CryptoExchange.Net.Protobuf/Converters/Protobuf/ProtobufMessageAccessor.cs

@@ -285,7 +285,7 @@ namespace CryptoExchange.Net.Converters.Protobuf
             }
             catch (Exception ex)
             {
-                return new CallResult<object>(new DeserializeError(ex.Message));
+                return new CallResult<object>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
             }
         }
 
@@ -320,7 +320,7 @@ namespace CryptoExchange.Net.Converters.Protobuf
             }
             catch(Exception ex)
             {
-                return new CallResult<T>(new DeserializeError(ex.ToLogString()));
+                return new CallResult<T>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
             }
         }
 
@@ -354,7 +354,7 @@ namespace CryptoExchange.Net.Converters.Protobuf
             {
                 // Not a json message
                 IsValid = false;
-                return Task.FromResult(new CallResult(new DeserializeError("ProtoBufError: " + ex.Message, ex)));
+                return Task.FromResult(new CallResult(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex)));
             }
         }
 
@@ -446,7 +446,7 @@ namespace CryptoExchange.Net.Converters.Protobuf
             }
             catch (Exception ex)
             {
-                return new CallResult<object>(new DeserializeError(ex.ToLogString()));
+                return new CallResult<object>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
             }
         }
 
@@ -485,7 +485,7 @@ namespace CryptoExchange.Net.Converters.Protobuf
             }
             catch (Exception ex)
             {
-                return new CallResult<T>(new DeserializeError(ex.Message));
+                return new CallResult<T>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
             }
         }
 
@@ -504,7 +504,7 @@ namespace CryptoExchange.Net.Converters.Protobuf
             {
                 // Not a json message
                 IsValid = false;
-                return new CallResult(new DeserializeError("ProtobufError: " + ex.Message, ex));
+                return new CallResult(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
             }
         }
 

CryptoExchange.Net.Protobuf/CryptoExchange.Net.Protobuf.csproj

@@ -6,9 +6,9 @@
     <PackageId>CryptoExchange.Net.Protobuf</PackageId>
     <Authors>JKorf</Authors>
     <Description>Protobuf support for CryptoExchange.Net</Description>
-    <PackageVersion>9.2.0</PackageVersion>
+    <PackageVersion>9.6.0</PackageVersion>
-    <AssemblyVersion>9.2.0</AssemblyVersion>
+    <AssemblyVersion>9.6.0</AssemblyVersion>
-    <FileVersion>9.2.0</FileVersion>
+    <FileVersion>9.6.0</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>CryptoExchange;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>
@@ -41,7 +41,7 @@
     <DocumentationFile>CryptoExchange.Net.Protobuf.xml</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="CryptoExchange.Net" Version="9.2.0" />
+    <PackageReference Include="CryptoExchange.Net" Version="9.6.0" />
-    <PackageReference Include="protobuf-net" Version="3.2.52" />
+    <PackageReference Include="protobuf-net" Version="3.2.56" />
   </ItemGroup>
 </Project>

CryptoExchange.Net.Protobuf/README.md

@@ -1,9 +1,22 @@
 # ![.CryptoExchange.Net](https://github.com/JKorf/CryptoExchange.Net/blob/ffcb7db8ff597c2f14982d68464015a748815580/CryptoExchange.Net/Icon/icon.png) CryptoExchange.Net.Proto  
 
-[![.NET](https://img.shields.io/github/actions/workflow/status/JKorf/CryptoExchange.Net.Protobuf/dotnet.yml?style=for-the-badge)](https://github.com/JKorf/CryptoExchange.NetProtobuf/actions/workflows/dotnet.yml) [![Nuget downloads](https://img.shields.io/nuget/dt/CryptoExchange.NetProtobuf.svg?style=for-the-badge)](https://www.nuget.org/packages/CryptoExchange.NetProtobuf) ![License](https://img.shields.io/github/license/JKorf/CryptoExchange.Net?style=for-the-badge)
+[![.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.Protobuf.svg?style=for-the-badge)](https://www.nuget.org/packages/CryptoExchange.Net.Protobuf) ![License](https://img.shields.io/github/license/JKorf/CryptoExchange.Net?style=for-the-badge)
 
 Protobuf support for CryptoExchange.Net.
 
 ## Release notes
+* Version 9.6.0 - 25 Aug 2025
+    * Updated CryptoExchange.Net version to 9.6.0
+
+* Version 9.5.0 - 19 Aug 2025
+    * Updated CryptoExchange.Net version to 9.5.0
+
+* Version 9.4.0 - 04 Aug 2025
+    * Updated CryptoExchange.Net to version 9.4.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+    * Updated protobuf-net package version to 3.2.56
+
+* Version 9.3.0 - 23 Jul 2025
+    * Updated CryptoExchange.Net to version 9.3.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
 * Version 9.2.0 - 14 Jul 2025
     * Initial release

CryptoExchange.Net.UnitTests/CallResultTests.cs

@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using NUnit.Framework;
 using NUnit.Framework.Legacy;
 using System;
@@ -16,9 +17,9 @@ namespace CryptoExchange.Net.UnitTests
         [Test]
         public void TestBasicErrorCallResult()
         {
-            var result = new CallResult(new ServerError("TestError"));
+            var result = new CallResult(new ServerError("TestError", ErrorInfo.Unknown));
 
-            ClassicAssert.AreSame(result.Error.Message, "TestError");
+            ClassicAssert.AreSame(result.Error.ErrorCode, "TestError");
             ClassicAssert.IsFalse(result);
             ClassicAssert.IsFalse(result.Success);
         }
@@ -36,9 +37,9 @@ namespace CryptoExchange.Net.UnitTests
         [Test]
         public void TestCallResultError()
         {
-            var result = new CallResult<object>(new ServerError("TestError"));
+            var result = new CallResult<object>(new ServerError("TestError", ErrorInfo.Unknown));
 
-            ClassicAssert.AreSame(result.Error.Message, "TestError");
+            ClassicAssert.AreSame(result.Error.ErrorCode, "TestError");
             ClassicAssert.IsNull(result.Data);
             ClassicAssert.IsFalse(result);
             ClassicAssert.IsFalse(result.Success);
@@ -71,11 +72,11 @@ namespace CryptoExchange.Net.UnitTests
         [Test]
         public void TestCallResultErrorAs()
         {
-            var result = new CallResult<TestObjectResult>(new ServerError("TestError"));
+            var result = new CallResult<TestObjectResult>(new ServerError("TestError", ErrorInfo.Unknown));
             var asResult = result.As<TestObject2>(default);
 
             ClassicAssert.IsNotNull(asResult.Error);
-            ClassicAssert.AreSame(asResult.Error.Message, "TestError");
+            ClassicAssert.AreSame(asResult.Error.ErrorCode, "TestError");
             ClassicAssert.IsNull(asResult.Data);
             ClassicAssert.IsFalse(asResult);
             ClassicAssert.IsFalse(asResult.Success);
@@ -84,11 +85,11 @@ namespace CryptoExchange.Net.UnitTests
         [Test]
         public void TestCallResultErrorAsError()
         {
-            var result = new CallResult<TestObjectResult>(new ServerError("TestError"));
+            var result = new CallResult<TestObjectResult>(new ServerError("TestError", ErrorInfo.Unknown));
-            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+            var asResult = result.AsError<TestObject2>(new ServerError("TestError2", ErrorInfo.Unknown));
 
             ClassicAssert.IsNotNull(asResult.Error);
-            ClassicAssert.AreSame(asResult.Error.Message, "TestError2");
+            ClassicAssert.AreSame(asResult.Error.ErrorCode, "TestError2");
             ClassicAssert.IsNull(asResult.Data);
             ClassicAssert.IsFalse(asResult);
             ClassicAssert.IsFalse(asResult.Success);
@@ -97,11 +98,11 @@ namespace CryptoExchange.Net.UnitTests
         [Test]
         public void TestWebCallResultErrorAsError()
         {
-            var result = new WebCallResult<TestObjectResult>(new ServerError("TestError"));
+            var result = new WebCallResult<TestObjectResult>(new ServerError("TestError", ErrorInfo.Unknown));
-            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+            var asResult = result.AsError<TestObject2>(new ServerError("TestError2", ErrorInfo.Unknown));
 
             ClassicAssert.IsNotNull(asResult.Error);
-            ClassicAssert.AreSame(asResult.Error.Message, "TestError2");
+            ClassicAssert.AreSame(asResult.Error.ErrorCode, "TestError2");
             ClassicAssert.IsNull(asResult.Data);
             ClassicAssert.IsFalse(asResult);
             ClassicAssert.IsFalse(asResult.Success);
@@ -124,10 +125,10 @@ namespace CryptoExchange.Net.UnitTests
                 ResultDataSource.Server,
                 new TestObjectResult(),
                 null);
-            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+            var asResult = result.AsError<TestObject2>(new ServerError("TestError2", ErrorInfo.Unknown));
 
             ClassicAssert.IsNotNull(asResult.Error);
-            Assert.That(asResult.Error.Message == "TestError2");
+            Assert.That(asResult.Error.ErrorCode == "TestError2");
             Assert.That(asResult.ResponseStatusCode == System.Net.HttpStatusCode.OK);
             Assert.That(asResult.ResponseTime == TimeSpan.FromSeconds(1));
             Assert.That(asResult.RequestUrl == "https://test.com/api");

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -96,7 +96,7 @@ namespace CryptoExchange.Net.UnitTests
             ClassicAssert.IsFalse(result.Success);
             Assert.That(result.Error != null);
             Assert.That(result.Error is ServerError);
-            Assert.That(result.Error.Code == 123);
+            Assert.That(result.Error.ErrorCode == "123");
             Assert.That(result.Error.Message == "Invalid request");
         }
 
@@ -182,7 +182,7 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase("/sapi/test1", true)]
         [TestCase("/sapi/test2", true)]
         [TestCase("/api/test1", false)]
-        [TestCase("sapi/test1", false)]
+        [TestCase("sapi/test1", true)]
         [TestCase("/sapi/", true)]
         public async Task PartialEndpointRateLimiterEndpoints(string endpoint, bool expectLimiting)
         {

CryptoExchange.Net.UnitTests/SystemTextJsonConverterTests.cs

@@ -224,13 +224,17 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(null, null)]
         [TestCase("", null)]
         [TestCase("null", null)]
+        [TestCase("nan", null)]
         [TestCase("1E+2", 100)]
         [TestCase("1E-2", 0.01)]
-        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        [TestCase("Infinity", 999)] // 999 is workaround for not being able to specify decimal.MinValue
+        [TestCase("-Infinity", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        [TestCase("80228162514264337593543950335", 999)] // 999 is workaround for not being able to specify decimal.MaxValue
+        [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));
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MinValue : expected == 999 ? decimal.MaxValue: expected));
         }
 
         [TestCase("1", 1)]

CryptoExchange.Net.UnitTests/TestImplementations/Sockets/TestChannelQuery.cs

@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.Sockets;
 using System;
@@ -31,21 +32,19 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
 
     internal class TestChannelQuery : Query<SubResponse>
     {
-        public override HashSet<string> ListenerIdentifiers { get; set; }
-
         public TestChannelQuery(string channel, string request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
         {
-            ListenerIdentifiers = new HashSet<string> { request + "-" + channel };
+            MessageMatcher = MessageMatcher.Create<SubResponse>(request + "-" + channel, HandleMessage);
         }
 
-        public override CallResult<SubResponse> HandleMessage(SocketConnection connection, DataEvent<SubResponse> message)
+        public CallResult<SubResponse> HandleMessage(SocketConnection connection, DataEvent<SubResponse> message)
         {
             if (!message.Data.Status.Equals("confirmed", StringComparison.OrdinalIgnoreCase))
             {
-                return new CallResult<SubResponse>(new ServerError(message.Data.Status));
+                return new CallResult<SubResponse>(new ServerError(ErrorInfo.Unknown with { Message = message.Data.Status }));
             }
 
-            return base.HandleMessage(connection, message);
+            return message.ToCallResult();
         }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/Sockets/TestQuery.cs

@@ -9,11 +9,9 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
 {
     internal class TestQuery : Query<object>
     {
-        public override HashSet<string> ListenerIdentifiers { get; set; }
-
         public TestQuery(string identifier, object request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
         {
-            ListenerIdentifiers = new HashSet<string> { identifier };
+            MessageMatcher = MessageMatcher.Create<object>(identifier);
         }
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/Sockets/TestSubscription.cs

@@ -15,22 +15,20 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
     {
         private readonly Action<DataEvent<T>> _handler;
 
-        public override HashSet<string> ListenerIdentifiers { get; set; } = new HashSet<string> { "update-topic" };
-
         public TestSubscription(ILogger logger, Action<DataEvent<T>> handler) : base(logger, false)
         {
             _handler = handler;
+
+            MessageMatcher = MessageMatcher.Create<T>("update-topic", DoHandleMessage);
         }
 
-        public override CallResult DoHandleMessage(SocketConnection connection, DataEvent<object> message)
+        public CallResult DoHandleMessage(SocketConnection connection, DataEvent<T> message)
         {
-            var data = (T)message.Data;
+            _handler.Invoke(message);
-            _handler.Invoke(message.As(data));
             return new CallResult(null);
         }
 
-        public override Type GetMessageType(IMessageAccessor message) => typeof(T);
+        protected override Query GetSubQuery(SocketConnection connection) => new TestQuery("sub", new object(), false, 1);
-        public override Query GetSubQuery(SocketConnection connection) => new TestQuery("sub", new object(), false, 1);
+        protected override Query GetUnsubQuery(SocketConnection connection) => new TestQuery("unsub", new object(), false, 1);
-        public override Query GetUnsubQuery() => new TestQuery("unsub", new object(), false, 1);
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/Sockets/TestSubscriptionWithResponseCheck.cs

@@ -15,24 +15,20 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
         private readonly Action<DataEvent<T>> _handler;
         private readonly string _channel;
 
-        public override HashSet<string> ListenerIdentifiers { get; set; }
-
         public TestSubscriptionWithResponseCheck(string channel, Action<DataEvent<T>> handler) : base(Mock.Of<ILogger>(), false)
         {
-            ListenerIdentifiers = new HashSet<string>() { channel };
+            MessageMatcher = MessageMatcher.Create<T>(channel, DoHandleMessage);
             _handler = handler;
             _channel = channel;
         }
 
-        public override CallResult DoHandleMessage(SocketConnection connection, DataEvent<object> message)
+        public CallResult DoHandleMessage(SocketConnection connection, DataEvent<T> message)
         {
-            var data = (T)message.Data;
+            _handler.Invoke(message);
-            _handler.Invoke(message.As(data));
             return new CallResult(null);
         }
 
-        public override Type GetMessageType(IMessageAccessor message) => typeof(T);
+        protected override Query GetSubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "subscribe", false, 1);
-        public override Query GetSubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "subscribe", false, 1);
+        protected override Query GetUnsubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "unsubscribe", false, 1);
-        public override Query GetUnsubQuery() => new TestChannelQuery(_channel, "unsubscribe", false, 1);
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -10,6 +10,7 @@ using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using CryptoExchange.Net.UnitTests.TestImplementations;
@@ -55,7 +56,7 @@ namespace CryptoExchange.Net.UnitTests
             var accessor = CreateAccessor();
             var valid = accessor.Read(stream, true).Result;
             if (!valid)
-                return new CallResult<T>(new ServerError(data));
+                return new CallResult<T>(new ServerError(ErrorInfo.Unknown with { Message = data }));
             
             var deserializeResult = accessor.Deserialize<T>();
             return deserializeResult;
@@ -77,10 +78,10 @@ namespace CryptoExchange.Net.UnitTests
         {
         }
 
-        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 override void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig)
         {
         }
-
+        
         public string GetKey() => _credentials.Key;
         public string GetSecret() => _credentials.Secret;
     }

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -18,6 +18,7 @@ using Microsoft.Extensions.Options;
 using System.Linq;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using System.Text.Json.Serialization;
+using CryptoExchange.Net.Objects.Errors;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
@@ -197,7 +198,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         {
             var errorData = accessor.Deserialize<TestError>();
 
-            return new ServerError(errorData.Data.ErrorCode, errorData.Data.ErrorMessage);
+            return new ServerError(errorData.Data.ErrorCode, GetErrorInfo(errorData.Data.ErrorCode, errorData.Data.ErrorMessage));
         }
 
         public override TimeSpan? GetTimeOffset()

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -51,30 +51,11 @@ namespace CryptoExchange.Net.Authentication
         }
 
         /// <summary>
-        /// Authenticate a request. Output parameters should include the providedParameters input
+        /// Authenticate a request
         /// </summary>
         /// <param name="apiClient">The Api client sending the request</param>
-        /// <param name="uri">The uri for the request</param>
+        /// <param name="requestConfig">The request configuration</param>
-        /// <param name="method">The method of the request</param>
+        public abstract void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig);
-        /// <param name="auth">If the requests should be authenticated</param>
-        /// <param name="arraySerialization">Array serialization type</param>
-        /// <param name="requestBodyFormat">The formatting of the request body</param>
-        /// <param name="uriParameters">Parameters that need to be in the Uri of the request. Should include the provided parameters if they should go in the uri</param>
-        /// <param name="bodyParameters">Parameters that need to be in the body of the request. Should include the provided parameters if they should go in the body</param>
-        /// <param name="headers">The headers that should be send with the request</param>
-        /// <param name="parameterPosition">The position where the providedParameters should go</param>
-        public abstract void AuthenticateRequest(
-            RestApiClient apiClient,
-            Uri uri,
-            HttpMethod method,
-            ref IDictionary<string, object>? uriParameters,
-            ref IDictionary<string, object>? bodyParameters,
-            ref Dictionary<string, string>? headers,
-            bool auth,
-            ArrayParametersSerialization arraySerialization,
-            HttpMethodParameterPosition parameterPosition,
-            RequestBodyFormat requestBodyFormat
-            );
 
         /// <summary>
         /// SHA256 sign the data and return the bytes

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Generic;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Logging;
@@ -54,6 +56,11 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         public ExchangeOptions ClientOptions { get; }
 
+        /// <summary>
+        /// Mapping of a response code to known error types
+        /// </summary>
+        protected internal virtual ErrorMapping ErrorMapping { get; } = new ErrorMapping([]);
+
         /// <summary>
         /// ctor
         /// </summary>
@@ -87,6 +94,16 @@ namespace CryptoExchange.Net.Clients
         /// <inheritdoc />
         public abstract string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
 
+        /// <summary>
+        /// Get error info for a response code
+        /// </summary>
+        public ErrorInfo GetErrorInfo(int code, string? message = null) => GetErrorInfo(code.ToString(), message);
+
+        /// <summary>
+        /// Get error info for a response code
+        /// </summary>
+        public ErrorInfo GetErrorInfo(string code, string? message = null) => ErrorMapping.GetErrorInfo(code.ToString(), message);
+
         /// <inheritdoc />
         public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
         {

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -11,6 +11,7 @@ using CryptoExchange.Net.Caching;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.RateLimiting;
 using CryptoExchange.Net.RateLimiting.Interfaces;
@@ -54,7 +55,7 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Request headers to be sent with each request
         /// </summary>
-        protected Dictionary<string, string>? StandardRequestHeaders { get; set; }
+        protected Dictionary<string, string> StandardRequestHeaders { get; set; } = [];
 
         /// <summary>
         /// Whether parameters need to be ordered
@@ -238,7 +239,7 @@ namespace CryptoExchange.Net.Clients
                     additionalHeaders);
                 _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);
+                var result = await GetResponseAsync<T>(definition, request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
                 if (result.Error is not CancellationRequestedError)
                 {
                     var originalData = OutputOriginalData ? result.OriginalData : "[Data only available when OutputOriginal = true]";
@@ -363,74 +364,58 @@ namespace CryptoExchange.Net.Clients
             ParameterCollection? bodyParameters,
             Dictionary<string, string>? additionalHeaders)
         {
-            var uriParams = uriParameters == null ? null : CreateParameterDictionary(uriParameters);
+            var requestConfiguration = new RestRequestConfiguration(
-            var bodyParams = bodyParameters == null ? null : CreateParameterDictionary(bodyParameters);
+                definition,
+                baseAddress,
+                uriParameters == null ? new Dictionary<string, object>() : CreateParameterDictionary(uriParameters),
+                bodyParameters == null ? new Dictionary<string, object>() : CreateParameterDictionary(bodyParameters),
+                new Dictionary<string, string>(additionalHeaders ?? []),
+                definition.ArraySerialization ?? ArraySerialization,
+                definition.ParameterPosition ?? ParameterPositions[definition.Method],
+                definition.RequestBodyFormat ?? RequestBodyFormat);
 
-            var uri = new Uri(baseAddress.AppendPath(definition.Path));
+            try
-            var arraySerialization = definition.ArraySerialization ?? ArraySerialization;
-            var bodyFormat = definition.RequestBodyFormat ?? RequestBodyFormat;
-            var parameterPosition = definition.ParameterPosition ?? ParameterPositions[definition.Method];
-
-            Dictionary<string, string>? headers = null;
-            if (AuthenticationProvider != null)
             {
-                try
+                AuthenticationProvider?.ProcessRequest(this, requestConfiguration);
-                {
-                    AuthenticationProvider.AuthenticateRequest(
-                        this,
-                        uri,
-                        definition.Method,
-                        ref uriParams,
-                        ref bodyParams,
-                        ref headers,
-                        definition.Authenticated,
-                        arraySerialization,
-                        parameterPosition,
-                        bodyFormat                        
-                        );
-                }
-                catch (Exception ex)
-                {
-                    throw new Exception("Failed to authenticate request, make sure your API credentials are correct", ex);
-                }
             }
+            catch (Exception ex)
+            {
+                throw new Exception("Failed to authenticate request, make sure your API credentials are correct", ex);
+            }
+            
+            var queryString = requestConfiguration.GetQueryString(true);
+            if (!string.IsNullOrEmpty(queryString) && !queryString.StartsWith("?"))
+                queryString = $"?{queryString}";
 
-            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters
+            var uri = new Uri(baseAddress.AppendPath(definition.Path) + queryString);
-            if (uriParams != null)
-                uri = uri.SetParameters(uriParams, arraySerialization);
-
             var request = RequestFactory.Create(definition.Method, uri, requestId);
             request.Accept = Constants.JsonContentHeader;
 
-            if (headers != null)
+            foreach (var header in requestConfiguration.Headers)
-            {
+                request.AddHeader(header.Key, header.Value);            
-                foreach (var header in headers)
-                    request.AddHeader(header.Key, header.Value);
-            }
 
-            if (additionalHeaders != null)
+            foreach (var header in StandardRequestHeaders)
             {
-                foreach (var header in additionalHeaders)
+                // Only add it if it isn't overwritten
+                if (!requestConfiguration.Headers.ContainsKey(header.Key))
                     request.AddHeader(header.Key, header.Value);
-            }
+            }            
 
-            if (StandardRequestHeaders != null)
+            if (requestConfiguration.ParameterPosition == HttpMethodParameterPosition.InBody)
             {
-                foreach (var header in StandardRequestHeaders)
+                var contentType = requestConfiguration.BodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
+                var bodyContent = requestConfiguration.GetBodyContent();
+                if (bodyContent != null)
                 {
-                    // Only add it if it isn't overwritten
+                    request.SetContent(bodyContent, contentType);
-                    if (additionalHeaders?.ContainsKey(header.Key) != true)
-                        request.AddHeader(header.Key, header.Value);
                 }
-            }
-
-            if (parameterPosition == HttpMethodParameterPosition.InBody)
-            {
-                var contentType = bodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;
-                if (bodyParams != null && bodyParams.Count != 0)
-                    WriteParamBody(request, bodyParams, contentType);
                 else
-                    request.SetContent(RequestBodyEmptyContent, contentType);
+                {
+                    if (requestConfiguration.BodyParameters != null && requestConfiguration.BodyParameters.Count != 0)
+                        WriteParamBody(request, requestConfiguration.BodyParameters, contentType);
+                    else
+                        request.SetContent(RequestBodyEmptyContent, contentType);
+                }
             }
 
             return request;
@@ -439,11 +424,13 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Executes the request and returns the result deserialized into the type parameter class
         /// </summary>
+        /// <param name="requestDefinition">The request definition</param>
         /// <param name="request">The request object to execute</param>
         /// <param name="gate">The ratelimit gate used</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <returns></returns>
         protected virtual async Task<WebCallResult<T>> GetResponseAsync<T>(
+            RequestDefinition requestDefinition,
             IRequest request,
             IRateLimitGate? gate,
             CancellationToken cancellationToken)
@@ -463,7 +450,7 @@ namespace CryptoExchange.Net.Clients
                 var outputOriginalData = ApiOptions.OutputOriginalData ?? ClientOptions.OutputOriginalData;
 
                 accessor = CreateAccessor();
-                if (!response.IsSuccessStatusCode)
+                if (!response.IsSuccessStatusCode && !requestDefinition.TryParseOnNonSuccess)
                 {
                     // Error response
                     var readResult = await accessor.Read(responseStream, true).ConfigureAwait(false);
@@ -499,12 +486,11 @@ namespace CryptoExchange.Net.Clients
                 if (!valid)
                 {
                     // Invalid json
-                    var error = new DeserializeError("Failed to parse response: " + valid.Error!.Message, valid.Error.Exception);
+                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, valid.Error);
-                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
                 }
 
                 // Json response received
-                var parsedError = TryParseError(response.ResponseHeaders, accessor);
+                var parsedError = TryParseError(requestDefinition, response.ResponseHeaders, accessor);
                 if (parsedError != null)
                 {
                     if (parsedError is ServerRateLimitError rateError)
@@ -526,7 +512,8 @@ namespace CryptoExchange.Net.Clients
             catch (HttpRequestException requestException)
             {
                 // Request exception, can't reach server for instance
-                return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new WebError(requestException.Message, exception: requestException));
+                var error = new WebError(requestException.Message, requestException);
+                return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
             }
             catch (OperationCanceledException canceledException)
             {
@@ -538,7 +525,9 @@ namespace CryptoExchange.Net.Clients
                 else
                 {
                     // Request timed out
-                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new WebError($"Request timed out", exception: canceledException));
+                    var error = new WebError($"Request timed out", exception: canceledException);
+                    error.ErrorType = ErrorType.Timeout;
+                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
                 }
             }
             finally
@@ -554,10 +543,11 @@ namespace CryptoExchange.Net.Clients
         /// This method will be called for each response to be able to check if the response is an error or not.
         /// If the response is an error this method should return the parsed error, else it should return null
         /// </summary>
+        /// <param name="requestDefinition">Request definition</param>
         /// <param name="accessor">Data accessor</param>
         /// <param name="responseHeaders">The response headers</param>
         /// <returns>Null if not an error, Error otherwise</returns>
-        protected virtual Error? TryParseError(KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor) => null;
+        protected virtual Error? TryParseError(RequestDefinition requestDefinition, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor) => null;
 
         /// <summary>
         /// Can be used to indicate that a request should be retried. Defaults to false. Make sure to retry a max number of times (based on the the tries parameter) or the request will retry forever.
@@ -633,7 +623,7 @@ namespace CryptoExchange.Net.Clients
         /// <returns></returns>
         protected virtual Error ParseErrorResponse(int httpStatusCode, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor, Exception? exception)
         {
-            return new ServerError(null, "Unknown request error", exception);
+            return new ServerError(ErrorInfo.Unknown, exception);
         }
 
         /// <summary>

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.RateLimiting;
@@ -82,6 +83,11 @@ namespace CryptoExchange.Net.Clients
         /// </summary>
         protected bool AllowTopicsOnTheSameConnection { get; set; } = true;
 
+        /// <summary>
+        /// Whether to continue processing and forward unparsable messages to handlers
+        /// </summary>
+        protected internal bool ProcessUnparsableMessages { get; set; } = false;
+
         /// <inheritdoc />
         public double IncomingKbps
         {
@@ -260,11 +266,11 @@ namespace CryptoExchange.Net.Clients
             if (socketConnection.PausedActivity)
             {
                 _logger.HasBeenPausedCantSubscribeAtThisMoment(socketConnection.SocketId);
-                return new CallResult<UpdateSubscription>(new ServerError("Socket is paused"));
+                return new CallResult<UpdateSubscription>(new ServerError(new ErrorInfo(ErrorType.WebsocketPaused, "Socket is paused")));
             }
 
             var waitEvent = new AsyncResetEvent(false);
-            var subQuery = subscription.GetSubQuery(socketConnection);
+            var subQuery = subscription.CreateSubscriptionQuery(socketConnection);
             if (subQuery != null)
             {
                 // Send the request and wait for answer
@@ -308,11 +314,10 @@ namespace CryptoExchange.Net.Clients
         /// Send a query on a socket connection to the BaseAddress and wait for the response
         /// </summary>
         /// <typeparam name="THandlerResponse">Expected result type</typeparam>
-        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
         /// <param name="query">The query</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns></returns>
-        protected virtual Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(Query<TServerResponse, THandlerResponse> query, CancellationToken ct = default)
+        protected virtual Task<CallResult<THandlerResponse>> QueryAsync<THandlerResponse>(Query<THandlerResponse> query, CancellationToken ct = default)
         {
             return QueryAsync(BaseAddress, query, ct);
         }
@@ -321,12 +326,11 @@ namespace CryptoExchange.Net.Clients
         /// Send a query on a socket connection and wait for the response
         /// </summary>
         /// <typeparam name="THandlerResponse">Expected result type</typeparam>
-        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
         /// <param name="url">The url for the request</param>
         /// <param name="query">The query</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns></returns>
-        protected virtual async Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(string url, Query<TServerResponse, THandlerResponse> query, CancellationToken ct = default)
+        protected virtual async Task<CallResult<THandlerResponse>> QueryAsync<THandlerResponse>(string url, Query<THandlerResponse> query, CancellationToken ct = default)
         {
             if (_disposing)
                 return new CallResult<THandlerResponse>(new InvalidOperationError("Client disposed, can't query"));
@@ -365,7 +369,7 @@ namespace CryptoExchange.Net.Clients
             if (socketConnection.PausedActivity)
             {
                 _logger.HasBeenPausedCantSendQueryAtThisMoment(socketConnection.SocketId);
-                return new CallResult<THandlerResponse>(new ServerError("Socket is paused"));
+                return new CallResult<THandlerResponse>(new ServerError(new ErrorInfo(ErrorType.WebsocketPaused, "Socket is paused")));
             }
 
             if (ct.IsCancellationRequested)
@@ -811,7 +815,7 @@ namespace CryptoExchange.Net.Clients
                             sb.AppendLine($"\t\t\tId: {subState.Id}");
                             sb.AppendLine($"\t\t\tConfirmed: {subState.Confirmed}");
                             sb.AppendLine($"\t\t\tInvocations: {subState.Invocations}");
-                            sb.AppendLine($"\t\t\tIdentifiers: [{string.Join(",", subState.Identifiers)}]");
+                            sb.AppendLine($"\t\t\tIdentifiers: [{subState.ListenMatcher.ToString()}]");
                         });
                     }
                 });

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

@@ -60,13 +60,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             }
             catch (JsonException ex)
             {
-                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+                var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
                 return new CallResult<object>(new DeserializeError(info, ex));
             }
             catch (Exception ex)
             {
-                var info = $"Deserialize unknown Exception: {ex.Message}";
+                return new CallResult<object>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-                return new CallResult<object>(new DeserializeError(info, ex));
             }
         }
 
@@ -87,13 +86,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             }
             catch (JsonException ex)
             {
-                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+                var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
                 return new CallResult<T>(new DeserializeError(info, ex));
             }
             catch (Exception ex)
             {
-                var info = $"Unknown exception: {ex.Message}";
+                return new CallResult<T>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-                return new CallResult<T>(new DeserializeError(info, ex));
             }
         }
 
@@ -286,7 +284,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             {
                 // Not a json message
                 IsValid = false;
-                return new CallResult(new DeserializeError("JsonError: " + ex.Message, ex));
+                return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
             }
         }
 
@@ -338,7 +336,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                 {
                     // Value doesn't start with `{` or `[`, prevent deserialization attempt as it's slow
                     IsValid = false;
-                    return new CallResult(new ServerError("Not a json value"));
+                    return new CallResult(new DeserializeError("Not a json value"));
                 }
 
                 _document = JsonDocument.Parse(data);
@@ -349,7 +347,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             {
                 // Not a json message
                 IsValid = false;
-                return new CallResult(new DeserializeError("JsonError: " + ex.Message, ex));
+                return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
             }
         }
 

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -6,11 +6,11 @@
     <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>9.2.0</PackageVersion>
+    <PackageVersion>9.6.0</PackageVersion>
-    <AssemblyVersion>9.2.0</AssemblyVersion>
+    <AssemblyVersion>9.6.0</AssemblyVersion>
-    <FileVersion>9.2.0</FileVersion>
+    <FileVersion>9.6.0</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>
+    <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;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/JKorf/CryptoExchange.Net.git</RepositoryUrl>
     <PackageProjectUrl>https://github.com/JKorf/CryptoExchange.Net</PackageProjectUrl>

CryptoExchange.Net/ExchangeHelpers.cs

@@ -348,22 +348,42 @@ namespace CryptoExchange.Net
         /// </summary>
         public static decimal? ParseDecimal(string? value)
         {
-            if (string.IsNullOrEmpty(value) || string.Equals("null", value, StringComparison.OrdinalIgnoreCase))
+            // Value is null or empty is the most common case to return null so check before trying to parse
+            if (string.IsNullOrEmpty(value))            
+                return null;            
+
+            // Try parse, only fails for these reasons:
+            // 1. string is null or empty
+            // 2. value is larger or smaller than decimal max/min
+            // 3. unparsable format
+            if (decimal.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var decValue))
+                return decValue;
+
+            // Check for values which should be parsed to null
+            if (string.Equals("null", value, StringComparison.OrdinalIgnoreCase)
+                || string.Equals("NaN", value, StringComparison.OrdinalIgnoreCase))
+            {
                 return null;
-
-            if (string.Equals("Infinity", value, StringComparison.Ordinal))
-                // Infinity returned by the server, default to max value
-                return decimal.MaxValue;
-
-            try
-            {
-                return decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture);
             }
-            catch (OverflowException)
+
-            {
+            // Infinity value should be parsed to min/max value
-                // Value doesn't fit decimal, default to max value
+            if (string.Equals("Infinity", value, StringComparison.OrdinalIgnoreCase))
                 return decimal.MaxValue;
+            else if(string.Equals("-Infinity", value, StringComparison.OrdinalIgnoreCase))
+                    return decimal.MinValue;
+
+            if (value!.Length > 27 && decimal.TryParse(value.Substring(0, 27), out var overflowValue))
+            {
+                // Not a valid decimal value and more than 27 chars, from which the first part can be parsed correctly.
+                // assume overflow
+                if (overflowValue < 0)
+                    return decimal.MinValue;
+                else
+                    return decimal.MaxValue;
             }
+
+            // Unknown decimal format, return null
+            return null;
         }
     }
 }

CryptoExchange.Net/ExchangeSymbolCache.cs

@@ -23,14 +23,14 @@ namespace CryptoExchange.Net
         {
             if(!_symbolInfos.TryGetValue(topicId, out var exchangeInfo))
             {
-                exchangeInfo = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => new SharedSymbol(x.TradingMode, x.BaseAsset.ToUpperInvariant(), x.QuoteAsset.ToUpperInvariant(), (x as SharedFuturesSymbol)?.DeliveryTime) { SymbolName = x.Name }));                
+                exchangeInfo = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x.SharedSymbol));                
                 _symbolInfos.TryAdd(topicId, exchangeInfo);
             }
 
             if (DateTime.UtcNow - exchangeInfo.UpdateTime < TimeSpan.FromMinutes(60))
                 return;
 
-            _symbolInfos[topicId] = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => new SharedSymbol(x.TradingMode, x.BaseAsset.ToUpperInvariant(), x.QuoteAsset.ToUpperInvariant(), (x as SharedFuturesSymbol)?.DeliveryTime) { SymbolName = x.Name }));
+            _symbolInfos[topicId] = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x.SharedSymbol));
         }
 
         /// <summary>

CryptoExchange.Net/ExtensionMethods.cs

@@ -498,8 +498,8 @@ namespace CryptoExchange.Net
                 services.AddTransient(x => (IBookTickerSocketClient)client(x)!);
             if (typeof(IKlineSocketClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (IKlineSocketClient)client(x)!);
-            if (typeof(IOrderBookRestClient).IsAssignableFrom(typeof(T)))
+            if (typeof(IOrderBookSocketClient).IsAssignableFrom(typeof(T)))
-                services.AddTransient(x => (IOrderBookRestClient)client(x)!);
+                services.AddTransient(x => (IOrderBookSocketClient)client(x)!);
             if (typeof(ITickerSocketClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (ITickerSocketClient)client(x)!);
             if (typeof(ITickersSocketClient).IsAssignableFrom(typeof(T)))

CryptoExchange.Net/Interfaces/IMessageProcessor.cs

@@ -17,22 +17,13 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         public int Id { get; }
         /// <summary>
-        /// The identifiers for this processor
+        /// The matcher for this listener
         /// </summary>
-        public HashSet<string> ListenerIdentifiers { get; }
+        public MessageMatcher MessageMatcher { get; }
         /// <summary>
         /// Handle a message
         /// </summary>
-        /// <param name="connection"></param>
+        Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message, MessageHandlerLink matchedHandler);
-        /// <param name="message"></param>
-        /// <returns></returns>
-        Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message);
-        /// <summary>
-        /// Get the type the message should be deserialized to
-        /// </summary>
-        /// <param name="messageAccessor"></param>
-        /// <returns></returns>
-        Type? GetMessageType(IMessageAccessor messageAccessor);
         /// <summary>
         /// Deserialize a message into object of type
         /// </summary>

CryptoExchange.Net/Logging/Extensions/SocketConnectionLoggingExtension.cs

@@ -18,7 +18,7 @@ namespace CryptoExchange.Net.Logging.Extensions
         private static readonly Action<ILogger, int, string, Exception?> _failedToParse;
         private static readonly Action<ILogger, int, string, Exception?> _failedToEvaluateMessage;
         private static readonly Action<ILogger, int, Exception?> _errorProcessingMessage;
-        private static readonly Action<ILogger, int, int, string, Exception?> _processorMatched;
+        private static readonly Action<ILogger, int, string, string, Exception?> _processorMatched;
         private static readonly Action<ILogger, int, int, Exception?> _receivedMessageNotRecognized;
         private static readonly Action<ILogger, int, string?, Exception?> _failedToDeserializeMessage;
         private static readonly Action<ILogger, int, string, Exception?> _userMessageProcessingFailed;
@@ -92,11 +92,6 @@ namespace CryptoExchange.Net.Logging.Extensions
                 new EventId(2009, "ErrorProcessingMessage"),
                 "[Sckt {SocketId}] error processing message");
 
-            _processorMatched = LoggerMessage.Define<int, int, string>(
-                LogLevel.Trace,
-                new EventId(2010, "ProcessorMatched"),
-                "[Sckt {SocketId}] {Count} processor(s) matched to message with listener identifier {ListenerId}");
-
             _receivedMessageNotRecognized = LoggerMessage.Define<int, int>(
                 LogLevel.Warning,
                 new EventId(2011, "ReceivedMessageNotRecognized"),
@@ -190,7 +185,7 @@ namespace CryptoExchange.Net.Logging.Extensions
             _receivedMessageNotMatchedToAnyListener = LoggerMessage.Define<int, string, string>(
                 LogLevel.Warning,
                 new EventId(2029, "ReceivedMessageNotMatchedToAnyListener"),
-                "[Sckt {SocketId}] received message not matched to any listener. ListenId: {ListenId}, current listeners: {ListenIds}");
+                "[Sckt {SocketId}] received message not matched to any listener. ListenId: {ListenId}, current listeners: [{ListenIds}]");
 
             _failedToParse = LoggerMessage.Define<int, string>(
                 LogLevel.Warning,
@@ -201,6 +196,12 @@ namespace CryptoExchange.Net.Logging.Extensions
                 LogLevel.Trace,
                 new EventId(2031, "SendingByteData"),
                 "[Sckt {SocketId}] [Req {RequestId}] sending byte message of length: {Length}");
+
+            _processorMatched = LoggerMessage.Define<int, string, string>(
+                LogLevel.Trace,
+                new EventId(2032, "ProcessorMatched"),
+                "[Sckt {SocketId}] listener '{ListenId}' matched to message with listener identifier {ListenerId}");
+
         }
 
         public static void ActivityPaused(this ILogger logger, int socketId, bool paused)
@@ -256,9 +257,9 @@ namespace CryptoExchange.Net.Logging.Extensions
         {
             _errorProcessingMessage(logger, socketId, e);
         }
-        public static void ProcessorMatched(this ILogger logger, int socketId, int count, string listenerId)
+        public static void ProcessorMatched(this ILogger logger, int socketId, string listener, string listenerId)
         {
-            _processorMatched(logger, socketId, count, listenerId, null);
+            _processorMatched(logger, socketId, listener, listenerId, null);
         }
         public static void ReceivedMessageNotRecognized(this ILogger logger, int socketId, int id)
         {

CryptoExchange.Net/Objects/Enums.cs

@@ -251,4 +251,20 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         DEX
     }
+
+    /// <summary>
+    /// Timeout behavior for queries
+    /// </summary>
+    public enum TimeoutBehavior
+    {
+        /// <summary>
+        /// Fail the request
+        /// </summary>
+        Fail,
+        /// <summary>
+        /// Mark the query as successful
+        /// </summary>
+        Succeed
+    }
+
 }

CryptoExchange.Net/Objects/Error.cs

@@ -1,4 +1,5 @@
-using System;
+using CryptoExchange.Net.Objects.Errors;
+using System;
 
 namespace CryptoExchange.Net.Objects
 {
@@ -7,15 +8,52 @@ namespace CryptoExchange.Net.Objects
     /// </summary>
     public abstract class Error
     {
+
+        private int? _code;
         /// <summary>
-        /// The error code from the server
+        /// The int error code the server returned; or the http status code int value if there was no error code.<br />
+        /// <br />
+        /// <i>Note:</i><br />
+        /// The <see cref="ErrorCode"/> property should be used for more generic error checking; it might contain a string error code if the server does not return an int code.
         /// </summary>
-        public int? Code { get; set; }
+        public int? Code 
+        { 
+            get
+            {
+                if (_code.HasValue)
+                    return _code;
+
+                return int.TryParse(ErrorCode, out var r) ? r : null;
+            }
+            set
+            {
+                _code = value;
+            }
+        }
 
         /// <summary>
-        /// The message for the error that occurred
+        /// The error code returned by the server
         /// </summary>
-        public string Message { get; set; }
+        public string? ErrorCode { get; set; }
+        /// <summary>
+        /// The error description
+        /// </summary>
+        public string? ErrorDescription { get; set; }
+
+        /// <summary>
+        /// Error type
+        /// </summary>
+        public ErrorType ErrorType { get; set; }
+
+        /// <summary>
+        /// Whether the error is transient and can be retried
+        /// </summary>
+        public bool IsTransient { get; set; }
+
+        /// <summary>
+        /// The server message for the error that occurred
+        /// </summary>
+        public string? Message { get; set; }
 
         /// <summary>
         /// Underlying exception
@@ -25,10 +63,13 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// ctor
         /// </summary>
-        protected Error (int? code, string message, Exception? exception)
+        protected Error(string? errorCode, ErrorInfo errorInfo, Exception? exception)
         {
-            Code = code;
+            ErrorCode = errorCode;
-            Message = message;
+            ErrorType = errorInfo.ErrorType;
+            Message = errorInfo.Message;
+            ErrorDescription = errorInfo.ErrorDescription;
+            IsTransient = errorInfo.IsTransient;
             Exception = exception;
         }
 
@@ -38,7 +79,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public override string ToString()
         {
-            return Code != null ? $"[{GetType().Name}] {Code}: {Message}" : $"[{GetType().Name}] {Message}";
+            return ErrorCode != null ? $"[{GetType().Name}.{ErrorType}] {ErrorCode}: {Message ?? ErrorDescription}" : $"[{GetType().Name}.{ErrorType}] {Message ?? ErrorDescription}";
         }
     }
 
@@ -48,19 +89,24 @@ namespace CryptoExchange.Net.Objects
     public class CantConnectError : Error
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        public CantConnectError() : base(null, "Can't connect to the server", null) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.UnableToConnect, false, "Can't connect to the server");
 
         /// <summary>
         /// ctor
         /// </summary>
-        public CantConnectError(Exception? exception) : base(null, "Can't connect to the server", exception) { }
+        public CantConnectError() : base(null, _errorInfo, null) { }
 
         /// <summary>
         /// ctor
         /// </summary>
-        protected CantConnectError(int? code, string message, Exception? exception) : base(code, message, exception) { }
+        public CantConnectError(Exception? exception) : base(null, _errorInfo, exception) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected CantConnectError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
     }
 
     /// <summary>
@@ -69,14 +115,19 @@ namespace CryptoExchange.Net.Objects
     public class NoApiCredentialsError : Error
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        public NoApiCredentialsError() : base(null, "No credentials provided for private endpoint", null) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.MissingCredentials, false, "No credentials provided for private endpoint");
 
         /// <summary>
         /// ctor
         /// </summary>
-        protected NoApiCredentialsError(int? code, string message, Exception? exception) : base(code, message, exception) { }
+        public NoApiCredentialsError() : base(null, _errorInfo, null) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected NoApiCredentialsError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
     }
 
     /// <summary>
@@ -87,12 +138,19 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// ctor
         /// </summary>
-        public ServerError(string message) : base(null, message, null) { }
+        public ServerError(ErrorInfo errorInfo, Exception? exception = null)
+             : base(null, errorInfo, exception) { }
 
         /// <summary>
         /// ctor
         /// </summary>
-        public ServerError(int? code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public ServerError(int errorCode, ErrorInfo errorInfo, Exception? exception = null) 
+            : this(errorCode.ToString(), errorInfo, exception) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ServerError(string errorCode, ErrorInfo errorInfo, Exception? exception = null) : base(errorCode, errorInfo, exception) { }
     }
 
     /// <summary>
@@ -101,14 +159,30 @@ namespace CryptoExchange.Net.Objects
     public class WebError : Error
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        public WebError(string message, Exception? exception = null) : base(null, message, exception) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.NetworkError, true, "Failed to complete the request to the server due to a network error");
 
         /// <summary>
         /// ctor
         /// </summary>
-        public WebError(int code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public WebError(string? message = null, Exception? exception = null) : base(null, _errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
+    }
+
+    /// <summary>
+    /// Timeout error waiting for a response from the server
+    /// </summary>
+    public class TimeoutError : Error
+    {
+        /// <summary>
+        /// Default error info
+        /// </summary>
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.Timeout, false, "Failed to receive a response from the server in time");
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public TimeoutError(string? message = null, Exception? exception = null) : base(null, _errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
     }
 
     /// <summary>
@@ -117,30 +191,14 @@ namespace CryptoExchange.Net.Objects
     public class DeserializeError : Error
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        public DeserializeError(string message, Exception? exception = null) : base(null, message, exception) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.DeserializationFailed, false, "Failed to deserialize data");
 
         /// <summary>
         /// ctor
         /// </summary>
-        protected DeserializeError(int? code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public DeserializeError(string? message = null, Exception? exception = null) : base(null, _errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
-    }
-
-    /// <summary>
-    /// Unknown error
-    /// </summary>
-    public class UnknownError : Error
-    {
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public UnknownError(string message, Exception? exception = null) : base(null, message, exception) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        protected UnknownError(int? code, string message, Exception? exception = null): base(code, message, exception) { }
     }
 
     /// <summary>
@@ -149,14 +207,28 @@ namespace CryptoExchange.Net.Objects
     public class ArgumentError : Error
     {
         /// <summary>
-        /// ctor
+        /// Default error info for missing parameter
         /// </summary>
-        public ArgumentError(string message) : base(null, "Invalid parameter: " + message, null) { }
+        protected static readonly ErrorInfo _missingInfo = new ErrorInfo(ErrorType.MissingParameter, false, "Missing parameter");
+        /// <summary>
+        /// Default error info for invalid parameter
+        /// </summary>
+        protected static readonly ErrorInfo _invalidInfo = new ErrorInfo(ErrorType.InvalidParameter, false, "Invalid parameter");
 
         /// <summary>
         /// ctor
         /// </summary>
-        protected ArgumentError(int? code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public static ArgumentError Missing(string parameterName, string? message = null) => new ArgumentError(_missingInfo with { Message = message == null ? $"{_missingInfo.Message} '{parameterName}'" : $"{_missingInfo.Message} '{parameterName}': {message}" }, null);
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public static ArgumentError Invalid(string parameterName, string message) => new ArgumentError(_invalidInfo with { Message = $"{_invalidInfo.Message} '{parameterName}': {message}" }, null);
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected ArgumentError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
     }
 
     /// <summary>
@@ -172,7 +244,7 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// ctor
         /// </summary>
-        protected BaseRateLimitError(int? code, string message, Exception? exception) : base(code, message, exception) { }
+        protected BaseRateLimitError(ErrorInfo errorInfo, Exception? exception) : base(null, errorInfo, exception) { }
     }
 
     /// <summary>
@@ -181,15 +253,19 @@ namespace CryptoExchange.Net.Objects
     public class ClientRateLimitError : BaseRateLimitError
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        /// <param name="message"></param>
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.RateLimitRequest, false, "Client rate limit exceeded");
-        public ClientRateLimitError(string message) : base(null, "Client rate limit exceeded: " + message, null) { }
 
         /// <summary>
         /// ctor
         /// </summary>
-        protected ClientRateLimitError(int? code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public ClientRateLimitError(string? message = null, Exception? exception = null) : base(_errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected ClientRateLimitError(ErrorInfo info, Exception? exception) : base(info, exception) { }
     }
 
     /// <summary>
@@ -198,14 +274,19 @@ namespace CryptoExchange.Net.Objects
     public class ServerRateLimitError : BaseRateLimitError
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        public ServerRateLimitError(string? message = null, Exception? exception = null) : base(null, "Server rate limit exceeded" + (message?.Length > 0 ? " : " + message : null), exception) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.RateLimitRequest, false, "Server rate limit exceeded");
 
         /// <summary>
         /// ctor
         /// </summary>
-        protected ServerRateLimitError(int? code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public ServerRateLimitError(string? message = null, Exception? exception = null) : base(_errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected ServerRateLimitError(ErrorInfo info, Exception? exception) : base(info, exception) { }
     }
 
     /// <summary>
@@ -214,14 +295,19 @@ namespace CryptoExchange.Net.Objects
     public class CancellationRequestedError : Error
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        public CancellationRequestedError(Exception? exception = null) : base(null, "Cancellation requested", exception) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.CancellationRequested, false, "Cancellation requested");
 
         /// <summary>
         /// ctor
         /// </summary>
-        public CancellationRequestedError(int? code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public CancellationRequestedError(Exception? exception = null) : base(null, _errorInfo, null) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected CancellationRequestedError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
     }
 
     /// <summary>
@@ -230,13 +316,18 @@ namespace CryptoExchange.Net.Objects
     public class InvalidOperationError : Error
     {
         /// <summary>
-        /// ctor
+        /// Default error info
         /// </summary>
-        public InvalidOperationError(string message, Exception? exception = null) : base(null, message, exception) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.InvalidOperation, false, "Operation invalid");
 
         /// <summary>
         /// ctor
         /// </summary>
-        protected InvalidOperationError(int? code, string message, Exception? exception = null) : base(code, message, exception) { }
+        public InvalidOperationError(string message) : base(null, _errorInfo with { Message = message }, null) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected InvalidOperationError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
     }
 }

CryptoExchange.Net/Objects/Errors/ErrorEvaluator.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.Objects.Errors
+{
+    /// <summary>
+    /// Error evaluator
+    /// </summary>
+    public class ErrorEvaluator
+    {
+        /// <summary>
+        /// Error code
+        /// </summary>
+        public string[] ErrorCodes { get; set; }
+
+        /// <summary>
+        /// Evaluation callback for determining the error type
+        /// </summary>
+        public Func<string, string?, ErrorInfo> ErrorTypeEvaluator { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ErrorEvaluator(string errorCode, Func<string, string?, ErrorInfo> errorTypeEvaluator)
+        {
+            ErrorCodes = [errorCode];
+            ErrorTypeEvaluator = errorTypeEvaluator;
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ErrorEvaluator(string[] errorCodes, Func<string, string?, ErrorInfo> errorTypeEvaluator)
+        {
+            ErrorCodes = errorCodes;
+            ErrorTypeEvaluator = errorTypeEvaluator;
+        }
+    }
+}

CryptoExchange.Net/Objects/Errors/ErrorInfo.cs

@@ -0,0 +1,58 @@
+using System;
+
+namespace CryptoExchange.Net.Objects.Errors
+{
+    /// <summary>
+    /// Error info
+    /// </summary>
+    public record ErrorInfo
+    {
+        /// <summary>
+        /// Unknown error info
+        /// </summary>
+        public static ErrorInfo Unknown { get; } = new ErrorInfo(ErrorType.Unknown, false, "Unknown error", []);
+
+        /// <summary>
+        /// The server error code
+        /// </summary>
+        public string[] ErrorCodes { get; set; }
+        /// <summary>
+        /// Error description
+        /// </summary>
+        public string? ErrorDescription { get; set; }
+        /// <summary>
+        /// The error type
+        /// </summary>
+        public ErrorType ErrorType { get; set; }
+        /// <summary>
+        /// Whether the error is transient and can be retried
+        /// </summary>
+        public bool IsTransient { get; set; }
+        /// <summary>
+        /// Server response message
+        /// </summary>
+        public string? Message { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ErrorInfo(ErrorType errorType, string description)
+        {
+            ErrorCodes = [];
+            ErrorType = errorType;
+            IsTransient = false;
+            ErrorDescription = description;
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ErrorInfo(ErrorType errorType, bool isTransient, string description, params string[] errorCodes)
+        {
+            ErrorCodes = errorCodes;
+            ErrorType = errorType;
+            IsTransient = isTransient;
+            ErrorDescription = description;
+        }
+    }
+}

CryptoExchange.Net/Objects/Errors/ErrorMapping.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace CryptoExchange.Net.Objects.Errors
+{
+    /// <summary>
+    /// Error mapping collection
+    /// </summary>
+    public class ErrorMapping
+    {
+        private Dictionary<string, ErrorEvaluator> _evaluators = new Dictionary<string, ErrorEvaluator>();
+        private Dictionary<string, ErrorInfo> _directMapping = new Dictionary<string, ErrorInfo>();
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ErrorMapping(ErrorInfo[] errorMappings, ErrorEvaluator[]? errorTypeEvaluators = null)
+        {
+            foreach (var item in errorMappings)
+            {
+                if (!item.ErrorCodes.Any())
+                    throw new Exception("Error codes can't be null in error mapping");
+
+                foreach(var code in item.ErrorCodes!)
+                    _directMapping.Add(code, item);
+            }
+
+            if (errorTypeEvaluators == null)
+                return;
+
+            foreach (var item in errorTypeEvaluators)
+            {
+                foreach(var code in item.ErrorCodes)
+                    _evaluators.Add(code, item);
+            }
+        }
+
+        /// <summary>
+        /// Get error info for an error code
+        /// </summary>
+        public ErrorInfo GetErrorInfo(string code, string? message)
+        {
+            if (_directMapping.TryGetValue(code!, out var info))
+                return info with { Message = message };
+            
+            if (_evaluators.TryGetValue(code!, out var eva))
+                return eva.ErrorTypeEvaluator.Invoke(code!, message) with { Message = message };
+
+            return ErrorInfo.Unknown with { Message = message };
+        }
+    }
+}

CryptoExchange.Net/Objects/Errors/ErrorType.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.Objects.Errors
+{
+    /// <summary>
+    /// Type of error
+    /// </summary>
+    public enum ErrorType
+    {
+        #region Library errors
+
+        /// <summary>
+        /// Failed to connect to server
+        /// </summary>
+        UnableToConnect,
+        /// <summary>
+        /// Failed to complete the request to the server
+        /// </summary>
+        NetworkError,
+        /// <summary>
+        /// No API credentials have been specified
+        /// </summary>
+        MissingCredentials,
+        /// <summary>
+        /// Invalid parameter value
+        /// </summary>
+        InvalidParameter,
+        /// <summary>
+        /// Missing parameter value
+        /// </summary>
+        MissingParameter,
+        /// <summary>
+        /// Cancellation requested by user
+        /// </summary>
+        CancellationRequested,
+        /// <summary>
+        /// Invalid operation requested
+        /// </summary>
+        InvalidOperation,
+        /// <summary>
+        /// Failed to deserialize data
+        /// </summary>
+        DeserializationFailed,
+        /// <summary>
+        /// Websocket is temporarily paused
+        /// </summary>
+        WebsocketPaused,
+        /// <summary>
+        /// Timeout while waiting for data from the order book subscription
+        /// </summary>
+        OrderBookTimeout,
+        /// <summary>
+        /// All orders failed for a multi-order operation
+        /// </summary>
+        AllOrdersFailed,
+        /// <summary>
+        /// Request timeout
+        /// </summary>
+        Timeout,
+
+        #endregion
+
+        #region Server errors
+
+        /// <summary>
+        /// Unknown error
+        /// </summary>
+        Unknown,
+        /// <summary>
+        /// Not authorized or insufficient permissions
+        /// </summary>
+        Unauthorized,
+        /// <summary>
+        /// Request rate limit error, too many requests 
+        /// </summary>
+        RateLimitRequest,
+        /// <summary>
+        /// Connection rate limit error, too many connections
+        /// </summary>
+        RateLimitConnection,
+        /// <summary>
+        /// Subscription rate limit error, too many subscriptions
+        /// </summary>
+        RateLimitSubscription,
+        /// <summary>
+        /// Order rate limit error, too many orders
+        /// </summary>
+        RateLimitOrder,
+        /// <summary>
+        /// Request timestamp invalid
+        /// </summary>
+        InvalidTimestamp,
+        /// <summary>
+        /// Unknown symbol
+        /// </summary>
+        UnknownSymbol,
+        /// <summary>
+        /// Unknown asset
+        /// </summary>
+        UnknownAsset,
+        /// <summary>
+        /// Unknown order
+        /// </summary>
+        UnknownOrder,
+        /// <summary>
+        /// Duplicate subscription
+        /// </summary>
+        DuplicateSubscription,
+        /// <summary>
+        /// Invalid quantity
+        /// </summary>
+        InvalidQuantity,
+        /// <summary>
+        /// Invalid price
+        /// </summary>
+        InvalidPrice,
+        /// <summary>
+        /// Parameter(s) for stop or tp/sl order invalid
+        /// </summary>
+        InvalidStopParameters,
+        /// <summary>
+        /// Not enough balance to execute request
+        /// </summary>
+        InsufficientBalance,
+        /// <summary>
+        /// Client order id already in use
+        /// </summary>
+        DuplicateClientOrderId,
+        /// <summary>
+        /// Symbol is not currently trading
+        /// </summary>
+        UnavailableSymbol,
+        /// <summary>
+        /// Order rejected due to order configuration such as order type or time in force restrictions
+        /// </summary>
+        RejectedOrderConfiguration,
+        /// <summary>
+        /// There is no open position
+        /// </summary>
+        NoPosition,
+        /// <summary>
+        /// Max position reached
+        /// </summary>
+        MaxPosition,
+        /// <summary>
+        /// Error in the internal system
+        /// </summary>
+        SystemError,
+        /// <summary>
+        /// The target object is not in the correct state for an operation
+        /// </summary>
+        IncorrectState,
+        /// <summary>
+        /// Risk management error
+        /// </summary>
+        RiskError
+
+        #endregion
+    }
+}

CryptoExchange.Net/Objects/RequestDefinition.cs

@@ -62,6 +62,11 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         public bool PreventCaching { get; set; }
 
+        /// <summary>
+        /// Whether the response to this requests should attempted to be parsed even when the status indicates failure
+        /// </summary>
+        public bool TryParseOnNonSuccess { get; set; }
+
         /// <summary>
         /// Connection id
         /// </summary>
@@ -76,6 +81,9 @@ namespace CryptoExchange.Net.Objects
         {
             Path = path;
             Method = method;
+
+            if (!Path.StartsWith("/"))
+                Path = $"/{Path}";
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Objects/RequestDefinitionCache.cs

@@ -46,6 +46,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="parameterPosition">Parameter position</param>
         /// <param name="arraySerialization">Array serialization type</param>
         /// <param name="preventCaching">Prevent request caching</param>
+        /// <param name="tryParseOnNonSuccess">Try parse the response even when status is not success</param>
         /// <returns></returns>
         public RequestDefinition GetOrCreate(
             HttpMethod method,
@@ -57,8 +58,9 @@ namespace CryptoExchange.Net.Objects
             RequestBodyFormat? requestBodyFormat = null,
             HttpMethodParameterPosition? parameterPosition = null,
             ArrayParametersSerialization? arraySerialization = null,
-            bool? preventCaching = null)
+            bool? preventCaching = null,
-            => GetOrCreate(method + path, method, path, rateLimitGate, weight, authenticated, limitGuard, requestBodyFormat, parameterPosition, arraySerialization, preventCaching);
+            bool? tryParseOnNonSuccess = null)
+            => GetOrCreate(method + path, method, path, rateLimitGate, weight, authenticated, limitGuard, requestBodyFormat, parameterPosition, arraySerialization, preventCaching, tryParseOnNonSuccess);
 
         /// <summary>
         /// Get a definition if it is already in the cache or create a new definition and add it to the cache
@@ -74,6 +76,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="parameterPosition">Parameter position</param>
         /// <param name="arraySerialization">Array serialization type</param>
         /// <param name="preventCaching">Prevent request caching</param>
+        /// <param name="tryParseOnNonSuccess">Try parse the response even when status is not success</param>
         /// <returns></returns>
         public RequestDefinition GetOrCreate(
             string identifier,
@@ -86,7 +89,8 @@ namespace CryptoExchange.Net.Objects
             RequestBodyFormat? requestBodyFormat = null,
             HttpMethodParameterPosition? parameterPosition = null,
             ArrayParametersSerialization? arraySerialization = null,
-            bool? preventCaching = null)
+            bool? preventCaching = null,
+            bool? tryParseOnNonSuccess = null)
         {
 
             if (!_definitions.TryGetValue(identifier, out var def))
@@ -100,7 +104,8 @@ namespace CryptoExchange.Net.Objects
                     ArraySerialization = arraySerialization,
                     RequestBodyFormat = requestBodyFormat,
                     ParameterPosition = parameterPosition,
-                    PreventCaching = preventCaching ?? false
+                    PreventCaching = preventCaching ?? false,
+                    TryParseOnNonSuccess = tryParseOnNonSuccess ?? false
                 };
                 _definitions.TryAdd(identifier, def);
             }

CryptoExchange.Net/Objects/RestRequestConfiguration.cs

@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using System.Net.Http;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Rest request configuration
+    /// </summary>
+    public class RestRequestConfiguration
+    {
+        private string? _bodyContent;
+        private string? _queryString;
+
+        /// <summary>
+        /// Http method
+        /// </summary>
+        public HttpMethod Method { get; set; }
+        /// <summary>
+        /// Whether the request needs authentication
+        /// </summary>
+        public bool Authenticated { get; set; }
+        /// <summary>
+        /// Base address for the request
+        /// </summary>
+        public string BaseAddress { get; set; }
+        /// <summary>
+        /// The request path
+        /// </summary>
+        public string Path { get; set; }
+        /// <summary>
+        /// Query parameters
+        /// </summary>
+        public IDictionary<string, object> QueryParameters { get; set; }
+        /// <summary>
+        /// Body parameters
+        /// </summary>
+        public IDictionary<string, object> BodyParameters { get; set; }
+        /// <summary>
+        /// Request headers
+        /// </summary>
+        public IDictionary<string, string> Headers { get; set; }
+        /// <summary>
+        /// Array serialization type
+        /// </summary>
+        public ArrayParametersSerialization ArraySerialization { get; set; }
+        /// <summary>
+        /// Position of the parameters
+        /// </summary>
+        public HttpMethodParameterPosition ParameterPosition { get; set; }
+        /// <summary>
+        /// Body format
+        /// </summary>
+        public RequestBodyFormat BodyFormat { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public RestRequestConfiguration(
+            RequestDefinition requestDefinition,
+            string baseAddress,
+            IDictionary<string, object> queryParams,
+            IDictionary<string, object> bodyParams,
+            IDictionary<string, string> headers,
+            ArrayParametersSerialization arraySerialization,
+            HttpMethodParameterPosition parametersPosition,
+            RequestBodyFormat bodyFormat)
+        {
+            Method = requestDefinition.Method;
+            Authenticated = requestDefinition.Authenticated;
+            Path = requestDefinition.Path;
+            BaseAddress = baseAddress;
+            QueryParameters = queryParams;
+            BodyParameters = bodyParams;
+            Headers = headers;
+            ArraySerialization = arraySerialization;
+            ParameterPosition = parametersPosition;
+            BodyFormat = bodyFormat;
+        }
+
+        /// <summary>
+        /// Get the parameter collection based on the ParameterPosition
+        /// </summary>
+        public IDictionary<string, object> GetPositionParameters()
+        {
+            if (ParameterPosition == HttpMethodParameterPosition.InBody)
+                return BodyParameters;
+
+            return QueryParameters;
+        }
+
+        /// <summary>
+        /// Get the query string. If it's not previously set it will return a newly formatted query string. If previously set return that.
+        /// </summary>
+        /// <param name="urlEncode">Whether to URL encode the parameter string if creating new</param>
+        public string GetQueryString(bool urlEncode = true)
+        {
+            return _queryString ?? QueryParameters.CreateParamString(urlEncode, ArraySerialization);
+        }
+
+        /// <summary>
+        /// Set the query string of the request. Will be returned by subsequent <see cref="GetQueryString" /> calls
+        /// </summary>
+        public void SetQueryString(string value)
+        {
+            _queryString = value;
+        }
+
+        /// <summary>
+        /// Get the body content if it's previously set
+        /// </summary>
+        public string? GetBodyContent()
+        {
+            return _bodyContent;
+        }
+
+        /// <summary>
+        /// Set the body content for the request
+        /// </summary>
+        public void SetBodyContent(string content)
+        {
+            _bodyContent = content;
+        }
+    }
+}

CryptoExchange.Net/OrderBook/SymbolOrderBook.cs

@@ -9,6 +9,7 @@ using System.Threading.Tasks;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 using Microsoft.Extensions.Logging;
@@ -549,7 +550,7 @@ namespace CryptoExchange.Net.OrderBook
                     return new CallResult<bool>(new CancellationRequestedError());
 
                 if (DateTime.UtcNow - startWait > timeout)
-                    return new CallResult<bool>(new ServerError("Timeout while waiting for data"));
+                    return new CallResult<bool>(new ServerError(new ErrorInfo(ErrorType.OrderBookTimeout, "Timeout while waiting for data")));
 
                 try
                 {

CryptoExchange.Net/SharedApis/Enums/SharedQuantityType.cs

@@ -20,6 +20,10 @@
         /// <summary>
         /// Quantity can be either base or quote quantity
         /// </summary>
-        BaseAndQuoteAsset
+        BaseAndQuoteAsset,
+        /// <summary>
+        /// Quantity can be either base or quote quantity, or in contracts
+        /// </summary>
+        BaseAndQuoteAssetAndContracts
     }
 }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/EndpointOptions.cs

@@ -58,19 +58,19 @@ namespace CryptoExchange.Net.SharedApis
         public virtual Error? ValidateRequest(string exchange, ExchangeParameters? exchangeParameters, TradingMode? tradingMode, TradingMode[] supportedTradingModes)
         {
             if (tradingMode != null && !supportedTradingModes.Contains(tradingMode.Value))
-                return new ArgumentError($"ApiType.{tradingMode} is not supported, supported types: {string.Join(", ", supportedTradingModes)}");
+                return ArgumentError.Invalid("TradingMode", $"TradingMode.{tradingMode} is not supported, supported types: {string.Join(", ", supportedTradingModes)}");
 
             foreach (var param in RequiredExchangeParameters)
             {
                 if (!string.IsNullOrEmpty(param.Name))
                 {
                     if (ExchangeParameters.HasValue(exchangeParameters, exchange, param.Name!, param.ValueType) != true)
-                        return new ArgumentError($"Required exchange parameter `{param.Name}` for exchange `{exchange}` is missing or has incorrect type. Expected type is {param.ValueType.Name}. Example: {param.ExampleValue}");
+                        return ArgumentError.Invalid(param.Name!, $"Required exchange parameter `{param.Name}` for exchange `{exchange}` is missing or has incorrect type. Expected type is {param.ValueType.Name}. Example: {param.ExampleValue}");
                 }
                 else
                 {
                     if (param.Names!.All(x => ExchangeParameters.HasValue(exchangeParameters, exchange, x, param.ValueType) != true))
-                        return new ArgumentError($"One of exchange parameters `{string.Join(", ", param.Names!)}` for exchange `{exchange}` should be provided. Example: {param.ExampleValue}");
+                        return ArgumentError.Invalid(string.Join("/", param.Names!), $"One of exchange parameters `{string.Join(", ", param.Names!)}` for exchange `{exchange}` should be provided. Example: {param.ExampleValue}");
                 }
             }
 
@@ -109,6 +109,15 @@ namespace CryptoExchange.Net.SharedApis
         /// </summary>
         public List<ParameterDescription> RequiredOptionalParameters { get; set; } = new List<ParameterDescription>();
 
+        /// <summary>
+        /// Whether this accepts multiple symbols (Only applicable to request requiring symbol parameters)
+        /// </summary>
+        public bool SupportsMultipleSymbols { get; set; } = false;
+        /// <summary>
+        /// The max number of symbols which can be passed in a call (Only applicable to request requiring symbol parameters)
+        /// </summary>
+        public int? MaxSymbolCount { get; set; }
+
         /// <summary>
         /// ctor
         /// </summary>
@@ -131,12 +140,25 @@ namespace CryptoExchange.Net.SharedApis
                 if (!string.IsNullOrEmpty(param.Name))
                 {
                     if (typeof(T).GetProperty(param.Name)!.GetValue(request, null) == null)
-                        return new ArgumentError($"Required optional parameter `{param.Name}` for exchange `{exchange}` is missing. Example: {param.ExampleValue}");
+                        return ArgumentError.Invalid(param.Name!, $"Required optional parameter `{param.Name}` for exchange `{exchange}` is missing. Example: {param.ExampleValue}");
                 }
                 else
                 {
                     if (param.Names!.All(x => typeof(T).GetProperty(param.Name!)!.GetValue(request, null) == null))
-                        return new ArgumentError($"One of optional parameters `{string.Join(", ", param.Names!)}` for exchange `{exchange}` should be provided. Example: {param.ExampleValue}");
+                        return ArgumentError.Invalid(string.Join("/", param.Names!), $"One of optional parameters `{string.Join(", ", param.Names!)}` for exchange `{exchange}` should be provided. Example: {param.ExampleValue}");
+                }
+
+            }
+
+            if (request is SharedSymbolRequest symbolsRequest)
+            {
+                if (symbolsRequest.Symbols != null) 
+                {
+                    if (!SupportsMultipleSymbols)
+                        return ArgumentError.Invalid(nameof(SharedSymbolRequest.Symbols), $"Only a single symbol parameter is allowed, multiple symbols are not supported");
+
+                    if (symbolsRequest.Symbols.Length > MaxSymbolCount)
+                        return ArgumentError.Invalid(nameof(SharedSymbolRequest.Symbols), $"Max number of symbols is {MaxSymbolCount} but {symbolsRequest.Symbols.Length} were passed");
                 }
 
             }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetClosedOrdersOptions.cs

@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
         public override Error? ValidateRequest(string exchange, GetClosedOrdersRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
         {
             if (TimeFilterSupported && request.StartTime != null)
-                return new ArgumentError($"Time filter is not supported");
+                return ArgumentError.Invalid(nameof(GetClosedOrdersRequest.StartTime), $"Time filter is not supported");
 
             return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
         }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetDepositsOptions.cs

@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
         public override Error? ValidateRequest(string exchange, GetDepositsRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
         {
             if (TimeFilterSupported && request.StartTime != null)
-                return new ArgumentError($"Time filter is not supported");
+                return ArgumentError.Invalid(nameof(GetDepositsRequest.StartTime), $"Time filter is not supported");
 
             return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
         }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetKlinesOptions.cs

@@ -67,23 +67,23 @@ namespace CryptoExchange.Net.SharedApis
         public override Error? ValidateRequest(string exchange, GetKlinesRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
         {
             if (!IsSupported(request.Interval))
-                return new ArgumentError("Interval not supported");
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.Interval), "Interval not supported");
 
             if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
-                return new ArgumentError($"Only the most recent {MaxAge} klines are available");
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxAge} klines are available");
 
             if (request.Limit > MaxLimit)
-                return new ArgumentError($"Only {MaxLimit} klines can be retrieved per request");
+                return ArgumentError.Invalid(nameof(GetKlinesRequest.Limit), $"Only {MaxLimit} klines can be retrieved per request");
 
             if (MaxTotalDataPoints.HasValue)
             {
                 if (request.Limit > MaxTotalDataPoints.Value)
-                    return new ArgumentError($"Only the most recent {MaxTotalDataPoints} klines are available");
+                    return ArgumentError.Invalid(nameof(GetKlinesRequest.Limit), $"Only the most recent {MaxTotalDataPoints} klines are available");
 
                 if (request.StartTime.HasValue == true)
                 {
                     if (((request.EndTime ?? DateTime.UtcNow) - request.StartTime.Value).TotalSeconds / (int)request.Interval > MaxTotalDataPoints.Value)
-                        return new ArgumentError($"Only the most recent {MaxTotalDataPoints} klines are available, time filter failed");
+                        return ArgumentError.Invalid(nameof(GetKlinesRequest.StartTime), $"Only the most recent {MaxTotalDataPoints} klines are available, time filter failed");
                 }
             }
 

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetOrderBookOptions.cs

@@ -49,13 +49,13 @@ namespace CryptoExchange.Net.SharedApis
                 return null;
 
             if (MaxLimit.HasValue && request.Limit.Value > MaxLimit)
-                return new ArgumentError($"Max limit is {MaxLimit}");
+                return ArgumentError.Invalid(nameof(GetOrderBookRequest.Limit), $"Max limit is {MaxLimit}");
 
             if (MinLimit.HasValue && request.Limit.Value < MinLimit)
-                return new ArgumentError($"Min limit is {MaxLimit}");
+                return ArgumentError.Invalid(nameof(GetOrderBookRequest.Limit), $"Min limit is {MaxLimit}");
 
             if (SupportedLimits != null && !SupportedLimits.Contains(request.Limit.Value))
-                return new ArgumentError($"Limit should be one of " + string.Join(", ", SupportedLimits));
+                return ArgumentError.Invalid(nameof(GetOrderBookRequest.Limit), $"Limit should be one of " + string.Join(", ", SupportedLimits));
 
             return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
         }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetRecentTradesOptions.cs

@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
         public Error? Validate(GetRecentTradesRequest request)
         {
             if (request.Limit > MaxLimit)
-                return new ArgumentError($"Only the most recent {MaxLimit} trades are available");
+                return ArgumentError.Invalid(nameof(GetRecentTradesRequest.Limit), $"Only the most recent {MaxLimit} trades are available");
 
             return null;
         }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetTradeHistoryOptions.cs

@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
         public override Error? ValidateRequest(string exchange, GetTradeHistoryRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
         {
             if (MaxAge.HasValue && request.StartTime < DateTime.UtcNow.Add(-MaxAge.Value))
-                return new ArgumentError($"Only the most recent {MaxAge} trades are available");
+                return ArgumentError.Invalid(nameof(GetTradeHistoryRequest.StartTime), $"Only the most recent {MaxAge} trades are available");
 
             return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
         }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetWithdrawalsOptions.cs

@@ -25,7 +25,7 @@ namespace CryptoExchange.Net.SharedApis
         public override Error? ValidateRequest(string exchange, GetWithdrawalsRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
         {
             if (TimeFilterSupported && request.StartTime != null)
-                return new ArgumentError($"Time filter is not supported");
+                return ArgumentError.Invalid(nameof(GetWithdrawalsRequest.StartTime), $"Time filter is not supported");
 
             return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
         }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/PlaceFuturesOrderOptions.cs

@@ -36,16 +36,16 @@ namespace CryptoExchange.Net.SharedApis
             SharedQuantitySupport quantitySupport)
         {
             if (!SupportsTpSl && (request.StopLossPrice != null || request.TakeProfitPrice != null))
-                return new ArgumentError("Tp/Sl parameters not supported");
+                return ArgumentError.Invalid(nameof(PlaceFuturesOrderRequest.StopLossPrice) + " / " + nameof(PlaceFuturesOrderRequest.TakeProfitPrice), "Tp/Sl parameters not supported");
 
             if (request.OrderType == SharedOrderType.Other)
                 throw new ArgumentException("OrderType can't be `Other`", nameof(request.OrderType));
 
             if (!supportedOrderTypes.Contains(request.OrderType))
-                return new ArgumentError("Order type not supported");
+                return ArgumentError.Invalid(nameof(PlaceFuturesOrderRequest.OrderType), "Order type not supported");
 
             if (request.TimeInForce != null && !supportedTimeInForce.Contains(request.TimeInForce.Value))
-                return new ArgumentError("Order time in force not supported");
+                return ArgumentError.Invalid(nameof(PlaceFuturesOrderRequest.TimeInForce), "Order time in force not supported");
 
             var quantityError = quantitySupport.Validate(request.Side, request.OrderType, request.Quantity);
             if (quantityError != null)

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/PlaceSpotOrderOptions.cs

@@ -34,10 +34,10 @@ namespace CryptoExchange.Net.SharedApis
                 throw new ArgumentException("OrderType can't be `Other`", nameof(request.OrderType));
 
             if (!supportedOrderTypes.Contains(request.OrderType))
-                return new ArgumentError("Order type not supported");
+                return ArgumentError.Invalid(nameof(PlaceSpotOrderRequest.OrderType), "Order type not supported");
 
             if (request.TimeInForce != null && !supportedTimeInForce.Contains(request.TimeInForce.Value))
-                return new ArgumentError("Order time in force not supported");
+                return ArgumentError.Invalid(nameof(PlaceSpotOrderRequest.TimeInForce), "Order time in force not supported");
 
             var quantityError = quantitySupport.Validate(request.Side, request.OrderType, request.Quantity);
             if (quantityError != null)

CryptoExchange.Net/SharedApis/Models/Options/Subscriptions/SubscribeKlineOptions.cs

@@ -60,7 +60,7 @@ namespace CryptoExchange.Net.SharedApis
         public override Error? ValidateRequest(string exchange, SubscribeKlineRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
         {
             if (!IsSupported(request.Interval))
-                return new ArgumentError("Interval not supported");
+                return ArgumentError.Invalid(nameof(SubscribeKlineRequest.Interval), "Interval not supported");
 
             return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
         }

CryptoExchange.Net/SharedApis/Models/Options/Subscriptions/SubscribeOrderBookOptions.cs

@@ -29,7 +29,7 @@ namespace CryptoExchange.Net.SharedApis
         public override Error? ValidateRequest(string exchange, SubscribeOrderBookRequest request, TradingMode? tradingMode, TradingMode[] supportedApiTypes)
         {
             if (request.Limit != null && !SupportedLimits.Contains(request.Limit.Value))
-                return new ArgumentError("Limit not supported");
+                return ArgumentError.Invalid(nameof(SubscribeOrderBookRequest.Limit), "Limit not supported");
 
             return base.ValidateRequest(exchange, request, tradingMode, supportedApiTypes);
         }

CryptoExchange.Net/SharedApis/Models/SharedQuantitySupport.cs

@@ -65,6 +65,9 @@ namespace CryptoExchange.Net.SharedApis
             if (supportedType == quantityType)
                 return true;
 
+            if (supportedType == SharedQuantityType.BaseAndQuoteAssetAndContracts)
+                return true;
+
             if (supportedType == SharedQuantityType.BaseAndQuoteAsset && (quantityType == SharedQuantityType.BaseAsset || quantityType == SharedQuantityType.QuoteAsset))
                 return true;
 
@@ -77,20 +80,20 @@ namespace CryptoExchange.Net.SharedApis
         public Error? Validate(SharedOrderSide side, SharedOrderType type, SharedQuantity? quantity)
         {
             var supportedType = GetSupportedQuantityType(side, type);
-            if (supportedType == SharedQuantityType.BaseAndQuoteAsset)
+            if (supportedType == SharedQuantityType.BaseAndQuoteAsset || supportedType == SharedQuantityType.BaseAndQuoteAssetAndContracts)
                 return null;
 
             if (supportedType == SharedQuantityType.BaseAndQuoteAsset && quantity != null && quantity.QuantityInBaseAsset == null && quantity.QuantityInQuoteAsset == null)
-                return new ArgumentError($"Quantity for {side}.{type} required in base or quote asset");
+                return ArgumentError.Invalid("Quantity", $"Quantity for {side}.{type} required in base or quote asset");
 
             if (supportedType == SharedQuantityType.QuoteAsset && quantity != null && quantity.QuantityInQuoteAsset == null)
-                return new ArgumentError($"Quantity for {side}.{type} required in quote asset");
+                return ArgumentError.Invalid("Quantity", $"Quantity for {side}.{type} required in quote asset");
 
             if (supportedType == SharedQuantityType.BaseAsset && quantity != null && quantity.QuantityInBaseAsset == null && quantity.QuantityInContracts == null)
-                return new ArgumentError($"Quantity for {side}.{type} required in base asset");
+                return ArgumentError.Invalid("Quantity", $"Quantity for {side}.{type} required in base asset");
 
             if (supportedType == SharedQuantityType.Contracts && quantity != null && quantity.QuantityInContracts == null)
-                return new ArgumentError($"Quantity for {side}.{type} required in contracts");
+                return ArgumentError.Invalid("Quantity", $"Quantity for {side}.{type} required in contracts");
 
             return null;
         }

CryptoExchange.Net/SharedApis/Models/SharedSymbolRequest.cs

@@ -1,14 +1,27 @@
-namespace CryptoExchange.Net.SharedApis
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Symbol request
     /// </summary>
     public record SharedSymbolRequest : SharedRequest
     {
+        /// <summary>
+        /// Trading mode
+        /// </summary>
+        public TradingMode TradingMode { get; }
         /// <summary>
         /// The symbol
         /// </summary>
-        public SharedSymbol Symbol { get; set; }
+        public SharedSymbol? Symbol { get; set; }
+        /// <summary>
+        /// Symbols
+        /// </summary>
+        public SharedSymbol[]? Symbols { get; set; }
 
         /// <summary>
         /// ctor
@@ -16,6 +29,22 @@
         public SharedSymbolRequest(SharedSymbol symbol, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
         {
             Symbol = symbol;
+            TradingMode = symbol.TradingMode;
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public SharedSymbolRequest(IEnumerable<SharedSymbol> symbols, ExchangeParameters? exchangeParameters = null) : base(exchangeParameters)
+        {
+            if (!symbols.Any())
+                throw new ArgumentException("Empty symbol list");
+
+            if (symbols.GroupBy(x => x.TradingMode).Count() > 1)
+                throw new ArgumentException("All symbols in the symbol list should have the same trading mode");
+
+            Symbols = symbols.ToArray();
+            TradingMode = Symbols.First().TradingMode;
         }
     }
 }

CryptoExchange.Net/SharedApis/Models/Socket/SubscribeBookTickerRequest.cs

@@ -1,4 +1,6 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Request to subscribe to book ticker updates
@@ -13,5 +15,22 @@
         public SubscribeBookTickerRequest(SharedSymbol symbol, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
         {
         }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        /// <param name="exchangeParameters">Exchange specific parameters</param>
+        public SubscribeBookTickerRequest(IEnumerable<SharedSymbol> symbols, ExchangeParameters? exchangeParameters = null) : base(symbols, exchangeParameters)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        public SubscribeBookTickerRequest(params SharedSymbol[] symbols) : base(symbols, null)
+        {
+        }
     }
 }

CryptoExchange.Net/SharedApis/Models/Socket/SubscribeKlineRequest.cs

@@ -1,4 +1,6 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Request to subscribe to kline/candlestick updates
@@ -20,5 +22,26 @@
         {
             Interval = interval;
         }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        /// <param name="interval">Kline interval</param>
+        /// <param name="exchangeParameters">Exchange specific parameters</param>
+        public SubscribeKlineRequest(IEnumerable<SharedSymbol> symbols, SharedKlineInterval interval, ExchangeParameters? exchangeParameters = null) : base(symbols, exchangeParameters)
+        {
+            Interval = interval;
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="interval">Kline interval</param>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        public SubscribeKlineRequest(SharedKlineInterval interval, params SharedSymbol[] symbols) : base(symbols, null)
+        {
+            Interval = interval;
+        }
     }
 }

CryptoExchange.Net/SharedApis/Models/Socket/SubscribeOrderBookRequest.cs

@@ -1,4 +1,6 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Request to subscribe to order book snapshot updates
@@ -20,5 +22,22 @@
         {
             Limit = limit;
         }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        /// <param name="exchangeParameters">Exchange specific parameters</param>
+        public SubscribeOrderBookRequest(IEnumerable<SharedSymbol> symbols, ExchangeParameters? exchangeParameters = null) : base(symbols, exchangeParameters)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        public SubscribeOrderBookRequest(params SharedSymbol[] symbols) : base(symbols, null)
+        {
+        }
     }
 }

CryptoExchange.Net/SharedApis/Models/Socket/SubscribeTickerRequest.cs

@@ -1,4 +1,7 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Collections;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Request to subscribe to ticker updates
@@ -13,5 +16,22 @@
         public SubscribeTickerRequest(SharedSymbol symbol, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
         {
         }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        /// <param name="exchangeParameters">Exchange specific parameters</param>
+        public SubscribeTickerRequest(IEnumerable<SharedSymbol> symbols, ExchangeParameters? exchangeParameters = null) : base(symbols, exchangeParameters)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        public SubscribeTickerRequest(params SharedSymbol[] symbols) : base(symbols, null)
+        {
+        }
     }
 }

CryptoExchange.Net/SharedApis/Models/Socket/SubscribeTradeRequest.cs

@@ -1,4 +1,6 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Request to subscribe to trade updates
@@ -13,5 +15,22 @@
         public SubscribeTradeRequest(SharedSymbol symbol, ExchangeParameters? exchangeParameters = null) : base(symbol, exchangeParameters)
         {
         }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        /// <param name="exchangeParameters">Exchange specific parameters</param>
+        public SubscribeTradeRequest(IEnumerable<SharedSymbol> symbols, ExchangeParameters? exchangeParameters = null) : base(symbols, exchangeParameters)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="symbols">The symbols to subscribe to</param>
+        public SubscribeTradeRequest(params SharedSymbol[] symbols) : base(symbols, null)
+        {
+        }
     }
 }

CryptoExchange.Net/SharedApis/ResponseModels/SharedFuturesSymbol.cs

@@ -30,5 +30,8 @@ namespace CryptoExchange.Net.SharedApis
         public SharedFuturesSymbol(TradingMode symbolType, string baseAsset, string quoteAsset, string symbol, bool trading) : base(baseAsset, quoteAsset, symbol, trading, symbolType)
         {
         }
+
+        /// <inheritdoc />
+        public override SharedSymbol SharedSymbol => new SharedSymbol(TradingMode, BaseAsset.ToUpperInvariant(), QuoteAsset.ToUpperInvariant(), DeliveryTime) { SymbolName = Name };
     }
 }

CryptoExchange.Net/SharedApis/ResponseModels/SharedPosition.cs

@@ -7,6 +7,10 @@ namespace CryptoExchange.Net.SharedApis
     /// </summary>
     public record SharedPosition : SharedSymbolModel
     {
+        /// <summary>
+        /// Position id
+        /// </summary>
+        public string? Id { get; set; }
         /// <summary>
         /// Current size of the position
         /// </summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedSpotSymbol.cs

@@ -69,5 +69,11 @@
             Name = symbol;
             Trading = trading;
         }
+
+        /// <summary>
+        /// The SharedSymbol of this symbol
+        /// </summary>
+        /// <returns></returns>
+        public virtual SharedSymbol SharedSymbol => new SharedSymbol(TradingMode, BaseAsset.ToUpperInvariant(), QuoteAsset.ToUpperInvariant()) { SymbolName = Name };
     }
 }

CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.RateLimiting;
 using Microsoft.Extensions.Logging;
@@ -252,6 +253,11 @@ namespace CryptoExchange.Net.Sockets
                         await (OnConnectRateLimited?.Invoke() ?? Task.CompletedTask).ConfigureAwait(false);
                         return new CallResult(new ServerRateLimitError(we.Message, we));
                     }
+
+                    if (_socket.HttpStatusCode == HttpStatusCode.Unauthorized)
+                    {
+                        return new CallResult(new ServerError(new ErrorInfo(ErrorType.Unauthorized, "Server returned status code `401` when `101` was expected")));
+                    }
 #else
                     // ClientWebSocket.HttpStatusCode is only available in .NET6+ https://learn.microsoft.com/en-us/dotnet/api/system.net.websockets.clientwebsocket.httpstatuscode?view=net-8.0
                     // Try to read 429 from the message instead

CryptoExchange.Net/Sockets/MessageMatcher.cs

@@ -0,0 +1,180 @@
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Sockets
+{
+    /// <summary>
+    /// Message link type
+    /// </summary>
+    public enum MessageLinkType
+    {
+        /// <summary>
+        /// Match when the listen id matches fully to the value
+        /// </summary>
+        Full,
+        /// <summary>
+        /// Match when the listen id starts with the value
+        /// </summary>
+        StartsWith
+    }
+
+    /// <summary>
+    /// Matches a message listen id to a specific listener
+    /// </summary>
+    public class MessageMatcher
+    {
+        /// <summary>
+        /// Linkers in this matcher
+        /// </summary>
+        public MessageHandlerLink[] HandlerLinks { get; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        private MessageMatcher(params MessageHandlerLink[] links)
+        {
+            HandlerLinks = links;
+        }
+
+        /// <summary>
+        /// Create message matcher
+        /// </summary>
+        public static MessageMatcher Create<T>(string value)
+        {
+            return new MessageMatcher(new MessageHandlerLink<T>(MessageLinkType.Full, value, (con, msg) => new CallResult<T>(default, msg.OriginalData, null)));
+        }
+
+        /// <summary>
+        /// Create message matcher
+        /// </summary>
+        public static MessageMatcher Create<T>(string value, Func<SocketConnection, DataEvent<T>, CallResult> handler)
+        {
+            return new MessageMatcher(new MessageHandlerLink<T>(MessageLinkType.Full, value, handler));
+        }
+
+        /// <summary>
+        /// Create message matcher
+        /// </summary>
+        public static MessageMatcher Create<T>(IEnumerable<string> values, Func<SocketConnection, DataEvent<T>, CallResult> handler)
+        {
+            return new MessageMatcher(values.Select(x => new MessageHandlerLink<T>(MessageLinkType.Full, x, handler)).ToArray());
+        }
+
+        /// <summary>
+        /// Create message matcher
+        /// </summary>
+        public static MessageMatcher Create<T>(MessageLinkType type, string value, Func<SocketConnection, DataEvent<T>, CallResult> handler)
+        {
+            return new MessageMatcher(new MessageHandlerLink<T>(type, value, handler));
+        }
+
+        /// <summary>
+        /// Create message matcher
+        /// </summary>
+        public static MessageMatcher Create(params MessageHandlerLink[] linkers)
+        {
+            return new MessageMatcher(linkers);
+        }
+
+        /// <summary>
+        /// Whether this matcher contains a specific link
+        /// </summary>
+        public bool ContainsCheck(MessageHandlerLink link) => HandlerLinks.Any(x => x.Type == link.Type && x.Value == link.Value);
+
+        /// <summary>
+        /// Get any handler links matching with the listen id
+        /// </summary>
+        public List<MessageHandlerLink> GetHandlerLinks(string listenId) => HandlerLinks.Where(x => x.Check(listenId)).ToList();
+
+        /// <inheritdoc />
+        public override string ToString() => string.Join(",", HandlerLinks.Select(x => x.ToString()));
+    }
+
+    /// <summary>
+    /// Message handler link
+    /// </summary>
+    public abstract class MessageHandlerLink
+    {
+        /// <summary>
+        /// Type of check
+        /// </summary>
+        public MessageLinkType Type { get; }
+        /// <summary>
+        /// String value of the check
+        /// </summary>
+        public string Value { get; }
+        /// <summary>
+        /// Deserialization type
+        /// </summary>
+        public abstract Type GetDeserializationType(IMessageAccessor accessor);
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public MessageHandlerLink(MessageLinkType type, string value)
+        {
+            Type = type;
+            Value = value;
+        }
+
+        /// <summary>
+        /// Whether this listen id matches this link
+        /// </summary>
+        public bool Check(string listenId)
+        {
+            if (Type == MessageLinkType.Full)
+                return Value.Equals(listenId, StringComparison.Ordinal);
+
+            return listenId.StartsWith(Value, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Message handler
+        /// </summary>
+        public abstract CallResult Handle(SocketConnection connection, DataEvent<object> message);
+
+        /// <inheritdoc />
+        public override string ToString() => $"{Type} match for \"{Value}\"";
+    }
+
+    /// <summary>
+    /// Message handler link
+    /// </summary>
+    public class MessageHandlerLink<TServer>: MessageHandlerLink
+    {
+        private Func<SocketConnection, DataEvent<TServer>, CallResult> _handler;
+
+        /// <inheritdoc />
+        public override Type GetDeserializationType(IMessageAccessor accessor) => typeof(TServer);
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public MessageHandlerLink(string value, Func<SocketConnection, DataEvent<TServer>, CallResult> handler)
+            : this(MessageLinkType.Full, value, handler)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public MessageHandlerLink(MessageLinkType type, string value, Func<SocketConnection, DataEvent<TServer>, CallResult> handler)
+            : base(type, value)
+        {
+            _handler = handler;
+        }
+
+
+        /// <inheritdoc />
+        public override CallResult Handle(SocketConnection connection, DataEvent<object> message)
+        {
+            return _handler(connection, message.As((TServer)message.Data));
+        }
+    }
+}

CryptoExchange.Net/Sockets/Query.cs

@@ -3,6 +3,7 @@ using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Sockets;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -28,6 +29,11 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public TimeSpan? RequestTimeout { get; set; }
 
+        /// <summary>
+        /// What should happen if the query times out
+        /// </summary>
+        public TimeoutBehavior TimeoutBehavior { get; set; } = TimeoutBehavior.Fail;
+
         /// <summary>
         /// The number of required responses. Can be more than 1 when for example subscribing multiple symbols streams in a single request,
         /// and each symbol receives it's own confirmation response
@@ -60,9 +66,9 @@ namespace CryptoExchange.Net.Sockets
         public AsyncResetEvent? ContinueAwaiter { get; set; }
 
         /// <summary>
-        /// Strings to match this query to a received message
+        /// Matcher for this query
         /// </summary>
-        public abstract HashSet<string> ListenerIdentifiers { get; set; }
+        public MessageMatcher MessageMatcher { get; set; } = null!;
 
         /// <summary>
         /// The query request object
@@ -84,13 +90,6 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public bool ExpectsResponse { get; set; } = true;
 
-        /// <summary>
-        /// Get the type the message should be deserialized to
-        /// </summary>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public abstract Type? GetMessageType(IMessageAccessor message);
-
         /// <summary>
         /// Wait event for response
         /// </summary>
@@ -161,23 +160,16 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Handle a response message
         /// </summary>
-        /// <param name="message"></param>
+        public abstract Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message, MessageHandlerLink check);
-        /// <param name="connection"></param>
-        /// <returns></returns>
-        public abstract Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message);
 
     }
 
     /// <summary>
     /// Query
     /// </summary>
-    /// <typeparam name="TServerResponse">The type returned from the server</typeparam>
     /// <typeparam name="THandlerResponse">The type to be returned to the caller</typeparam>
-    public abstract class Query<TServerResponse, THandlerResponse> : Query
+    public abstract class Query<THandlerResponse> : Query
     {
-        /// <inheritdoc />
-        public override Type? GetMessageType(IMessageAccessor message) => typeof(TServerResponse);
-
         /// <summary>
         /// The typed call result
         /// </summary>
@@ -194,25 +186,22 @@ namespace CryptoExchange.Net.Sockets
         }
 
         /// <inheritdoc />
-        public override async Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message)
+        public override async Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message, MessageHandlerLink check)
         {
-            var typedMessage = message.As((TServerResponse)message.Data);
+            if (!PreCheckMessage(connection, message))
-            if (!ValidateMessage(typedMessage))
                 return CallResult.SuccessResult;
 
             CurrentResponses++;
-            if (CurrentResponses == RequiredResponses)
+            if (CurrentResponses == RequiredResponses)            
-            {
-                Completed = true;
                 Response = message.Data;
-            }
 
             if (Result?.Success != false)
                 // If an error result is already set don't override that
-                Result = HandleMessage(connection, typedMessage);
+                Result = check.Handle(connection, message);
 
             if (CurrentResponses == RequiredResponses)
             {
+                Completed = true;
                 _event.Set();
                 if (ContinueAwaiter != null)
                     await ContinueAwaiter.WaitAsync().ConfigureAwait(false);
@@ -224,26 +213,20 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Validate if a message is actually processable by this query
         /// </summary>
-        /// <param name="message"></param>
+        public virtual bool PreCheckMessage(SocketConnection connection, DataEvent<object> message) => true;
-        /// <returns></returns>
-        public virtual bool ValidateMessage(DataEvent<TServerResponse> message) => true;
-
-        /// <summary>
-        /// Handle the query response
-        /// </summary>
-        /// <param name="connection"></param>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public abstract CallResult<THandlerResponse> HandleMessage(SocketConnection connection, DataEvent<TServerResponse> message);
 
         /// <inheritdoc />
         public override void Timeout()
         {
             if (Completed)
                 return;
-
+                        
             Completed = true;
-            Result = new CallResult<THandlerResponse>(new CancellationRequestedError(null, "Query timeout", null));
+            if (TimeoutBehavior == TimeoutBehavior.Fail)
+                Result = new CallResult<THandlerResponse>(new TimeoutError());
+            else
+                Result = new CallResult<THandlerResponse>(default, null, default);
+
             ContinueAwaiter?.Set();
             _event.Set();
         }
@@ -257,29 +240,4 @@ namespace CryptoExchange.Net.Sockets
             _event.Set();
         }
     }
-
-    /// <summary>
-    /// Query
-    /// </summary>
-    /// <typeparam name="TResponse">Response object type</typeparam>
-    public abstract class Query<TResponse> : Query<TResponse, TResponse>
-    {
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="request"></param>
-        /// <param name="authenticated"></param>
-        /// <param name="weight"></param>
-        protected Query(object request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
-        {
-        }
-
-        /// <summary>
-        /// Handle the query response
-        /// </summary>
-        /// <param name="connection"></param>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public override CallResult<TResponse> HandleMessage(SocketConnection connection, DataEvent<TResponse> message) => message.ToCallResult();
-    }
 }

CryptoExchange.Net/Sockets/SocketConnection.cs

@@ -11,8 +11,6 @@ using System.Diagnostics;
 using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Logging.Extensions;
 using System.Threading;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.Authentication;
 
 namespace CryptoExchange.Net.Sockets
 {
@@ -204,6 +202,18 @@ namespace CryptoExchange.Net.Sockets
             }
         }
 
+        /// <summary>
+        /// The number of current pending requests
+        /// </summary>
+        public int PendingRequests
+        {
+            get
+            {
+                lock (_listenersLock)
+                    return _listeners.OfType<Query>().Where(x => !x.Completed).Count();
+            }
+        }
+
         private bool _pausedActivity;
         private readonly object _listenersLock;
         private readonly List<IMessageProcessor> _listeners;
@@ -229,6 +239,11 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         private readonly IWebsocket _socket;
 
+        /// <summary>
+        /// Cache for deserialization, only caches for a single message
+        /// </summary>
+        private readonly Dictionary<Type, object> _deserializationCache = new Dictionary<Type, object>();
+
         /// <summary>
         /// New socket connection
         /// </summary>
@@ -446,9 +461,6 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Handle a message
         /// </summary>
-        /// <param name="data"></param>
-        /// <param name="type"></param>
-        /// <returns></returns>
         protected virtual async Task HandleStreamMessage(WebSocketMessageType type, ReadOnlyMemory<byte> data)
         {
             var sw = Stopwatch.StartNew();
@@ -475,9 +487,9 @@ namespace CryptoExchange.Net.Sockets
                     _logger.ReceivedData(SocketId, originalData);
                 }
 
-                if (!accessor.IsValid)
+                if (!accessor.IsValid && !ApiClient.ProcessUnparsableMessages)
                 {
-                    _logger.FailedToParse(SocketId, result.Error!.Message);
+                    _logger.FailedToParse(SocketId, result.Error!.Message ?? result.Error!.ErrorDescription!);
                     return;
                 }
 
@@ -485,7 +497,7 @@ namespace CryptoExchange.Net.Sockets
                 var listenId = ApiClient.GetListenerIdentifier(accessor);
                 if (listenId == null)
                 {
-                    originalData = outputOriginalData ? accessor.GetOriginalString() : "[OutputOriginalData is false]";
+                    originalData ??= "[OutputOriginalData is false]";
                     if (!ApiClient.UnhandledMessageExpected)
                         _logger.FailedToEvaluateMessage(SocketId, originalData);
 
@@ -493,18 +505,81 @@ namespace CryptoExchange.Net.Sockets
                     return;
                 }
 
-                // 4. Get the listeners interested in this message
+                bool processed = false;
-                List<IMessageProcessor> processors;
+                var totalUserTime = 0;
-                lock (_listenersLock)
-                    processors = _listeners.Where(s => s.ListenerIdentifiers.Contains(listenId)).ToList();
 
-                if (processors.Count == 0)
+                List<IMessageProcessor> localListeners;
+                lock(_listenersLock)
+                    localListeners = _listeners.ToList();
+
+                foreach(var processor in localListeners)
+                {
+                    foreach(var listener in processor.MessageMatcher.GetHandlerLinks(listenId))
+                    {
+                        processed = true;
+                        _logger.ProcessorMatched(SocketId, listener.ToString(), listenId);
+
+                        // 4. Determine the type to deserialize to for this processor
+                        var messageType = listener.GetDeserializationType(accessor);
+                        if (messageType == null)
+                        {
+                            _logger.ReceivedMessageNotRecognized(SocketId, processor.Id);
+                            continue;
+                        }
+
+                        if (processor is Subscription subscriptionProcessor && !subscriptionProcessor.Confirmed)
+                        {
+                            // If this message is for this listener then it is automatically confirmed, even if the subscription is not (yet) confirmed
+                            subscriptionProcessor.Confirmed = true;
+                            if (subscriptionProcessor.SubscriptionQuery?.TimeoutBehavior == TimeoutBehavior.Succeed)
+                                // If this subscription has a query waiting for a timeout (success if there is no error response)
+                                // then time it out now as the data is being received, so we assume it's successful
+                                subscriptionProcessor.SubscriptionQuery.Timeout();
+                        }
+
+                        // 5. Deserialize the message
+                        _deserializationCache.TryGetValue(messageType, out var deserialized);
+
+                        if (deserialized == null)
+                        {
+                            var desResult = processor.Deserialize(accessor, messageType);
+                            if (!desResult)
+                            {
+                                _logger.FailedToDeserializeMessage(SocketId, desResult.Error?.ToString(), desResult.Error?.Exception);
+                                continue;
+                            }
+
+                            deserialized = desResult.Data;
+                            _deserializationCache.Add(messageType, deserialized);
+                        }
+
+                        // 6. Pass the message to the handler
+                        try
+                        {
+                            var innerSw = Stopwatch.StartNew();
+                            await processor.Handle(this, new DataEvent<object>(deserialized, null, null, originalData, receiveTime, null), listener).ConfigureAwait(false);
+                            if (processor is Query query && query.RequiredResponses != 1)
+                                _logger.LogDebug($"[Sckt {SocketId}] [Req {query.Id}] responses: {query.CurrentResponses}/{query.RequiredResponses}");
+                            totalUserTime += (int)innerSw.ElapsedMilliseconds;
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.UserMessageProcessingFailed(SocketId, ex.Message, ex);
+                            if (processor is Subscription subscription)
+                                subscription.InvokeExceptionHandler(ex);
+                        }
+
+                    }
+                }
+
+                if (!processed)
                 {
                     if (!ApiClient.UnhandledMessageExpected)
                     {
                         List<string> listenerIds;
                         lock (_listenersLock)
-                            listenerIds = _listeners.SelectMany(l => l.ListenerIdentifiers).ToList();
+                            listenerIds = _listeners.Select(l => l.MessageMatcher.ToString()).ToList();
+
                         _logger.ReceivedMessageNotMatchedToAnyListener(SocketId, listenId, string.Join(",", listenerIds));
                         UnhandledMessage?.Invoke(accessor);
                     }
@@ -512,69 +587,11 @@ namespace CryptoExchange.Net.Sockets
                     return;
                 }
 
-                _logger.ProcessorMatched(SocketId, processors.Count, listenId);
-                var totalUserTime = 0;
-                Dictionary<Type, object>? desCache = null;
-                if (processors.Count > 1)
-                {
-                    // Only instantiate a cache if there are multiple processors
-                    desCache = new Dictionary<Type, object>();
-                }
-
-                foreach (var processor in processors)
-                {
-                    // 5. Determine the type to deserialize to for this processor
-                    var messageType = processor.GetMessageType(accessor);
-                    if (messageType == null)
-                    {
-                        _logger.ReceivedMessageNotRecognized(SocketId, processor.Id);
-                        continue;
-                    }
-
-                    if (processor is Subscription subscriptionProcessor && !subscriptionProcessor.Confirmed)
-                    {
-                        // If this message is for this listener then it is automatically confirmed, even if the subscription is not (yet) confirmed
-                        subscriptionProcessor.Confirmed = true;
-                        // This doesn't trigger a waiting subscribe query, should probably also somehow set the wait event for that
-                    }
-
-                    // 6. Deserialize the message
-                    object? deserialized = null;
-                    desCache?.TryGetValue(messageType, out deserialized);
-
-                    if (deserialized == null)
-                    {
-                        var desResult = processor.Deserialize(accessor, messageType);
-                        if (!desResult)
-                        {
-                            _logger.FailedToDeserializeMessage(SocketId, desResult.Error?.ToString(), desResult.Error?.Exception);
-                            continue;
-                        }
-                        deserialized = desResult.Data;
-                        desCache?.Add(messageType, deserialized);
-                    }
-
-                    // 7. Hand of the message to the subscription
-                    try
-                    {
-                        var innerSw = Stopwatch.StartNew();
-                        await processor.Handle(this, new DataEvent<object>(deserialized, null, null, originalData, receiveTime, null)).ConfigureAwait(false);
-                        if (processor is Query query && query.RequiredResponses != 1)
-                            _logger.LogDebug($"[Sckt {SocketId}] [Req {query.Id}] responses: {query.CurrentResponses}/{query.RequiredResponses}");
-                        totalUserTime += (int)innerSw.ElapsedMilliseconds;
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.UserMessageProcessingFailed(SocketId, ex.Message, ex);
-                        if (processor is Subscription subscription)
-                            subscription.InvokeExceptionHandler(ex);
-                    }
-                }
-
                 _logger.MessageProcessed(SocketId, sw.ElapsedMilliseconds, sw.ElapsedMilliseconds - totalUserTime);
             }
             finally
             {
+                _deserializationCache.Clear();
                 accessor.Clear();
             }
         }
@@ -654,7 +671,7 @@ namespace CryptoExchange.Net.Sockets
 
             bool anyDuplicateSubscription;
             lock (_listenersLock)
-                anyDuplicateSubscription = _listeners.OfType<Subscription>().Any(x => x != subscription && x.ListenerIdentifiers.All(l => subscription.ListenerIdentifiers.Contains(l)));
+                anyDuplicateSubscription = _listeners.OfType<Subscription>().Any(x => x != subscription && x.MessageMatcher.HandlerLinks.All(l => subscription.MessageMatcher.ContainsCheck(l)));
 
             bool shouldCloseConnection;
             lock (_listenersLock)
@@ -763,22 +780,21 @@ namespace CryptoExchange.Net.Sockets
         public virtual async Task<CallResult> SendAndWaitQueryAsync(Query query, AsyncResetEvent? continueEvent = null, CancellationToken ct = default)
         {
             await SendAndWaitIntAsync(query, continueEvent, ct).ConfigureAwait(false);
-            return query.Result ?? new CallResult(new ServerError("Timeout"));
+            return query.Result ?? new CallResult(new TimeoutError());
         }
 
         /// <summary>
         /// Send a query request and wait for an answer
         /// </summary>
         /// <typeparam name="THandlerResponse">Expected result type</typeparam>
-        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
         /// <param name="query">Query to send</param>
         /// <param name="continueEvent">Wait event for when the socket message handler can continue</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns></returns>
-        public virtual async Task<CallResult<THandlerResponse>> SendAndWaitQueryAsync<TServerResponse, THandlerResponse>(Query<TServerResponse, THandlerResponse> query, AsyncResetEvent? continueEvent = null, CancellationToken ct = default)
+        public virtual async Task<CallResult<THandlerResponse>> SendAndWaitQueryAsync<THandlerResponse>(Query<THandlerResponse> query, AsyncResetEvent? continueEvent = null, CancellationToken ct = default)
         {
             await SendAndWaitIntAsync(query, continueEvent, ct).ConfigureAwait(false);
-            return query.TypedResult ?? new CallResult<THandlerResponse>(new ServerError("Timeout"));
+            return query.TypedResult ?? new CallResult<THandlerResponse>(new TimeoutError());
         }
 
         private async Task SendAndWaitIntAsync(Query query, AsyncResetEvent? continueEvent, CancellationToken ct = default)
@@ -863,7 +879,7 @@ namespace CryptoExchange.Net.Sockets
         {
             if (ApiClient.MessageSendSizeLimit != null && data.Length > ApiClient.MessageSendSizeLimit.Value)
             {
-                var info = $"Message to send exceeds the max server message size ({ApiClient.MessageSendSizeLimit.Value} bytes). Split the request into batches to keep below this limit";
+                var info = $"Message to send exceeds the max server message size ({data.Length} vs {ApiClient.MessageSendSizeLimit.Value} bytes). Split the request into batches to keep below this limit";
                 _logger.LogWarning("[Sckt {SocketId}] [Req {RequestId}] {Info}", SocketId, requestId, info);
                 return new CallResult(new InvalidOperationError(info));
             }
@@ -898,7 +914,7 @@ namespace CryptoExchange.Net.Sockets
         {
             if (ApiClient.MessageSendSizeLimit != null && data.Length > ApiClient.MessageSendSizeLimit.Value)
             {
-                var info = $"Message to send exceeds the max server message size ({ApiClient.MessageSendSizeLimit.Value} bytes). Split the request into batches to keep below this limit";
+                var info = $"Message to send exceeds the max server message size ({data.Length} vs {ApiClient.MessageSendSizeLimit.Value} bytes). Split the request into batches to keep below this limit";
                 _logger.LogWarning("[Sckt {SocketId}] [Req {RequestId}] {Info}", SocketId, requestId, info);
                 return new CallResult(new InvalidOperationError(info));
             }
@@ -995,7 +1011,7 @@ namespace CryptoExchange.Net.Sockets
                         return result;
                     }
 
-                    var subQuery = subscription.GetSubQuery(this);
+                    var subQuery = subscription.CreateSubscriptionQuery(this);
                     if (subQuery == null)
                     {
                         subscription.IsResubscribing = false;
@@ -1030,7 +1046,7 @@ namespace CryptoExchange.Net.Sockets
 
         internal async Task UnsubscribeAsync(Subscription subscription)
         {
-            var unsubscribeRequest = subscription.GetUnsubQuery();
+            var unsubscribeRequest = subscription.CreateUnsubscriptionQuery(this);
             if (unsubscribeRequest == null)
                 return;
 
@@ -1043,7 +1059,7 @@ namespace CryptoExchange.Net.Sockets
             if (!_socket.IsOpen)
                 return new CallResult(new WebError("Socket is not connected"));
 
-            var subQuery = subscription.GetSubQuery(this);
+            var subQuery = subscription.CreateSubscriptionQuery(this);
             if (subQuery == null)
                 return CallResult.SuccessResult;
 

CryptoExchange.Net/Sockets/Subscription.cs

@@ -4,6 +4,7 @@ using CryptoExchange.Net.Objects.Sockets;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -60,9 +61,9 @@ namespace CryptoExchange.Net.Sockets
         public bool Authenticated { get; }
 
         /// <summary>
-        /// Strings to match this subscription to a received message
+        /// Matcher for this subscription
         /// </summary>
-        public abstract HashSet<string> ListenerIdentifiers { get; set; }
+        public MessageMatcher MessageMatcher { get; set; } = null!;
 
         /// <summary>
         /// Cancellation token registration
@@ -74,24 +75,24 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public event Action<Exception>? Exception;
 
-        /// <summary>
-        /// Get the deserialization type for this message
-        /// </summary>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public abstract Type? GetMessageType(IMessageAccessor message);
-
         /// <summary>
         /// Subscription topic
         /// </summary>
         public string? Topic { get; set; }
 
+        /// <summary>
+        /// The subscribe query for this subscription
+        /// </summary>
+        public Query? SubscriptionQuery { get; private set; }
+
+        /// <summary>
+        /// The unsubscribe query for this subscription
+        /// </summary>
+        public Query? UnsubscriptionQuery { get; private set; }
+
         /// <summary>
         /// ctor
         /// </summary>
-        /// <param name="logger"></param>
-        /// <param name="authenticated"></param>
-        /// <param name="userSubscription"></param>
         public Subscription(ILogger logger, bool authenticated, bool userSubscription = true)
         {
             _logger = logger;
@@ -100,11 +101,21 @@ namespace CryptoExchange.Net.Sockets
             Id = ExchangeHelpers.NextId();
         }
 
+        /// <summary>
+        /// Create a new subscription query
+        /// </summary>
+        public Query? CreateSubscriptionQuery(SocketConnection connection)
+        {
+            var query = GetSubQuery(connection);
+            SubscriptionQuery = query;
+            return query;
+        }
+
         /// <summary>
         /// Get the subscribe query to send when subscribing
         /// </summary>
         /// <returns></returns>
-        public abstract Query? GetSubQuery(SocketConnection connection);
+        protected abstract Query? GetSubQuery(SocketConnection connection);
 
         /// <summary>
         /// Handle a subscription query response
@@ -118,11 +129,21 @@ namespace CryptoExchange.Net.Sockets
         /// <param name="message"></param>
         public virtual void HandleUnsubQueryResponse(object message) { }
 
+        /// <summary>
+        /// Create a new unsubscription query
+        /// </summary>
+        public Query? CreateUnsubscriptionQuery(SocketConnection connection)
+        {
+            var query = GetUnsubQuery(connection);
+            UnsubscriptionQuery = query;
+            return query;
+        }
+
         /// <summary>
         /// Get the unsubscribe query to send when unsubscribing
         /// </summary>
         /// <returns></returns>
-        public abstract Query? GetUnsubQuery();
+        protected abstract Query? GetUnsubQuery(SocketConnection connection);
 
         /// <inheritdoc />
         public virtual CallResult<object> Deserialize(IMessageAccessor message, Type type) => message.Deserialize(type);
@@ -130,14 +151,11 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Handle an update message
         /// </summary>
-        /// <param name="connection"></param>
+        public Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message, MessageHandlerLink matcher)
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message)
         {
             ConnectionInvocations++;
             TotalInvocations++;
-            return Task.FromResult(DoHandleMessage(connection, message));
+            return Task.FromResult(matcher.Handle(connection, message));
         }
 
         /// <summary>
@@ -154,14 +172,6 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public virtual void DoHandleReset() { }
 
-        /// <summary>
-        /// Handle the update message
-        /// </summary>
-        /// <param name="connection"></param>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public abstract CallResult DoHandleMessage(SocketConnection connection, DataEvent<object> message);
-
         /// <summary>
         /// Invoke the exception event
         /// </summary>
@@ -177,12 +187,12 @@ namespace CryptoExchange.Net.Sockets
         /// <param name="Id">The id of the subscription</param>
         /// <param name="Confirmed">True when the subscription query is handled (either accepted or rejected)</param>
         /// <param name="Invocations">Number of times this subscription got a message</param>
-        /// <param name="Identifiers">Identifiers the subscription is listening to</param>
+        /// <param name="ListenMatcher">Matcher for this subscription</param>
         public record SubscriptionState(
             int Id,
             bool Confirmed,
             int Invocations,
-            HashSet<string> Identifiers
+            MessageMatcher ListenMatcher
         );
 
         /// <summary>
@@ -191,7 +201,7 @@ namespace CryptoExchange.Net.Sockets
         /// <returns></returns>
         public SubscriptionState GetState()
         {
-            return new SubscriptionState(Id, Confirmed, TotalInvocations, ListenerIdentifiers);
+            return new SubscriptionState(Id, Confirmed, TotalInvocations, MessageMatcher);
         }
     }
 

CryptoExchange.Net/Sockets/SystemSubscription.cs

@@ -22,37 +22,9 @@ namespace CryptoExchange.Net.Sockets
         }
 
         /// <inheritdoc />
-        public override Query? GetSubQuery(SocketConnection connection) => null;
+        protected override Query? GetSubQuery(SocketConnection connection) => null;
 
         /// <inheritdoc />
-        public override Query? GetUnsubQuery() => null;
+        protected override Query? GetUnsubQuery(SocketConnection connection) => null;
-    }
-
-    /// <inheritdoc />
-    public abstract class SystemSubscription<T> : SystemSubscription
-    {
-        /// <inheritdoc />
-        public override Type GetMessageType(IMessageAccessor message) => typeof(T);
-
-        /// <inheritdoc />
-        public override CallResult DoHandleMessage(SocketConnection connection, DataEvent<object> message)
-            => HandleMessage(connection, message.As((T)message.Data));
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="logger"></param>
-        /// <param name="authenticated"></param>
-        protected SystemSubscription(ILogger logger, bool authenticated) : base(logger, authenticated)
-        {
-        }
-
-        /// <summary>
-        /// Handle an update message
-        /// </summary>
-        /// <param name="connection"></param>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public abstract CallResult HandleMessage(SocketConnection connection, DataEvent<T> message);
     }
 }

CryptoExchange.Net/Testing/Comparers/SystemTextJsonComparer.cs

@@ -386,7 +386,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                 var stringValue = jsonValue.GetString();
                 if (objectValue is decimal dec)
                 {
-                    if (decimal.Parse(stringValue!, CultureInfo.InvariantCulture) != dec)
+                    if (ExchangeHelpers.ParseDecimal(stringValue!) != dec)
                         throw new Exception($"{method}: {property} not equal: {stringValue} vs {dec}");
                 }
                 else if (objectValue is DateTime time)

CryptoExchange.Net/Testing/TestHelpers.cs

@@ -128,23 +128,27 @@ namespace CryptoExchange.Net.Testing
             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>();
+            var requestDefinition = new RestRequestConfiguration(
+                    new RequestDefinition(path, method)
+                    {
+                        Authenticated = true
+                    },
+                    host,
+                    uriParams ?? new Dictionary<string, object>(),
+                    bodyParams ?? new Dictionary<string, object>(),
+                    new Dictionary<string, string>(),
+                    client.ArraySerialization,
+                    client.ParameterPositions[method],
+                    client.RequestBodyFormat
+                    );
 
             authProvider.TimeProvider = new TestAuthTimeProvider(time ?? new DateTime(2024, 01, 01, 0, 0, 0, DateTimeKind.Utc));
-            authProvider.AuthenticateRequest(
+            authProvider.ProcessRequest(
-                client, 
+                client,
-                new Uri(host.AppendPath(path)), 
+                requestDefinition
-                method,
-                ref uriParams,
-                ref bodyParams,
-                ref headers,
-                true,
-                client.ArraySerialization, 
-                client.ParameterPositions[method],
-                client.RequestBodyFormat
                 );
 
-            var signature = getSignature(uriParams, bodyParams, headers);
+            var signature = getSignature(requestDefinition.QueryParameters, requestDefinition.BodyParameters, requestDefinition.Headers);
 
             if (!string.Equals(signature, expectedSignature, compareCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase))
                 throw new Exception($"Signatures do not match. Expected: {expectedSignature}, Actual: {signature}");

CryptoExchange.Net/Trackers/Klines/KlineTracker.cs

@@ -176,18 +176,32 @@ namespace CryptoExchange.Net.Trackers.Klines
             Status = SyncStatus.Syncing;
             _logger.KlineTrackerStarting(SymbolName);
 
-            var startResult = await DoStartAsync().ConfigureAwait(false);
+            var subResult = await _socketClient.SubscribeToKlineUpdatesAsync(new SubscribeKlineRequest(Symbol, _interval),
-            if (!startResult)
+                 update =>
+                 {
+                     AddOrUpdate(update.Data);
+                 }).ConfigureAwait(false);
+
+            if (!subResult)
             {
-                _logger.KlineTrackerStartFailed(SymbolName, startResult.Error!.Message, startResult.Error.Exception);
+                _logger.KlineTrackerStartFailed(SymbolName, subResult.Error!.Message ?? subResult.Error!.ErrorDescription!, subResult.Error.Exception);
                 Status = SyncStatus.Disconnected;
-                return new CallResult(startResult.Error!);
+                return subResult;
             }
 
-            _updateSubscription = startResult.Data;
+            _updateSubscription = subResult.Data;
             _updateSubscription.ConnectionLost += HandleConnectionLost;
             _updateSubscription.ConnectionClosed += HandleConnectionClosed;
             _updateSubscription.ConnectionRestored += HandleConnectionRestored;
+
+            var startResult = await DoStartAsync().ConfigureAwait(false);
+            if (!startResult)
+            {
+                _ = subResult.Data.CloseAsync();
+                Status = SyncStatus.Disconnected;                
+                return new CallResult(startResult.Error!);
+            }
+
             Status = SyncStatus.Synced;
             _logger.KlineTrackerStarted(SymbolName);
             return CallResult.SuccessResult;
@@ -208,22 +222,10 @@ namespace CryptoExchange.Net.Trackers.Klines
         /// The start procedure needed for kline syncing, generally subscribing to an update stream and requesting the snapshot
         /// </summary>
         /// <returns></returns>
-        protected virtual async Task<CallResult<UpdateSubscription>> DoStartAsync()
+        protected virtual async Task<CallResult> DoStartAsync()
         {
-            var subResult = await _socketClient.SubscribeToKlineUpdatesAsync(new SubscribeKlineRequest(Symbol, _interval),
-                 update =>
-                 {
-                     AddOrUpdate(update.Data);
-                 }).ConfigureAwait(false);
-
-            if (!subResult)
-            {
-                Status = SyncStatus.Disconnected;
-                return subResult;
-            }
-
             if (!_startWithSnapshot)
-                return subResult;
+                return CallResult.SuccessResult;
 
             var startTime = Period == null ? (DateTime?)null : DateTime.UtcNow.Add(-Period.Value);
             if (_restClient.GetKlinesOptions.MaxAge != null && DateTime.UtcNow.Add(-_restClient.GetKlinesOptions.MaxAge.Value) > startTime)
@@ -236,11 +238,7 @@ namespace CryptoExchange.Net.Trackers.Klines
             await foreach (var result in ExchangeHelpers.ExecutePages(_restClient.GetKlinesAsync, request).ConfigureAwait(false))
             {
                 if (!result)
-                {
+                    return result;                
-                    _ = subResult.Data.CloseAsync();
-                    Status = SyncStatus.Disconnected;
-                    return subResult.AsError<UpdateSubscription>(result.Error!);
-                }
 
                 if (Limit != null && data.Count > Limit)
                     break;
@@ -249,7 +247,7 @@ namespace CryptoExchange.Net.Trackers.Klines
             }
 
             SetInitialData(data);
-            return subResult;
+            return CallResult.SuccessResult;
         }
 
         /// <summary>

CryptoExchange.Net/Trackers/Trades/TradeTracker.cs

@@ -199,10 +199,15 @@ namespace CryptoExchange.Net.Trackers.Trades
             _startWithSnapshot = startWithSnapshot;
             Status = SyncStatus.Syncing;
             _logger.TradeTrackerStarting(SymbolName);
-            var subResult = await DoStartAsync().ConfigureAwait(false);
+            var subResult = await _socketClient.SubscribeToTradeUpdatesAsync(new SubscribeTradeRequest(Symbol),
+                 update =>
+                 {
+                     AddData(update.Data);
+                 }).ConfigureAwait(false);
+
             if (!subResult)
             {
-                _logger.TradeTrackerStartFailed(SymbolName, subResult.Error!.Message, subResult.Error.Exception);
+                _logger.TradeTrackerStartFailed(SymbolName, subResult.Error!.Message ?? subResult.Error!.ErrorDescription!, subResult.Error.Exception);
                 Status = SyncStatus.Disconnected;
                 return subResult;
             }
@@ -211,6 +216,15 @@ namespace CryptoExchange.Net.Trackers.Trades
             _updateSubscription.ConnectionLost += HandleConnectionLost;
             _updateSubscription.ConnectionClosed += HandleConnectionClosed;
             _updateSubscription.ConnectionRestored += HandleConnectionRestored;
+
+            var result = await DoStartAsync().ConfigureAwait(false);
+            if (!result)
+            {
+                _ = subResult.Data.CloseAsync();
+                Status = SyncStatus.Disconnected;
+                return result;
+            }
+
             SetSyncStatus();
             _logger.TradeTrackerStarted(SymbolName);
             return CallResult.SuccessResult;
@@ -231,22 +245,10 @@ namespace CryptoExchange.Net.Trackers.Trades
         /// The start procedure needed for trade syncing, generally subscribing to an update stream and requesting the snapshot
         /// </summary>
         /// <returns></returns>
-        protected virtual async Task<CallResult<UpdateSubscription>> DoStartAsync()
+        protected virtual async Task<CallResult> DoStartAsync()
         {
-            var subResult = await _socketClient.SubscribeToTradeUpdatesAsync(new SubscribeTradeRequest(Symbol),
-                 update =>
-                 {
-                     AddData(update.Data);
-                 }).ConfigureAwait(false);
-
-            if (!subResult)
-            {
-                Status = SyncStatus.Disconnected;
-                return subResult;
-            }
-
             if (!_startWithSnapshot)
-                return subResult;
+                return CallResult.SuccessResult;
 
             if (_historyRestClient != null)
             {
@@ -256,12 +258,8 @@ namespace CryptoExchange.Net.Trackers.Trades
                 await foreach(var result in ExchangeHelpers.ExecutePages(_historyRestClient.GetTradeHistoryAsync, request).ConfigureAwait(false))
                 {
                     if (!result)
-                    {
+                        return result;
-                        _ = subResult.Data.CloseAsync();
+                    
-                        Status = SyncStatus.Disconnected;
-                        return subResult.AsError<UpdateSubscription>(result.Error!);
-                    }
-
                     if (Limit != null && data.Count > Limit)
                         break;
 
@@ -279,15 +277,13 @@ namespace CryptoExchange.Net.Trackers.Trades
                 var snapshot = await _recentRestClient.GetRecentTradesAsync(new GetRecentTradesRequest(Symbol, limit)).ConfigureAwait(false);
                 if (!snapshot)
                 {
-                    _ = subResult.Data.CloseAsync();
+                    return snapshot;
-                    Status = SyncStatus.Disconnected;
-                    return subResult.AsError<UpdateSubscription>(snapshot.Error!);
                 }
 
                 SetInitialData(snapshot.Data);
             }
 
-            return subResult;
+            return CallResult.SuccessResult;
         }
 
         /// <summary>

Examples/BlazorClient/App.razor

@@ -1,4 +1,4 @@
-<Router AppAssembly="@typeof(Program).Assembly" PreferExactMatches="@true">
+<Router AppAssembly="@typeof(Program).Assembly">
     <Found Context="routeData">
         <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
     </Found>

Examples/BlazorClient/BlazorClient.csproj

@@ -5,28 +5,29 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Binance.Net" Version="11.1.0" />
+    <PackageReference Include="Binance.Net" Version="11.3.0" />
-    <PackageReference Include="Bitfinex.Net" Version="9.1.0" />
+    <PackageReference Include="Bitfinex.Net" Version="9.3.0" />
-    <PackageReference Include="BitMart.Net" Version="2.1.0" />
+    <PackageReference Include="BitMart.Net" Version="2.4.1" />
-    <PackageReference Include="Bybit.Net" Version="5.1.0" />
+    <PackageReference Include="Bybit.Net" Version="5.4.0" />
-    <PackageReference Include="CoinEx.Net" Version="9.1.0" />
+    <PackageReference Include="CoinEx.Net" Version="9.3.0" />
-    <PackageReference Include="CryptoCom.Net" Version="2.1.0" />
+    <PackageReference Include="CoinW.Net" Version="1.0.1" />
-    <PackageReference Include="DeepCoin.Net" Version="2.1.0" />
+    <PackageReference Include="CryptoCom.Net" Version="2.4.0" />
-    <PackageReference Include="GateIo.Net" Version="2.1.0" />
+    <PackageReference Include="DeepCoin.Net" Version="2.3.0" />
-    <PackageReference Include="HyperLiquid.Net" Version="2.1.1" />
+    <PackageReference Include="GateIo.Net" Version="2.4.0" />
-    <PackageReference Include="JK.BingX.Net" Version="2.1.0" />
+    <PackageReference Include="HyperLiquid.Net" Version="2.4.0" />
-    <PackageReference Include="JK.Bitget.Net" Version="2.1.0" />
+    <PackageReference Include="JK.BingX.Net" Version="2.3.0" />
-    <PackageReference Include="JK.Mexc.Net" Version="3.1.0" />
+    <PackageReference Include="JK.Bitget.Net" Version="2.3.0" />
-    <PackageReference Include="JK.OKX.Net" Version="3.1.0" />
+    <PackageReference Include="JK.Mexc.Net" Version="3.3.0" />
-    <PackageReference Include="JKorf.BitMEX.Net" Version="2.1.0" />
+    <PackageReference Include="JK.OKX.Net" Version="3.3.1" />
-    <PackageReference Include="JKorf.Coinbase.Net" Version="2.1.0" />
+    <PackageReference Include="JKorf.BitMEX.Net" Version="2.3.0" />
-    <PackageReference Include="JKorf.HTX.Net" Version="7.1.0" />
+    <PackageReference Include="JKorf.Coinbase.Net" Version="2.3.0" />
-    <PackageReference Include="KrakenExchange.Net" Version="6.1.0" />
+    <PackageReference Include="JKorf.HTX.Net" Version="7.3.0" />
-    <PackageReference Include="Kucoin.Net" Version="7.1.0" />
+    <PackageReference Include="KrakenExchange.Net" Version="6.3.1" />
+    <PackageReference Include="Kucoin.Net" Version="7.3.0" />
     <PackageReference Include="Serilog.AspNetCore" Version="9.0.0" />
-    <PackageReference Include="Toobit.Net" Version="1.0.1" />
+    <PackageReference Include="Toobit.Net" Version="1.2.1" />
-    <PackageReference Include="WhiteBit.Net" Version="2.1.0" />
+    <PackageReference Include="WhiteBit.Net" Version="2.4.0" />
-    <PackageReference Include="XT.Net" Version="2.1.0" />
+    <PackageReference Include="XT.Net" Version="2.3.1" />
   </ItemGroup>
 
 </Project>

Examples/BlazorClient/Pages/Index.razor

@@ -8,6 +8,7 @@
 @inject IBybitRestClient bybitClient
 @inject ICoinbaseRestClient coinbaseClient
 @inject ICoinExRestClient coinexClient
+@inject ICoinWRestClient coinWClient
 @inject ICryptoComRestClient cryptocomClient
 @inject IDeepCoinRestClient deepCoinClient
 @inject IGateIoRestClient gateioClient
@@ -41,6 +42,7 @@
         var bybitTask = bybitClient.V5Api.ExchangeData.GetSpotTickersAsync("BTCUSDT");
         var coinbaseTask = coinbaseClient.AdvancedTradeApi.ExchangeData.GetSymbolAsync("BTC-USDT");
         var coinexTask = coinexClient.SpotApiV2.ExchangeData.GetTickersAsync(["BTCUSDT"]);
+        var coinWTask = coinWClient.SpotApi.ExchangeData.GetTickersAsync();
         var cryptocomTask = cryptocomClient.ExchangeApi.ExchangeData.GetTickersAsync("BTC_USDT");
         var deepCoinTask = deepCoinClient.ExchangeApi.ExchangeData.GetTickersAsync(DeepCoin.Net.Enums.SymbolType.Spot);
         var gateioTask = gateioClient.SpotApi.ExchangeData.GetTickersAsync("BTC_USDT");
@@ -83,6 +85,9 @@
         if (coinexTask.Result.Success)
             _prices.Add("CoinEx", coinexTask.Result.Data.Single().LastPrice);
 
+        if (coinWTask.Result.Success)
+            _prices.Add("CoinW", coinWTask.Result.Data.Single(x => x.Symbol == "BTC_USDT").LastPrice);
+
         if (cryptocomTask.Result.Success)
             _prices.Add("CryptoCom", cryptocomTask.Result.Data.First().LastPrice ?? 0);
 

Examples/BlazorClient/Pages/LiveData.razor

@@ -8,6 +8,7 @@
 @inject IBybitSocketClient bybitSocketClient
 @inject ICoinbaseSocketClient coinbaseSocketClient
 @inject ICoinExSocketClient coinExSocketClient
+@inject ICoinWSocketClient coinWSocketClient
 @inject ICryptoComSocketClient cryptocomSocketClient
 @inject IDeepCoinSocketClient deepCoinSocketClient
 @inject IGateIoSocketClient gateioSocketClient
@@ -49,6 +50,7 @@
             bitmexSocketClient.ExchangeApi.SubscribeToSymbolUpdatesAsync("ETH_XBT", data => UpdateData("BitMEX", data.Data.LastPrice ?? 0)),
             bybitSocketClient.V5SpotApi.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Bybit", data.Data.LastPrice)),
             coinExSocketClient.SpotApiV2.SubscribeToTickerUpdatesAsync(["ETHBTC"], data => UpdateData("CoinEx", data.Data.First().LastPrice)),
+            coinWSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH_BTC", data => UpdateData("CoinW", data.Data.LastPrice)),
             coinbaseSocketClient.AdvancedTradeApi.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("Coinbase", data.Data.LastPrice ?? 0)),
             cryptocomSocketClient.ExchangeApi.SubscribeToTickerUpdatesAsync("ETH_BTC", data => UpdateData("CryptoCom", data.Data.LastPrice ?? 0)),
             deepCoinSocketClient.ExchangeApi.SubscribeToSymbolUpdatesAsync("ETH-BTC", data => UpdateData("DeepCoin", data.Data.LastPrice ?? 0)),

Examples/BlazorClient/Pages/OrderBooks.razor

@@ -9,6 +9,7 @@
 @using BitMEX.Net.Interfaces;
 @using Bybit.Net.Interfaces
 @using CoinEx.Net.Interfaces
+@using CoinW.Net.Interfaces
 @using Coinbase.Net.Interfaces
 @using CryptoExchange.Net.Authentication
 @using CryptoExchange.Net.Interfaces
@@ -34,6 +35,7 @@
 @inject IBybitOrderBookFactory bybitFactory
 @inject ICoinbaseOrderBookFactory coinbaseFactory
 @inject ICoinExOrderBookFactory coinExFactory
+@inject ICoinWOrderBookFactory coinWFactory
 @inject ICryptoComOrderBookFactory cryptocomFactory
 @inject IDeepCoinOrderBookFactory deepCoinFactory
 @inject IGateIoOrderBookFactory gateioFactory
@@ -88,6 +90,7 @@
                 { "Bybit", bybitFactory.Create("ETHBTC", Bybit.Net.Enums.Category.Spot) },
                 { "Coinbase", coinbaseFactory.Create("ETH-BTC", null) },
                 { "CoinEx", coinExFactory.CreateSpot("ETHBTC") },
+                { "CoinW", coinWFactory.CreateSpot("ETH_BTC") },
                 { "CryptoCom", cryptocomFactory.Create("ETH_BTC") },
                 { "GateIo", gateioFactory.CreateSpot("ETH_BTC") },
                 // DeepCoin does not support the ETH/BTC pair
@@ -115,7 +118,7 @@
 
     public void Dispose()
     {
-        _timer.Stop();
+        _timer?.Stop();
         _timer.Dispose();
         foreach (var book in _books.Where(b => b.Value.Status != CryptoExchange.Net.Objects.OrderBookStatus.Disconnected))
             // It's not necessary to wait for this

Examples/BlazorClient/Pages/Trackers.razor

@@ -9,6 +9,7 @@
 @using BitMart.Net.Interfaces;
 @using Bybit.Net.Interfaces
 @using CoinEx.Net.Interfaces
+@using CoinW.Net.Interfaces
 @using Coinbase.Net.Interfaces
 @using CryptoExchange.Net.Interfaces
 @using CryptoCom.Net.Interfaces
@@ -35,6 +36,7 @@
 @inject IBybitTrackerFactory bybitFactory
 @inject ICoinbaseTrackerFactory coinbaseFactory
 @inject ICoinExTrackerFactory coinExFactory
+@inject ICoinWTrackerFactory coinWFactory
 @inject ICryptoComTrackerFactory cryptocomFactory
 @inject IDeepCoinTrackerFactory deepCoinFactory
 @inject IGateIoTrackerFactory gateioFactory
@@ -82,6 +84,7 @@
                 { bybitFactory.CreateTradeTracker(usdtSymbol, period: TimeSpan.FromMinutes(5)) },
                 { coinbaseFactory.CreateTradeTracker(usdtSymbol, period: TimeSpan.FromMinutes(5)) },
                 { coinExFactory.CreateTradeTracker(usdtSymbol, period: TimeSpan.FromMinutes(5)) },
+                { coinWFactory.CreateTradeTracker(usdtSymbol, period: TimeSpan.FromMinutes(5)) },
                 { cryptocomFactory.CreateTradeTracker(usdtSymbol, period: TimeSpan.FromMinutes(5)) },
                 { deepCoinFactory.CreateTradeTracker(usdtSymbol, period: TimeSpan.FromMinutes(5)) },
                 { gateioFactory.CreateTradeTracker(usdtSymbol, period: TimeSpan.FromMinutes(5)) },
@@ -121,8 +124,8 @@
 
     public void Dispose()
     {
-        _timer.Stop();
+        _timer?.Stop();
-        _timer.Dispose();
+        _timer?.Dispose();
         foreach (var tracker in _trackers.Where(b => b.Status != CryptoExchange.Net.Objects.SyncStatus.Disconnected))
             // It's not necessary to wait for this
             _ = tracker.StopAsync();

Examples/BlazorClient/Startup.cs

@@ -41,6 +41,7 @@ namespace BlazorClient
             services.AddBybit();
             services.AddCoinbase();
             services.AddCoinEx();
+            services.AddCoinW();
             services.AddCryptoCom();
             services.AddDeepCoin();
             services.AddGateIo();

Examples/BlazorClient/_Imports.razor

@@ -17,6 +17,7 @@
 @using Bybit.Net.Interfaces.Clients;
 @using Coinbase.Net.Interfaces.Clients;
 @using CoinEx.Net.Interfaces.Clients;
+@using CoinW.Net.Interfaces.Clients;
 @using CryptoCom.Net.Interfaces.Clients;
 @using DeepCoin.Net.Interfaces.Clients;
 @using GateIo.Net.Interfaces.Clients;

README.md

@@ -21,6 +21,7 @@ Full list of all libraries part of the CryptoExchange.Net ecosystem. Consider us
 |![Bybit](https://raw.githubusercontent.com/JKorf/Bybit.Net/refs/heads/main/ByBit.Net/Icon/icon.png)|Bybit|CEX|[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)|[Link](https://partner.bybit.com/b/jkorf)|-|
 |![Coinbase](https://raw.githubusercontent.com/JKorf/Coinbase.Net/refs/heads/main/Coinbase.Net/Icon/icon.png)|Coinbase|CEX|[JKorf/Coinbase.Net](https://github.com/JKorf/Coinbase.Net)|[![Nuget version](https://img.shields.io/nuget/v/JKorf.Coinbase.Net.svg?style=flat-square)](https://www.nuget.org/packages/JKorf.Coinbase.Net)|[Link](https://advanced.coinbase.com/join/T6H54H8)|-|
 |![CoinEx](https://raw.githubusercontent.com/JKorf/CoinEx.Net/refs/heads/master/CoinEx.Net/Icon/icon.png)|CoinEx|CEX|[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)|[Link](https://www.coinex.com/register?rc=rbtnp)|20%|
+|![CoinW](https://raw.githubusercontent.com/JKorf/CoinW.Net/refs/heads/main/CoinW.Net/Icon/icon.png)|CoinW|CEX|[JKorf/CoinW.Net](https://github.com/JKorf/CoinW.Net)|[![Nuget version](https://img.shields.io/nuget/v/CoinW.net.svg?style=flat-square)](https://www.nuget.org/packages/CoinW.Net)|[Link](https://www.coinw.com/register?rc=rbtnp)|-|
 |![CoinGecko](https://raw.githubusercontent.com/JKorf/CoinGecko.Net/refs/heads/main/CoinGecko.Net/Icon/icon.png)|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)|-|-|
 |![Crypto.com](https://raw.githubusercontent.com/JKorf/CryptoCom.Net/refs/heads/main/CryptoCom.Net/Icon/icon.png)|Crypto.com|CEX|[JKorf/CryptoCom.Net](https://github.com/JKorf/CryptoCom.Net)|[![Nuget version](https://img.shields.io/nuget/v/CryptoCom.net.svg?style=flat-square)](https://www.nuget.org/packages/CryptoCom.Net)|[Link](https://crypto.com/exch/26ge92xbkn)|-|
 |![DeepCoin](https://raw.githubusercontent.com/JKorf/DeepCoin.Net/refs/heads/main/DeepCoin.Net/Icon/icon.png)|DeepCoin|CEX|[JKorf/DeepCoin.Net](https://github.com/JKorf/DeepCoin.Net)|[![Nuget version](https://img.shields.io/nuget/v/DeepCoin.net.svg?style=flat-square)](https://www.nuget.org/packages/DeepCoin.Net)|[Link](https://s.deepcoin.com/jddhfca)|-|
@@ -58,6 +59,37 @@ 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 9.6.0 - 25 Aug 2025
+    * Added support for parsing REST response even though status indicates error
+    * Added better support for subscriptions without subscribe confirmation
+    * Added check in websocket for receiving 401 unauthorized http response status when 101 was expected
+    * Removed obsolete attribute on Error.Code property, updated the description
+
+* Version 9.5.0 - 19 Aug 2025
+    * Added better error handling support
+    * Added ErrorDescription, ErrorType and IsTransient to Error object
+    * Added ErrorCode in favor of Code
+    * Updated some error messages
+    * Refactored RestApiClient request authentication and AuthenticationProvider to prevent duplicate query string / body serialization
+    * Fixed IOrderBookSocketClient Shared interface not getting registered in DI
+    * Fixed response type in websocket queries not interested in the response
+    * Fixed timing issue in query response processing
+
+* Version 9.4.0 - 04 Aug 2025
+    * Updated Shared symbol requests/subscriptions to allow multiple symbols in one call if supported
+
+* Version 9.3.1 - 29 Jul 2025
+    * Added BaseAndQuoteAssetAndContracts value to SharedQuantityType enum
+    * Added Id property to SharedPosition model
+
+* Version 9.3.0 - 23 Jul 2025
+    * Updated websocket message to listener matching logic to be more flexible
+    * Updated decimal parser to support "NaN" and "-Infinity" strings, added check for negative overflow value, improved performance in most cases
+
+* Version 9.2.1 - 16 Jul 2025
+    * Added setting for whether or not to process unparsable websocket messages
+    * Fixed issue causing duplicate subscriptions and data in the TradeTracker and KlineTracker when websocket connection was reconnected
+
 * Version 9.2.0 - 14 Jul 2025
     * Added support for sending byte data on websocket
     * Added support for handling both string and byte data with different IMessageAccessor types