Updated to version 10.0.1

Fixed CryptoExchange.Net reference
Updated to version 10.0.0
2026-08-11 16:32:57 +00:00 · 2025-12-16 11:54:37 +01:00 · 2025-12-16 11:54:08 +01:00 · 2025-12-16 11:49:45 +01:00 · 2025-12-16 11:31:42 +01:00 · 2025-12-16 11:27:49 +01:00
302 changed files with 11252 additions and 3191 deletions
@@ -16,7 +16,7 @@ jobs:
    - name: Setup .NET
      uses: actions/setup-dotnet@v1
      with:
-        dotnet-version: 9.0.x
+        dotnet-version: 10.0.x
    - name: Restore dependencies
      run: dotnet restore
    - name: Build
@@ -0,0 +1,530 @@
+using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Objects;
+using ProtoBuf;
+using ProtoBuf.Meta;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.InteropServices.ComTypes;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Converters.Protobuf
+{
+    /// <summary>
+    /// System.Text.Json message accessor
+    /// </summary>
+#if NET5_0_OR_GREATER
+    public abstract class ProtobufMessageAccessor<
+        [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+        DynamicallyAccessedMemberTypes.NonPublicConstructors |
+        DynamicallyAccessedMemberTypes.PublicFields |
+        DynamicallyAccessedMemberTypes.NonPublicFields |
+        DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+        DynamicallyAccessedMemberTypes.PublicProperties |
+        DynamicallyAccessedMemberTypes.NonPublicProperties |
+#endif
+        DynamicallyAccessedMemberTypes.PublicNestedTypes |
+        DynamicallyAccessedMemberTypes.NonPublicMethods |
+        DynamicallyAccessedMemberTypes.PublicMethods
+        )]
+    TIntermediateType> : IMessageAccessor
+#else
+    public abstract class ProtobufMessageAccessor<TIntermediateType> : IMessageAccessor
+#endif
+    {
+        /// <summary>
+        /// The intermediate deserialization object
+        /// </summary>
+        protected TIntermediateType? _intermediateType;
+        /// <summary>
+        /// Runtime type model
+        /// </summary>
+        protected RuntimeTypeModel _model;
+
+        /// <inheritdoc />
+        public bool IsValid { get; set; }
+
+        /// <inheritdoc />
+        public abstract bool OriginalDataAvailable { get; }
+
+        /// <inheritdoc />
+        public object? Underlying => _intermediateType;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ProtobufMessageAccessor(RuntimeTypeModel model)
+        {
+            _model = model;
+        }
+
+        /// <inheritdoc />
+        public NodeType? GetNodeType()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        public NodeType? GetNodeType(MessagePath path)
+        {
+            if (_intermediateType == null)
+                throw new InvalidOperationException("Data not read");
+
+            object? value = _intermediateType;
+            foreach (var step in path)
+            {
+                if (value == null)
+                    break;
+
+                if (step.Type == 0)
+                {
+                    // array index
+                }
+                else if (step.Type == 1)
+                {
+                    // property value
+#pragma warning disable IL2075 // Type is already annotated
+                    value = value.GetType().GetProperty(step.Property!)?.GetValue(value);
+#pragma warning restore
+                }
+                else
+                {
+                    // property name
+                }
+            }
+
+            if (value == null)
+                return null;
+
+            var valueType = value.GetType();
+            if (valueType.IsArray)
+                return NodeType.Array;
+
+            if (IsSimple(valueType))
+                return NodeType.Value;
+
+            return NodeType.Object;
+        }
+
+        private static bool IsSimple(Type type)
+        {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                // nullable type, check if the nested type is simple.
+                return IsSimple(type.GetGenericArguments()[0]);
+            }
+            return type.IsPrimitive
+              || type.IsEnum
+              || type == typeof(string)
+              || type == typeof(decimal);
+        }
+
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2075:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public T? GetValue<T>(MessagePath path)
+        {
+            if (_intermediateType == null)
+                throw new InvalidOperationException("Data not read");
+
+            object? value = _intermediateType;
+            foreach(var step in path)
+            {
+                if (value == null)
+                    break;
+
+                if (step.Type == 0)
+                {
+                    // array index
+                }
+                else if (step.Type == 1)
+                {
+                    // property value
+#pragma warning disable IL2075 // Type is already annotated
+                    value = value.GetType().GetProperty(step.Property!)?.GetValue(value);
+#pragma warning restore
+                }
+                else
+                {
+                    // property name
+                }
+            }
+
+            return (T?)value;
+        }
+
+        /// <inheritdoc />
+        public T?[]? GetValues<T>(MessagePath path)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        public abstract string GetOriginalString();
+
+        /// <inheritdoc />
+        public abstract void Clear();
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public abstract CallResult<object> Deserialize(
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+#endif
+        Type type, MessagePath? path = null);
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public abstract CallResult<T> Deserialize<
+#if NET5_0_OR_GREATER
+        [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+#endif
+        T>(MessagePath? path = null);
+    }
+
+    /// <summary>
+    /// System.Text.Json stream message accessor
+    /// </summary>
+    public class ProtobufStreamMessageAccessor<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+#endif
+    TIntermediate> : ProtobufMessageAccessor<TIntermediate>, IStreamMessageAccessor
+    {
+        private Stream? _stream;
+
+        /// <inheritdoc />
+        public override bool OriginalDataAvailable => _stream?.CanSeek == true;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ProtobufStreamMessageAccessor(RuntimeTypeModel model) : base(model)
+        {
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public override CallResult<object> Deserialize(
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+#endif
+        Type type, MessagePath? path = null)
+        {
+            try
+            {
+                var result = _model.Deserialize(type, _stream);
+                return new CallResult<object>(result);
+            }
+            catch (Exception ex)
+            {
+                return new CallResult<object>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
+            }
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public override CallResult<T> Deserialize<            
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+#endif
+        T>(MessagePath? path = null)
+        {
+            try
+            {
+                var result = _model.Deserialize<T>(_stream);
+                return new CallResult<T>(result);
+            }
+            catch(Exception ex)
+            {
+                return new CallResult<T>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
+            }
+        }
+
+        /// <inheritdoc />
+        public Task<CallResult> Read(Stream stream, bool bufferStream)
+        {
+            if (bufferStream && stream is not MemoryStream)
+            {
+                // We need to be buffer the stream, and it's not currently a seekable stream, so copy it to a new memory stream
+                _stream = new MemoryStream();
+                stream.CopyTo(_stream);
+                _stream.Position = 0;
+            }
+            else if (bufferStream)
+            {
+                // We need to buffer the stream, and the current stream is seekable, store as is
+                _stream = stream;
+            }
+            else
+            {
+                // We don't need to buffer the stream, so don't bother keeping the reference
+            }
+
+            try
+            {
+                _intermediateType = _model.Deserialize<TIntermediate>(_stream);
+                IsValid = true;
+                return Task.FromResult(CallResult.SuccessResult);
+            }
+            catch (Exception ex)
+            {
+                // Not a json message
+                IsValid = false;
+                return Task.FromResult(new CallResult(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex)));
+            }
+        }
+
+        /// <inheritdoc />
+        public override string GetOriginalString()
+        {
+            if (_stream is null)
+                throw new NullReferenceException("Stream not initialized");
+
+            _stream.Position = 0;
+            using var textReader = new StreamReader(_stream, Encoding.UTF8, false, 1024, true);
+            return textReader.ReadToEnd();
+        }
+
+        /// <inheritdoc />
+        public override void Clear()
+        {
+            _stream?.Dispose();
+            _stream = null;
+            _intermediateType = default;
+        }
+
+    }
+
+    /// <summary>
+    /// Protobuf byte message accessor
+    /// </summary>
+    public class ProtobufByteMessageAccessor<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+#endif
+    TIntermediate> : ProtobufMessageAccessor<TIntermediate>, IByteMessageAccessor
+    {
+        private ReadOnlyMemory<byte> _bytes;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ProtobufByteMessageAccessor(RuntimeTypeModel model) : base(model)
+        {
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public override CallResult<object> Deserialize(
+
+#if NET5_0_OR_GREATER
+            [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+            [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+#endif
+        Type type, MessagePath? path = null)
+        {
+            try
+            {
+                using var stream = new MemoryStream(_bytes.ToArray());
+                stream.Position = 0;
+                var result = _model.Deserialize(type, stream);
+                return new CallResult<object>(result);
+            }
+            catch (Exception ex)
+            {
+                return new CallResult<object>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
+            }
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+#if NET5_0_OR_GREATER
+        public override CallResult<T> Deserialize<
+            [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+            [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+        T>(MessagePath? path = null)
+#else
+        public override CallResult<T> Deserialize<T>(MessagePath? path = null)
+#endif
+        {
+            try
+            {
+                var result = _model.Deserialize<T>(_bytes);
+                return new CallResult<T>(result);
+            }
+            catch (Exception ex)
+            {
+                return new CallResult<T>(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
+            }
+        }
+
+        /// <inheritdoc />
+        public CallResult Read(ReadOnlyMemory<byte> data)
+        {
+            _bytes = data;
+
+            try
+            {
+                _intermediateType = _model.Deserialize<TIntermediate>(data);
+                IsValid = true;
+                return CallResult.SuccessResult;
+            }
+            catch (Exception ex)
+            {
+                // Not a json message
+                IsValid = false;
+                return new CallResult(new DeserializeError("Protobuf deserialization failed: " + ex.Message, ex));
+            }
+        }
+
+        /// <inheritdoc />
+        public override string GetOriginalString() =>
+            // NetStandard 2.0 doesn't support GetString from a ReadonlySpan<byte>, so use ToArray there instead
+#if NETSTANDARD2_0
+            Encoding.UTF8.GetString(_bytes.ToArray());
+#else
+            Encoding.UTF8.GetString(_bytes.Span);
+#endif
+
+        /// <inheritdoc />
+        public override bool OriginalDataAvailable => true;
+
+        /// <inheritdoc />
+        public override void Clear()
+        {
+            _bytes = null;
+            _intermediateType = default;
+        }
+    }
+}
@@ -0,0 +1,53 @@
+using CryptoExchange.Net.Interfaces;
+using ProtoBuf.Meta;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Reflection;
+
+namespace CryptoExchange.Net.Converters.Protobuf
+{
+    /// <inheritdoc />
+    public class ProtobufMessageSerializer : IByteMessageSerializer
+    {
+        private RuntimeTypeModel _model;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ProtobufMessageSerializer(RuntimeTypeModel model)
+        {
+            _model = model;
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+#if NET5_0_OR_GREATER
+        public byte[] Serialize<
+            [DynamicallyAccessedMembers(
+#if NET8_0_OR_GREATER
+            DynamicallyAccessedMemberTypes.NonPublicConstructors |
+            DynamicallyAccessedMemberTypes.PublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicFields |
+            DynamicallyAccessedMemberTypes.NonPublicNestedTypes |
+            DynamicallyAccessedMemberTypes.PublicProperties |
+            DynamicallyAccessedMemberTypes.NonPublicProperties |
+            DynamicallyAccessedMemberTypes.PublicConstructors |
+#endif
+            DynamicallyAccessedMemberTypes.PublicNestedTypes |
+            DynamicallyAccessedMemberTypes.NonPublicMethods |
+            DynamicallyAccessedMemberTypes.PublicMethods
+            )]
+        T>(T message)
+#else
+        public byte[] Serialize<T>(T message)
+#endif
+        {
+            using var memoryStream = new MemoryStream();
+            _model.Serialize(memoryStream, message);
+            return memoryStream.ToArray();
+        }
+    }
+}
@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0;net10.0</TargetFrameworks>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PackageId>CryptoExchange.Net.Protobuf</PackageId>
+    <Authors>JKorf</Authors>
+    <Description>Protobuf support for CryptoExchange.Net</Description>
+    <PackageVersion>10.0.1</PackageVersion>
+    <AssemblyVersion>10.0.1</AssemblyVersion>
+    <FileVersion>10.0.1</FileVersion>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <PackageTags>CryptoExchange;CryptoExchange.Net</PackageTags>
+    <RepositoryType>git</RepositoryType>
+    <RepositoryUrl>https://github.com/JKorf/CryptoExchange.Net.git</RepositoryUrl>
+    <PackageProjectUrl>https://github.com/JKorf/CryptoExchange.Net/tree/master/CryptoExchange.Net.Protobuf</PackageProjectUrl>
+    <NeutralLanguage>en</NeutralLanguage>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageIcon>icon.png</PackageIcon>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <PackageReleaseNotes>https://github.com/JKorf/CryptoExchange.Net?tab=readme-ov-file#release-notes</PackageReleaseNotes>
+    <Nullable>enable</Nullable>
+    <LangVersion>12.0</LangVersion>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+  </PropertyGroup>
+  <ItemGroup>
+    <None Include="..\CryptoExchange.Net\Icon\icon.png" Pack="true" PackagePath="\" />
+    <None Include="README.md" Pack="true" PackagePath="\" />
+  </ItemGroup>
+  <PropertyGroup Label="AOT" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
+    <IsAotCompatible>true</IsAotCompatible>
+  </PropertyGroup>
+  <PropertyGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DocumentationFile>CryptoExchange.Net.Protobuf.xml</DocumentationFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="CryptoExchange.Net" Version="10.0.0" />
+    <PackageReference Include="protobuf-net" Version="3.2.56" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,128 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>CryptoExchange.Net.Protobuf</name>
+    </assembly>
+    <members>
+        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1">
+            <summary>
+            System.Text.Json message accessor
+            </summary>
+        </member>
+        <member name="F:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1._intermediateType">
+            <summary>
+            The intermediate deserialization object
+            </summary>
+        </member>
+        <member name="F:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1._model">
+            <summary>
+            Runtime type model
+            </summary>
+        </member>
+        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.IsValid">
+            <inheritdoc />
+        </member>
+        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.OriginalDataAvailable">
+            <inheritdoc />
+        </member>
+        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Underlying">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
+            <summary>
+            ctor
+            </summary>
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetNodeType">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetNodeType(CryptoExchange.Net.Converters.MessageParsing.MessagePath)">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetValue``1(CryptoExchange.Net.Converters.MessageParsing.MessagePath)">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetValues``1(CryptoExchange.Net.Converters.MessageParsing.MessagePath)">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.GetOriginalString">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Clear">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Deserialize(System.Type,System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageAccessor`1.Deserialize``1(System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
+            <inheritdoc />
+        </member>
+        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1">
+            <summary>
+            System.Text.Json stream message accessor
+            </summary>
+        </member>
+        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.OriginalDataAvailable">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
+            <summary>
+            ctor
+            </summary>
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Deserialize(System.Type,System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Deserialize``1(System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Read(System.IO.Stream,System.Boolean)">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.GetOriginalString">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufStreamMessageAccessor`1.Clear">
+            <inheritdoc />
+        </member>
+        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1">
+            <summary>
+            Protobuf byte message accessor
+            </summary>
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
+            <summary>
+            ctor
+            </summary>
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Deserialize(System.Type,System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Deserialize``1(System.Nullable{CryptoExchange.Net.Converters.MessageParsing.MessagePath})">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Read(System.ReadOnlyMemory{System.Byte})">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.GetOriginalString">
+            <inheritdoc />
+        </member>
+        <member name="P:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.OriginalDataAvailable">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufByteMessageAccessor`1.Clear">
+            <inheritdoc />
+        </member>
+        <member name="T:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageSerializer">
+            <inheritdoc />
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageSerializer.#ctor(ProtoBuf.Meta.RuntimeTypeModel)">
+            <summary>
+            ctor
+            </summary>
+        </member>
+        <member name="M:CryptoExchange.Net.Converters.Protobuf.ProtobufMessageSerializer.Serialize``1(``0)">
+            <inheritdoc />
+        </member>
+    </members>
+</doc>
@@ -0,0 +1,52 @@
+# ![.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/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 10.0.1 - 16 Dec 2025
+    * Updated CryptoExchange.Net version to 10.0.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 10.0.0 - 16 Dec 2025
+    * Updated CryptoExchange.Net version to 10.0.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.13.0 - 10 Nov 2025
+    * Updated CryptoExchange.Net version to 9.13.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.12.0 - 03 Nov 2025
+    * Updated CryptoExchange.Net version to 9.12.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.11.1 - 30 Oct 2025
+    * Updated CryptoExchange.Net version to 9.11.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.11.0 - 30 Oct 2025
+    * Updated CryptoExchange.Net version to 9.11.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.10.0 - 15 Oct 2025
+    * Updated CryptoExchange.Net version to 9.10.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.9.0 - 06 Oct 2025
+    * Updated CryptoExchange.Net version to 9.9.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.8.0 - 30 Sep 2025
+    * Updated CryptoExchange.Net version to 9.8.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.7.0 - 01 Sep 2025
+    * Updated CryptoExchange.Net version to 9.7.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* 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
@@ -4,7 +4,6 @@ using NUnit.Framework.Legacy;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;

 namespace CryptoExchange.Net.UnitTests
@@ -1,11 +1,5 @@
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.UnitTests.TestImplementations;
-using Microsoft.Extensions.Logging;
-using NUnit.Framework;
+using NUnit.Framework;
 using NUnit.Framework.Legacy;
-using System;
-using System.Collections.Generic;

 namespace CryptoExchange.Net.UnitTests
 {
@@ -1,12 +1,11 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using NUnit.Framework;
 using NUnit.Framework.Legacy;
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Net;
 using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;

 namespace CryptoExchange.Net.UnitTests
 {
@@ -16,9 +15,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 +35,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 +70,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 +83,11 @@ namespace CryptoExchange.Net.UnitTests
        [Test]
        public void TestCallResultErrorAsError()
        {
-            var result = new CallResult<TestObjectResult>(new ServerError("TestError"));
-            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+            var result = new CallResult<TestObjectResult>(new ServerError("TestError", ErrorInfo.Unknown));
+            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 +96,11 @@ namespace CryptoExchange.Net.UnitTests
        [Test]
        public void TestWebCallResultErrorAsError()
        {
-            var result = new WebCallResult<TestObjectResult>(new ServerError("TestError"));
-            var asResult = result.AsError<TestObject2>(new ServerError("TestError2"));
+            var result = new WebCallResult<TestObjectResult>(new ServerError("TestError", ErrorInfo.Unknown));
+            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);
@@ -112,7 +111,8 @@ namespace CryptoExchange.Net.UnitTests
        {
            var result = new WebCallResult<TestObjectResult>(
                System.Net.HttpStatusCode.OK,
-                new KeyValuePair<string, string[]>[0],
+                HttpVersion.Version11,
+                new HttpResponseMessage().Headers,
                TimeSpan.FromSeconds(1),
                null,
                "{}",
@@ -120,14 +120,14 @@ namespace CryptoExchange.Net.UnitTests
                "https://test.com/api",
                null,
                HttpMethod.Get,
-                new KeyValuePair<string, string[]>[0],
+                new HttpRequestMessage().Headers,
                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");
@@ -142,7 +142,8 @@ namespace CryptoExchange.Net.UnitTests
        {
            var result = new WebCallResult<TestObjectResult>(
                System.Net.HttpStatusCode.OK,
-                new KeyValuePair<string, string[]>[0],
+                HttpVersion.Version11,
+                new HttpResponseMessage().Headers,
                TimeSpan.FromSeconds(1),
                null,
                "{}",
@@ -150,7 +151,7 @@ namespace CryptoExchange.Net.UnitTests
                "https://test.com/api",
                null,
                HttpMethod.Get,
-                new KeyValuePair<string, string[]>[0],
+                new HttpRequestMessage().Headers,
                ResultDataSource.Server,
                new TestObjectResult(),
                null);
@@ -1,15 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
    <IsPackable>false</IsPackable>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0"></PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1"></PackageReference>
    <PackageReference Include="Moq" Version="4.20.72" />
-    <PackageReference Include="NUnit" Version="4.2.2"></PackageReference>
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0"></PackageReference>
+    <PackageReference Include="NUnit" Version="4.4.0"></PackageReference>
+    <PackageReference Include="NUnit3TestAdapter" Version="6.0.0"></PackageReference>
  </ItemGroup>

  <ItemGroup>
@@ -1,7 +1,5 @@
 using CryptoExchange.Net.Objects;
 using NUnit.Framework;
-using NUnit.Framework.Legacy;
-using System.Diagnostics;
 using System.Globalization;

 namespace CryptoExchange.Net.UnitTests
@@ -32,6 +30,7 @@ namespace CryptoExchange.Net.UnitTests
        [TestCase(0.1, 1, 0.0001, RoundingType.Closest, 0.532, 0.532)]
        [TestCase(0.1, 1, 0.0001, RoundingType.Down, 0.5516592, 0.5516)]
        [TestCase(0.1, 1, 0.0001, RoundingType.Closest, 0.5516592, 0.5517)]
+        [TestCase(0, 1, 0.000000001, RoundingType.Closest, 0.0000097232, 0.000009723)]
        public void AdjustValueStepTests(decimal min, decimal max, decimal? step, RoundingType roundingType, decimal input, decimal expected)
        {
            var result = ExchangeHelpers.AdjustValueStep(min, max, step, roundingType, input);
@@ -1,15 +1,8 @@
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.UnitTests.TestImplementations;
-using Microsoft.Extensions.Logging;
 using NUnit.Framework;
-using NUnit.Framework.Legacy;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;

 namespace CryptoExchange.Net.UnitTests
 {
@@ -9,7 +9,6 @@ using System.Threading.Tasks;
 using System.Threading;
 using NUnit.Framework.Legacy;
 using CryptoExchange.Net.RateLimiting;
-using System.Net;
 using CryptoExchange.Net.RateLimiting.Guards;
 using CryptoExchange.Net.RateLimiting.Filters;
 using CryptoExchange.Net.RateLimiting.Interfaces;
@@ -80,8 +79,6 @@ namespace CryptoExchange.Net.UnitTests
            ClassicAssert.IsFalse(result.Success);
            Assert.That(result.Error != null);
            Assert.That(result.Error is ServerError);
-            Assert.That(result.Error.Message.Contains("Invalid request"));
-            Assert.That(result.Error.Message.Contains("123"));
        }

        [TestCase]
@@ -98,7 +95,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");
        }

@@ -184,7 +181,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)
        {
@@ -1,231 +1,234 @@
-using System;
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading;
-using System.Threading.Tasks;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using CryptoExchange.Net.UnitTests.TestImplementations;
-using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
-using Microsoft.Extensions.Logging;
-using Moq;
-using NUnit.Framework;
-using NUnit.Framework.Legacy;
+//using CryptoExchange.Net.Objects;
+//using CryptoExchange.Net.Objects.Sockets;
+//using CryptoExchange.Net.Sockets;
+//using CryptoExchange.Net.Testing.Implementations;
+//using CryptoExchange.Net.UnitTests.TestImplementations;
+//using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
+//using Microsoft.Extensions.Logging;
+//using Moq;
+//using NUnit.Framework;
+//using NUnit.Framework.Legacy;
+//using System;
+//using System.Collections.Generic;
+//using System.Net.Sockets;
+//using System.Text.Json;
+//using System.Threading;
+//using System.Threading.Tasks;

-namespace CryptoExchange.Net.UnitTests
-{
-    [TestFixture]
-    public class SocketClientTests
-    {
-        [TestCase]
-        public void SettingOptions_Should_ResultInOptionsSet()
-        {
-            //arrange
-            //act
-            var client = new TestSocketClient(options =>
-            {
-                options.SubOptions.ApiCredentials = new Authentication.ApiCredentials("1", "2");
-                options.SubOptions.MaxSocketConnections = 1;
-            });
+//namespace CryptoExchange.Net.UnitTests
+//{
+//    [TestFixture]
+//    public class SocketClientTests
+//    {
+//        [TestCase]
+//        public void SettingOptions_Should_ResultInOptionsSet()
+//        {
+//            //arrange
+//            //act
+//            var client = new TestSocketClient(options =>
+//            {
+//                options.SubOptions.ApiCredentials = new Authentication.ApiCredentials("1", "2");
+//                options.SubOptions.MaxSocketConnections = 1;
+//            });

-            //assert
-            ClassicAssert.NotNull(client.SubClient.ApiOptions.ApiCredentials);
-            Assert.That(1 == client.SubClient.ApiOptions.MaxSocketConnections);
-        }
+//            //assert
+//            ClassicAssert.NotNull(client.SubClient.ApiOptions.ApiCredentials);
+//            Assert.That(1 == client.SubClient.ApiOptions.MaxSocketConnections);
+//        }

-        [TestCase(true)]
-        [TestCase(false)]
-        public void ConnectSocket_Should_ReturnConnectionResult(bool canConnect)
-        {
-            //arrange
-            var client = new TestSocketClient();
-            var socket = client.CreateSocket();
-            socket.CanConnect = canConnect;
+//        [TestCase(true)]
+//        [TestCase(false)]
+//        public void ConnectSocket_Should_ReturnConnectionResult(bool canConnect)
+//        {
+//            //arrange
+//            var client = new TestSocketClient();
+//            var socket = client.CreateSocket();
+//            socket.CanConnect = canConnect;

-            //act
-            var connectResult = client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, null));
+//            //act
+//            var connectResult = client.SubClient.ConnectSocketSub(
+//                new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));

-            //assert
-            Assert.That(connectResult.Success == canConnect);
-        }
+//            //assert
+//            Assert.That(connectResult.Success == canConnect);
+//        }

-        [TestCase]
-        public void SocketMessages_Should_BeProcessedInDataHandlers()
-        {
-            // arrange
-            var client = new TestSocketClient(options => {
-                options.ReconnectInterval = TimeSpan.Zero;
-            });
-            var socket = client.CreateSocket();
-            socket.CanConnect = true;
-            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
-            var rstEvent = new ManualResetEvent(false);
-            Dictionary<string, string> result = null;
+//        [TestCase]
+//        public void SocketMessages_Should_BeProcessedInDataHandlers()
+//        {
+//            // arrange
+//            var client = new TestSocketClient(options => {
+//                options.ReconnectInterval = TimeSpan.Zero;
+//            });
+//            var socket = client.CreateSocket();
+//            socket.CanConnect = true;
+//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
+//            var rstEvent = new ManualResetEvent(false);
+//            Dictionary<string, string> result = null;

-            client.SubClient.ConnectSocketSub(sub);
+//            client.SubClient.ConnectSocketSub(sub);

-            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
-            {
-                result = messageEvent.Data;
-                rstEvent.Set();
-            });
-            sub.AddSubscription(subObj);
+//            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
+//            {
+//                result = messageEvent.Data;
+//                rstEvent.Set();
+//            });
+//            sub.AddSubscription(subObj);

-            // act
-            socket.InvokeMessage("{\"property\": \"123\", \"action\": \"update\", \"topic\": \"topic\"}");
-            rstEvent.WaitOne(1000);
+//            // act
+//            socket.InvokeMessage("{\"property\": \"123\", \"action\": \"update\", \"topic\": \"topic\"}");
+//            rstEvent.WaitOne(1000);

-            // assert
-            Assert.That(result["property"] == "123");
-        }
+//            // assert
+//            Assert.That(result["property"] == "123");
+//        }

-        [TestCase(false)]
-        [TestCase(true)]
-        public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
-        {
-            // arrange
-            var client = new TestSocketClient(options =>
-            {
-                options.ReconnectInterval = TimeSpan.Zero;
-                options.SubOptions.OutputOriginalData = enabled;
-            });
-            var socket = client.CreateSocket();
-            socket.CanConnect = true;
-            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
-            var rstEvent = new ManualResetEvent(false);
-            string original = null;
+//        [TestCase(false)]
+//        [TestCase(true)]
+//        public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
+//        {
+//            // arrange
+//            var client = new TestSocketClient(options =>
+//            {
+//                options.ReconnectInterval = TimeSpan.Zero;
+//                options.SubOptions.OutputOriginalData = enabled;
+//            });
+//            var socket = client.CreateSocket();
+//            socket.CanConnect = true;
+//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
+//            var rstEvent = new ManualResetEvent(false);
+//            string original = null;

-            client.SubClient.ConnectSocketSub(sub);
-            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
-            {
-                original = messageEvent.OriginalData;
-                rstEvent.Set();
-            });
-            sub.AddSubscription(subObj);
-            var msgToSend = JsonSerializer.Serialize(new { topic = "topic", action = "update", property = "123" });
+//            client.SubClient.ConnectSocketSub(sub);
+//            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
+//            {
+//                original = messageEvent.OriginalData;
+//                rstEvent.Set();
+//            });
+//            sub.AddSubscription(subObj);
+//            var msgToSend = JsonSerializer.Serialize(new { topic = "topic", action = "update", property = "123" });

-            // act
-            socket.InvokeMessage(msgToSend);
-            rstEvent.WaitOne(1000);
+//            // act
+//            socket.InvokeMessage(msgToSend);
+//            rstEvent.WaitOne(1000);

-            // assert
-            Assert.That(original == (enabled ? msgToSend : null));
-        }
+//            // assert
+//            Assert.That(original == (enabled ? msgToSend : null));
+//        }

-        [TestCase()]
-        public void UnsubscribingStream_Should_CloseTheSocket()
-        {
-            // arrange
-            var client = new TestSocketClient(options =>
-            {
-                options.ReconnectInterval = TimeSpan.Zero;
-            });
-            var socket = client.CreateSocket();
-            socket.CanConnect = true;
-            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
-            client.SubClient.ConnectSocketSub(sub);
+//        [TestCase()]
+//        public void UnsubscribingStream_Should_CloseTheSocket()
+//        {
+//            // arrange
+//            var client = new TestSocketClient(options =>
+//            {
+//                options.ReconnectInterval = TimeSpan.Zero;
+//            });
+//            var socket = client.CreateSocket();
+//            socket.CanConnect = true;
+//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
+//            client.SubClient.ConnectSocketSub(sub);

-            var subscription = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
-            var ups = new UpdateSubscription(sub, subscription);
-            sub.AddSubscription(subscription);
+//            var subscription = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+//            var ups = new UpdateSubscription(sub, subscription);
+//            sub.AddSubscription(subscription);

-            // act
-            client.UnsubscribeAsync(ups).Wait();
+//            // act
+//            client.UnsubscribeAsync(ups).Wait();

-            // assert
-            Assert.That(socket.Connected == false);
-        }
+//            // assert
+//            Assert.That(socket.Connected == false);
+//        }

-        [TestCase()]
-        public void UnsubscribingAll_Should_CloseAllSockets()
-        {
-            // arrange
-            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
-            var socket1 = client.CreateSocket();
-            var socket2 = client.CreateSocket();
-            socket1.CanConnect = true;
-            socket2.CanConnect = true;
-            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket1, null);
-            var sub2 = new SocketConnection(new TraceLogger(), client.SubClient, socket2, null);
-            client.SubClient.ConnectSocketSub(sub1);
-            client.SubClient.ConnectSocketSub(sub2);
-            var subscription1 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
-            var subscription2 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+//        [TestCase()]
+//        public void UnsubscribingAll_Should_CloseAllSockets()
+//        {
+//            // arrange
+//            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
+//            var socket1 = client.CreateSocket();
+//            var socket2 = client.CreateSocket();
+//            socket1.CanConnect = true;
+//            socket2.CanConnect = true;
+//            var sub1 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket1), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
+//            var sub2 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket2), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
+//            client.SubClient.ConnectSocketSub(sub1);
+//            client.SubClient.ConnectSocketSub(sub2);
+//            var subscription1 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+//            var subscription2 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });

-            sub1.AddSubscription(subscription1);
-            sub2.AddSubscription(subscription2);
-            var ups1 = new UpdateSubscription(sub1, subscription1);
-            var ups2 = new UpdateSubscription(sub2, subscription2);
+//            sub1.AddSubscription(subscription1);
+//            sub2.AddSubscription(subscription2);
+//            var ups1 = new UpdateSubscription(sub1, subscription1);
+//            var ups2 = new UpdateSubscription(sub2, subscription2);

-            // act
-            client.UnsubscribeAllAsync().Wait();
+//            // act
+//            client.UnsubscribeAllAsync().Wait();

-            // assert
-            Assert.That(socket1.Connected == false);
-            Assert.That(socket2.Connected == false);
-        }
+//            // assert
+//            Assert.That(socket1.Connected == false);
+//            Assert.That(socket2.Connected == false);
+//        }

-        [TestCase()]
-        public void FailingToConnectSocket_Should_ReturnError()
-        {
-            // arrange
-            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
-            var socket = client.CreateSocket();
-            socket.CanConnect = false;
-            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
+//        [TestCase()]
+//        public void FailingToConnectSocket_Should_ReturnError()
+//        {
+//            // arrange
+//            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
+//            var socket = client.CreateSocket();
+//            socket.CanConnect = false;
+//            var sub1 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");

-            // act
-            var connectResult = client.SubClient.ConnectSocketSub(sub1);
+//            // act
+//            var connectResult = client.SubClient.ConnectSocketSub(sub1);

-            // assert
-            ClassicAssert.IsFalse(connectResult.Success);
-        }
+//            // assert
+//            ClassicAssert.IsFalse(connectResult.Success);
+//        }

-        [TestCase()]
-        public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
-        {
-            // arrange
-            var channel = "trade_btcusd";
-            var client = new TestSocketClient(opt =>
-            {
-                opt.OutputOriginalData = true;
-                opt.SocketSubscriptionsCombineTarget = 1;
-            });
-            var socket = client.CreateSocket();
-            socket.CanConnect = true;
-            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, "https://test.test"));
+//        [TestCase()]
+//        public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
+//        {
+//            // arrange
+//            var channel = "trade_btcusd";
+//            var client = new TestSocketClient(opt =>
+//            {
+//                opt.OutputOriginalData = true;
+//                opt.SocketSubscriptionsCombineTarget = 1;
+//            });
+//            var socket = client.CreateSocket();
+//            socket.CanConnect = true;
+//            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));

-            // act
-            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "error" }));
-            await sub;
+//            // act
+//            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
+//            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "error" }));
+//            await sub;

-            // assert
-            ClassicAssert.IsFalse(client.SubClient.TestSubscription.Confirmed);
-        }
+//            // assert
+//            ClassicAssert.IsTrue(client.SubClient.TestSubscription.Status != SubscriptionStatus.Subscribed);
+//        }

-        [TestCase()]
-        public async Task SuccessResponse_Should_ConfirmSubscription()
-        {
-            // arrange
-            var channel = "trade_btcusd";
-            var client = new TestSocketClient(opt =>
-            {
-                opt.OutputOriginalData = true;
-                opt.SocketSubscriptionsCombineTarget = 1;
-            });
-            var socket = client.CreateSocket();
-            socket.CanConnect = true;
-            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, "https://test.test"));
+//        [TestCase()]
+//        public async Task SuccessResponse_Should_ConfirmSubscription()
+//        {
+//            // arrange
+//            var channel = "trade_btcusd";
+//            var client = new TestSocketClient(opt =>
+//            {
+//                opt.OutputOriginalData = true;
+//                opt.SocketSubscriptionsCombineTarget = 1;
+//            });
+//            var socket = client.CreateSocket();
+//            socket.CanConnect = true;
+//            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));

-            // act
-            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "confirmed" }));
-            await sub;
+//            // act
+//            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
+//            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "confirmed" }));
+//            await sub;

-            // assert
-            Assert.That(client.SubClient.TestSubscription.Confirmed);
-        }
-    }
-}
+//            // assert
+//            Assert.That(client.SubClient.TestSubscription.Status == SubscriptionStatus.Subscribed);
+//        }
+//    }
+//}
@@ -4,9 +4,8 @@ using System.Text.Json;
 using NUnit.Framework;
 using System;
 using System.Text.Json.Serialization;
-using NUnit.Framework.Legacy;
 using CryptoExchange.Net.Converters;
-using CryptoExchange.Net.Testing.Comparers;
+using CryptoExchange.Net.SharedApis;

 namespace CryptoExchange.Net.UnitTests
 {
@@ -223,13 +222,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)]
@@ -269,9 +272,18 @@ namespace CryptoExchange.Net.UnitTests
                TestInternal = new Test
                {
                    Prop1 = 10
-                }
+                },
+                Prop8 = new Test3
+                {
+                    Prop31 = 5,
+                    Prop32 = "101"
+                },
            };

+            var options = new JsonSerializerOptions()
+            {
+                TypeInfoResolver = new SerializationContext()
+            };
            var serialized = JsonSerializer.Serialize(data);
            var deserialized = JsonSerializer.Deserialize<Test>(serialized);

@@ -286,6 +298,42 @@ namespace CryptoExchange.Net.UnitTests
            Assert.That(deserialized.Prop6.Prop32, Is.EqualTo("789"));
            Assert.That(deserialized.Prop7, Is.EqualTo(TestEnum.Two));
            Assert.That(deserialized.TestInternal.Prop1, Is.EqualTo(10));
+            Assert.That(deserialized.Prop8.Prop31, Is.EqualTo(5));
+            Assert.That(deserialized.Prop8.Prop32, Is.EqualTo("101"));
+        }
+
+        [TestCase(TradingMode.Spot, "ETH", "USDT", null)]
+        [TestCase(TradingMode.PerpetualLinear, "ETH", "USDT", null)]
+        [TestCase(TradingMode.DeliveryLinear, "ETH", "USDT", 1748432430)]
+        public void TestSharedSymbolConversion(TradingMode tradingMode, string baseAsset, string quoteAsset, int? deliverTime)
+        {
+            DateTime? time = deliverTime == null ? null : DateTimeConverter.ParseFromDouble(deliverTime.Value);
+            var symbol = new SharedSymbol(tradingMode, baseAsset, quoteAsset, time);
+
+            var serialized = JsonSerializer.Serialize(symbol);
+            var restored = JsonSerializer.Deserialize<SharedSymbol>(serialized);
+
+            Assert.That(restored.TradingMode, Is.EqualTo(symbol.TradingMode));
+            Assert.That(restored.BaseAsset, Is.EqualTo(symbol.BaseAsset));
+            Assert.That(restored.QuoteAsset, Is.EqualTo(symbol.QuoteAsset));
+            Assert.That(restored.DeliverTime, Is.EqualTo(symbol.DeliverTime));
+        }
+
+        [TestCase(0.1, null, null)]
+        [TestCase(0.1, 0.1, null)]
+        [TestCase(0.1, 0.1, 0.1)]
+        [TestCase(null, 0.1, null)]
+        [TestCase(null, 0.1, 0.1)]
+        public void TestSharedQuantityConversion(double? baseQuantity, double? quoteQuantity, double? contractQuantity)
+        {
+            var symbol = new SharedOrderQuantity((decimal?)baseQuantity, (decimal?)quoteQuantity, (decimal?)contractQuantity);
+
+            var serialized = JsonSerializer.Serialize(symbol);
+            var restored = JsonSerializer.Deserialize<SharedOrderQuantity>(serialized);
+
+            Assert.That(restored.QuantityInBaseAsset, Is.EqualTo(symbol.QuantityInBaseAsset));
+            Assert.That(restored.QuantityInQuoteAsset, Is.EqualTo(symbol.QuantityInQuoteAsset));
+            Assert.That(restored.QuantityInContracts, Is.EqualTo(symbol.QuantityInContracts));
        }
    }

@@ -323,7 +371,7 @@ namespace CryptoExchange.Net.UnitTests
        public bool Value { get; set; }
    }

-    [JsonConverter(typeof(ArrayConverter<Test, SerializationContext>))]
+    [JsonConverter(typeof(ArrayConverter<Test>))]
    record Test
    {
        [ArrayProperty(0)]
@@ -344,9 +392,11 @@ namespace CryptoExchange.Net.UnitTests
        public TestEnum? Prop7 { get; set; }
        [ArrayProperty(7)]
        public Test TestInternal { get; set; }
+        [ArrayProperty(8), JsonConversion]
+        public Test3 Prop8 { get; set; }
    }

-    [JsonConverter(typeof(ArrayConverter<Test2, SerializationContext>))]
+    [JsonConverter(typeof(ArrayConverter<Test2>))]
    record Test2
    {
        [ArrayProperty(0)]
@@ -1,51 +0,0 @@
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Collections.Generic;
-using System.Text.Json.Serialization;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
-{
-    internal class SubResponse
-    {
-
-        [JsonPropertyName("action")]
-        public string Action { get; set; } = null!;
-
-        [JsonPropertyName("channel")]
-        public string Channel { get; set; } = null!;
-
-        [JsonPropertyName("status")]
-        public string Status { get; set; } = null!;
-    }
-
-    internal class UnsubResponse
-    {
-        [JsonPropertyName("action")]
-        public string Action { get; set; } = null!;
-
-        [JsonPropertyName("status")]
-        public string Status { get; set; } = null!;
-    }
-
-    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 };
-        }
-
-        public override 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 base.HandleMessage(connection, message);
-        }
-    }
-}
@@ -1,19 +0,0 @@
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-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 };
-        }
-    }
-}
@@ -1,36 +0,0 @@
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using Microsoft.Extensions.Logging;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
-{
-    internal class TestSubscription<T> : Subscription<object, object>
-    {
-        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;
-        }
-
-        public override CallResult DoHandleMessage(SocketConnection connection, DataEvent<object> message)
-        {
-            var data = (T)message.Data;
-            _handler.Invoke(message.As(data));
-            return new CallResult(null);
-        }
-
-        public override Type GetMessageType(IMessageAccessor message) => typeof(T);
-        public override Query GetSubQuery(SocketConnection connection) => new TestQuery("sub", new object(), false, 1);
-        public override Query GetUnsubQuery() => new TestQuery("unsub", new object(), false, 1);
-    }
-}
@@ -1,38 +0,0 @@
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using Microsoft.Extensions.Logging;
-using Moq;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
-{
-    internal class TestSubscriptionWithResponseCheck<T> : Subscription<SubResponse, UnsubResponse>
-    {
-        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 };
-            _handler = handler;
-            _channel = channel;
-        }
-
-        public override CallResult DoHandleMessage(SocketConnection connection, DataEvent<object> message)
-        {
-            var data = (T)message.Data;
-            _handler.Invoke(message.As(data));
-            return new CallResult(null);
-        }
-
-        public override Type GetMessageType(IMessageAccessor message) => typeof(T);
-        public override Query GetSubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "subscribe", false, 1);
-        public override Query GetUnsubQuery() => new TestChannelQuery(_channel, "unsubscribe", false, 1);
-    }
-}
@@ -1,19 +1,18 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Net.Http;
 using System.Text;
-using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 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;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;

 namespace CryptoExchange.Net.UnitTests
 {
@@ -24,12 +23,14 @@ namespace CryptoExchange.Net.UnitTests
        public TestBaseClient(): base(null, "Test")
        {
            var options = new TestClientOptions();
+            _logger = NullLogger.Instance;
            Initialize(options);
            SubClient = AddApiClient(new TestSubClient(options, new RestApiOptions()));
        }

        public TestBaseClient(TestClientOptions exchangeOptions) : base(null, "Test")
        {
+            _logger = NullLogger.Instance;
            Initialize(exchangeOptions);
            SubClient = AddApiClient(new TestSubClient(exchangeOptions, new RestApiOptions()));
        }
@@ -42,6 +43,8 @@ namespace CryptoExchange.Net.UnitTests

    public class TestSubClient : RestApiClient
    {
+        protected override IRestMessageHandler MessageHandler => throw new NotImplementedException();
+
        public TestSubClient(RestExchangeOptions<TestEnvironment> options, RestApiOptions apiOptions) : base(new TraceLogger(), null, "https://localhost:123", options, apiOptions)
        {
        }
@@ -52,7 +55,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;
@@ -70,15 +73,27 @@ namespace CryptoExchange.Net.UnitTests

    public class TestAuthProvider : AuthenticationProvider
    {
+        public override ApiCredentialsType[] SupportedCredentialTypes => [ApiCredentialsType.Hmac];
+
        public TestAuthProvider(ApiCredentials credentials) : base(credentials)
        {
        }

-        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;
    }
+
+    public class TestEnvironment : TradeEnvironment
+    {
+        public string TestAddress { get; }
+
+        public TestEnvironment(string name, string url) : base(name)
+        {
+            TestAddress = url;
+        }
+    }
 }
@@ -13,11 +13,13 @@ using CryptoExchange.Net.Authentication;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 using CryptoExchange.Net.Clients;
-using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Options;
 using System.Linq;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using System.Text.Json.Serialization;
+using System.Net.Http.Headers;
+using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;

 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
@@ -48,19 +50,19 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations

            var response = new Mock<IResponse>();
            response.Setup(c => c.IsSuccessStatusCode).Returns(true);
-            response.Setup(c => c.GetResponseStreamAsync()).Returns(Task.FromResult((Stream)responseStream));
+            response.Setup(c => c.GetResponseStreamAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult((Stream)responseStream));
            
-            var headers = new Dictionary<string, string[]>();
+            var headers = new HttpRequestMessage().Headers;
            var request = new Mock<IRequest>();
            request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
            request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response.Object));
            request.Setup(c => c.SetContent(It.IsAny<string>(), It.IsAny<string>())).Callback(new Action<string, string>((content, type) => { request.Setup(r => r.Content).Returns(content); }));
            request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(key, new string[] { val }));
-            request.Setup(c => c.GetHeaders()).Returns(() => headers.ToArray());
+            request.Setup(c => c.GetHeaders()).Returns(() => headers);

            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => 
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => 
                { 
                    request.Setup(a => a.Uri).Returns(uri);
                    request.Setup(a => a.Method).Returns(method); 
@@ -68,8 +70,8 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
                .Returns(request.Object);

            factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) =>
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) =>
                {
                    request.Setup(a => a.Uri).Returns(uri);
                    request.Setup(a => a.Method).Returns(method);
@@ -85,16 +87,16 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
           
            var request = new Mock<IRequest>();
            request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
-            request.Setup(c => c.GetHeaders()).Returns(new KeyValuePair<string, string[]>[0]);
+            request.Setup(c => c.GetHeaders()).Returns(new HttpRequestMessage().Headers);
            request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Throws(we);

            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                .Returns(request.Object);


            factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                .Returns(request.Object);
        }

@@ -107,29 +109,31 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations

            var response = new Mock<IResponse>();
            response.Setup(c => c.IsSuccessStatusCode).Returns(false);
-            response.Setup(c => c.GetResponseStreamAsync()).Returns(Task.FromResult((Stream)responseStream));
+            response.Setup(c => c.GetResponseStreamAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult((Stream)responseStream));

            var headers = new List<KeyValuePair<string, string[]>>();
            var request = new Mock<IRequest>();
            request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
            request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response.Object));
            request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(new KeyValuePair<string, string[]>(key, new string[] { val })));
-            request.Setup(c => c.GetHeaders()).Returns(headers.ToArray());
+            request.Setup(c => c.GetHeaders()).Returns(new HttpRequestMessage().Headers);

            var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
                .Returns(request.Object);

            factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
                .Returns(request.Object);
        }
    }

    public class TestRestApi1Client : RestApiClient
    {
+        protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
+
        public TestRestApi1Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api1Options)
        {
            RequestFactory = new Mock<IRequestFactory>().Object;
@@ -177,6 +181,8 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations

    public class TestRestApi2Client : RestApiClient
    {
+        protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
+
        public TestRestApi2Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api2Options)
        {
            RequestFactory = new Mock<IRequestFactory>().Object;
@@ -193,13 +199,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
            return await SendAsync<T>("http://www.test.com", new RequestDefinition("/", HttpMethod.Get) { Weight = 0 }, null, ct);
        }

-        protected override Error ParseErrorResponse(int httpStatusCode, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor)
-        {
-            var errorData = accessor.Deserialize<TestError>();
-
-            return new ServerError(errorData.Data.ErrorCode, errorData.Data.ErrorMessage);
-        }
-
        public override TimeSpan? GetTimeOffset()
        {
            throw new NotImplementedException();
@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.TestImplementations
+{
+    internal class TestRestMessageHandler : JsonRestMessageHandler
+    {
+        private ErrorMapping _errorMapping = new ErrorMapping([]);
+        public override JsonSerializerOptions Options => new JsonSerializerOptions();
+
+        public override ValueTask<Error> ParseErrorResponse(int httpStatusCode, HttpResponseHeaders responseHeaders, Stream responseStream)
+        {
+            var errorData = JsonSerializer.Deserialize<TestError>(responseStream);
+
+            return new ValueTask<Error>(new ServerError(errorData.ErrorCode, _errorMapping.GetErrorInfo(errorData.ErrorCode.ToString(), errorData.ErrorMessage)));
+        }
+    }
+}
@@ -1,132 +0,0 @@
-//using System;
-//using System.IO;
-//using System.Net.WebSockets;
-//using System.Security.Authentication;
-//using System.Text;
-//using System.Threading.Tasks;
-//using CryptoExchange.Net.Interfaces;
-//using CryptoExchange.Net.Objects;
-
-//namespace CryptoExchange.Net.UnitTests.TestImplementations
-//{
-//    public class TestSocket: IWebsocket
-//    {
-//        public bool CanConnect { get; set; }
-//        public bool Connected { get; set; }
-
-//        public event Func<Task> OnClose;
-//#pragma warning disable 0067
-//        public event Func<Task> OnReconnected;
-//        public event Func<Task> OnReconnecting;
-//        public event Func<int, Task> OnRequestRateLimited;
-//#pragma warning restore 0067
-//        public event Func<int, Task> OnRequestSent;
-//        public event Func<WebSocketMessageType, ReadOnlyMemory<byte>, Task> OnStreamMessage;
-//        public event Func<Exception, Task> OnError;
-//        public event Func<Task> OnOpen;
-//        public Func<Task<Uri>> GetReconnectionUrl { get; set; }
-
-//        public int Id { get; }
-//        public bool ShouldReconnect { get; set; }
-//        public TimeSpan Timeout { get; set; }
-//        public Func<string, string> DataInterpreterString { get; set; }
-//        public Func<byte[], string> DataInterpreterBytes { get; set; }
-//        public DateTime? DisconnectTime { get; set; }
-//        public string Url { get; }
-//        public bool IsClosed => !Connected;
-//        public bool IsOpen => Connected;
-//        public bool PingConnection { get; set; }
-//        public TimeSpan PingInterval { get; set; }
-//        public SslProtocols SSLProtocols { get; set; }
-//        public Encoding Encoding { get; set; }
-
-//        public int ConnectCalls { get; private set; }
-//        public bool Reconnecting { get; set; }
-//        public string Origin { get; set; }
-//        public int? RatelimitPerSecond { get; set; }
-
-//        public double IncomingKbps => throw new NotImplementedException();
-
-//        public Uri Uri => new Uri("");
-
-//        public TimeSpan KeepAliveInterval { get; set; }
-
-//        public static int lastId = 0;
-//        public static object lastIdLock = new object();
-
-//        public TestSocket()
-//        {
-//            lock (lastIdLock)
-//            {
-//                Id = lastId + 1;
-//                lastId++;
-//            }
-//        }
-
-//        public Task<CallResult> ConnectAsync()
-//        {
-//            Connected = CanConnect;
-//            ConnectCalls++;
-//            if (CanConnect)
-//                InvokeOpen();
-//            return Task.FromResult(CanConnect ? new CallResult(null) : new CallResult(new CantConnectError()));
-//        }
-
-//        public bool Send(int requestId, string data, int weight)
-//        {
-//            if(!Connected)
-//                throw new Exception("Socket not connected");
-//            OnRequestSent?.Invoke(requestId);
-//            return true;
-//        }
-
-//        public void Reset()
-//        {
-//        }
-
-//        public Task CloseAsync()
-//        {
-//            Connected = false;
-//            DisconnectTime = DateTime.UtcNow;
-//            OnClose?.Invoke();
-//            return Task.FromResult(0);
-//        }
-
-//        public void SetProxy(string host, int port)
-//        {
-//            throw new NotImplementedException();
-//        }
-//        public void Dispose()
-//        {
-//        }
-
-//        public void InvokeClose()
-//        {
-//            Connected = false;
-//            DisconnectTime = DateTime.UtcNow;
-//            Reconnecting = true;
-//            OnClose?.Invoke();
-//        }
-
-//        public void InvokeOpen()
-//        {
-//            OnOpen?.Invoke();
-//        }
-
-//        public void InvokeMessage(string data)
-//        {
-//            OnStreamMessage?.Invoke(WebSocketMessageType.Text, new ReadOnlyMemory<byte>(Encoding.UTF8.GetBytes(data))).Wait();
-//        }
-
-//        public void SetProxy(ApiProxy proxy)
-//        {
-//            throw new NotImplementedException();
-//        }
-
-//        public void InvokeError(Exception error)
-//        {
-//            OnError?.Invoke(error);
-//        }
-//        public Task ReconnectAsync() => Task.CompletedTask;
-//    }
-//}
@@ -1,139 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Clients;
-using CryptoExchange.Net.Converters.MessageParsing;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
-using Microsoft.Extensions.Logging;
-using Moq;
-using CryptoExchange.Net.Testing.Implementations;
-using CryptoExchange.Net.SharedApis;
-using Microsoft.Extensions.Options;
-using CryptoExchange.Net.Converters.SystemTextJson;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations
-{
-    internal class TestSocketClient: BaseSocketClient
-    {
-        public TestSubSocketClient SubClient { get; }
-
-        /// <summary>
-        /// Create a new instance of KucoinSocketClient
-        /// </summary>
-        /// <param name="optionsFunc">Configure the options to use for this client</param>
-        public TestSocketClient(Action<TestSocketOptions> optionsDelegate = null)
-            : this(Options.Create(ApplyOptionsDelegate(optionsDelegate)), null)
-        {
-        }
-
-        public TestSocketClient(IOptions<TestSocketOptions> options, ILoggerFactory loggerFactory = null) : base(loggerFactory, "Test")
-        {
-            Initialize(options.Value);
-
-            SubClient = AddApiClient(new TestSubSocketClient(options.Value, options.Value.SubOptions));
-            SubClient.SocketFactory = new Mock<IWebsocketFactory>().Object;
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket("https://test.com"));
-        }
-
-        public TestSocket CreateSocket()
-        {
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket("https://test.com"));
-            return (TestSocket)SubClient.CreateSocketInternal("https://localhost:123/");
-        }
-                
-    }
-
-    public class TestEnvironment : TradeEnvironment
-    {
-        public string TestAddress { get; }
-
-        public TestEnvironment(string name, string url) : base(name)
-        {
-            TestAddress = url;
-        }
-    }
-
-    public class TestSocketOptions: SocketExchangeOptions<TestEnvironment>
-    {
-        public static TestSocketOptions Default = new TestSocketOptions
-        {
-            Environment = new TestEnvironment("Live", "https://test.test")
-        };
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public TestSocketOptions()
-        {
-            Default?.Set(this);
-        }
-
-        public SocketApiOptions SubOptions { get; set; } = new SocketApiOptions();
-
-        internal TestSocketOptions Set(TestSocketOptions targetOptions)
-        {
-            targetOptions = base.Set<TestSocketOptions>(targetOptions);
-            targetOptions.SubOptions = SubOptions.Set(targetOptions.SubOptions);
-            return targetOptions;
-        }
-    }
-
-    public class TestSubSocketClient : SocketApiClient
-    {
-        private MessagePath _channelPath = MessagePath.Get().Property("channel");
-        private MessagePath _actionPath = MessagePath.Get().Property("action");
-        private MessagePath _topicPath = MessagePath.Get().Property("topic");
-
-        public Subscription TestSubscription { get; private set; } = null;
-
-        public TestSubSocketClient(TestSocketOptions options, SocketApiOptions apiOptions) : base(new TraceLogger(), options.Environment.TestAddress, options, apiOptions)
-        {
-
-        }
-
-        protected internal override IByteMessageAccessor CreateAccessor() => new SystemTextJsonByteMessageAccessor(new System.Text.Json.JsonSerializerOptions());
-        protected internal override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(new System.Text.Json.JsonSerializerOptions());
-
-        /// <inheritdoc />
-        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
-
-        internal IWebsocket CreateSocketInternal(string address)
-        {
-            return CreateSocket(address);
-        }
-
-        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
-            => new TestAuthProvider(credentials);
-
-        public CallResult ConnectSocketSub(SocketConnection sub)
-        {
-            return ConnectSocketAsync(sub).Result;
-        }
-
-        public override string GetListenerIdentifier(IMessageAccessor message)
-        {
-            if (!message.IsJson)
-            {
-                return "topic";
-            }
-
-            var id = message.GetValue<string>(_channelPath);
-            id ??= message.GetValue<string>(_topicPath);
-
-            return message.GetValue<string>(_actionPath) + "-" + id;
-        }
-
-        public Task<CallResult<UpdateSubscription>> SubscribeToSomethingAsync(string channel, Action<DataEvent<string>> onUpdate, CancellationToken ct)
-        {
-            TestSubscription = new TestSubscriptionWithResponseCheck<string>(channel, onUpdate);
-            return SubscribeAsync(TestSubscription, ct);
-        }        
-    }
-}
@@ -1,10 +1,6 @@
 using CryptoExchange.Net.UnitTests.TestImplementations;
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Text.Json.Serialization;
-using System.Threading.Tasks;

 namespace CryptoExchange.Net.UnitTests
 {
@@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleClient", "Examples\C
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharedClients", "Examples\SharedClients\SharedClients.csproj", "{988A87EF-EAEA-4313-A6CF-FA869813D5AB}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CryptoExchange.Net.Protobuf", "CryptoExchange.Net.Protobuf\CryptoExchange.Net.Protobuf.csproj", "{CC6A807A-9183-6F41-8EF1-8A70172B0E83}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -41,6 +43,10 @@ Global
 		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{988A87EF-EAEA-4313-A6CF-FA869813D5AB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CC6A807A-9183-6F41-8EF1-8A70172B0E83}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -1,7 +1,6 @@
 using System;
 using System.IO;
-using CryptoExchange.Net.Converters.SystemTextJson;
-using CryptoExchange.Net.Converters.MessageParsing;
+using System.Threading.Tasks;

 namespace CryptoExchange.Net.Authentication
 {
@@ -48,6 +47,48 @@ namespace CryptoExchange.Net.Authentication
            Pass = pass;
        }

+        /// <summary>
+        /// Create API credentials using an API key and secret generated by the server
+        /// </summary>
+        public static ApiCredentials HmacCredentials(string apiKey, string apiSecret, string? pass)
+        {
+            return new ApiCredentials(apiKey, apiSecret, pass, ApiCredentialsType.Hmac);
+        }
+
+        /// <summary>
+        /// Create API credentials using an API key and an RSA private key in PEM format
+        /// </summary>
+        public static ApiCredentials RsaPemCredentials(string apiKey, string privateKey)
+        {
+            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.RsaPem);
+        }
+
+        /// <summary>
+        /// Create API credentials using an API key and an RSA private key in XML format
+        /// </summary>
+        public static ApiCredentials RsaXmlCredentials(string apiKey, string privateKey)
+        {
+            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.RsaXml);
+        }
+
+        /// <summary>
+        /// Create API credentials using an API key and an Ed25519 private key
+        /// </summary>
+        public static ApiCredentials Ed25519Credentials(string apiKey, string privateKey)
+        {
+            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.Ed25519);
+        }
+
+        /// <summary>
+        /// Load a key from a file
+        /// </summary>
+        public static string ReadFromFile(string path)
+        {
+            using var fileStream = File.OpenRead(path);
+            using var streamReader = new StreamReader(fileStream);
+            return streamReader.ReadToEnd();
+        }
+
        /// <summary>
        /// Copy the credentials
        /// </summary>
@@ -16,6 +16,10 @@
        /// <summary>
        /// Rsa keys credentials in pem/base64 format. Only available for .NetStandard 2.1 and up, use xml format for lower.
        /// </summary>
-        RsaPem
+        RsaPem,
+        /// <summary>
+        /// Ed25519 keys credentials
+        /// </summary>
+        Ed25519
    }
 }
@@ -2,10 +2,13 @@
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+#if NET8_0_OR_GREATER
+using NSec.Cryptography;
+#endif
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Globalization;
-using System.Net.Http;
 using System.Security.Cryptography;
 using System.Text;

@@ -18,6 +21,11 @@ namespace CryptoExchange.Net.Authentication
    {
        internal IAuthTimeProvider TimeProvider { get; set; } = new AuthTimeProvider();

+        /// <summary>
+        /// The supported credential types
+        /// </summary>
+        public abstract ApiCredentialsType[] SupportedCredentialTypes { get; }
+
        /// <summary>
        /// Provided credentials
        /// </summary>
@@ -28,6 +36,13 @@ namespace CryptoExchange.Net.Authentication
        /// </summary>
        protected byte[] _sBytes;

+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// The Ed25519 private key
+        /// </summary>
+        protected Key? Ed25519Key;
+#endif
+
        /// <summary>
        /// Get the API key of the current credentials
        /// </summary>
@@ -46,35 +61,26 @@ namespace CryptoExchange.Net.Authentication
            if (credentials.Key == null || credentials.Secret == null)
                throw new ArgumentException("ApiKey/Secret needed");

+            if (!SupportedCredentialTypes.Any(x => x == credentials.CredentialType))
+                throw new ArgumentException($"Credential type {credentials.CredentialType} not supported");
+
+            if (credentials.CredentialType == ApiCredentialsType.Ed25519)
+            {
+#if !NET8_0_OR_GREATER
+                throw new ArgumentException($"Credential type Ed25519 only supported on Net8.0 or newer");
+#endif
+            }
+
            _credentials = credentials;
            _sBytes = Encoding.UTF8.GetBytes(credentials.Secret);
        }

        /// <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="method">The method of the request</param>
-        /// <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
-            );
+        /// <param name="requestConfig">The request configuration</param>
+        public abstract void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig);

        /// <summary>
        /// SHA256 sign the data and return the bytes
@@ -368,6 +374,36 @@ namespace CryptoExchange.Net.Authentication
            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
        }

+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(string data, SignOutputType? outputType = null)
+            => SignEd25519(Encoding.ASCII.GetBytes(data), outputType);
+
+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(byte[] data, SignOutputType? outputType = null)
+        {
+#if NET8_0_OR_GREATER
+            if (Ed25519Key == null)
+            {
+                var key = _credentials.Secret!
+                        .Replace("\n", "")
+                        .Replace("-----BEGIN PRIVATE KEY-----", "")
+                        .Replace("-----END PRIVATE KEY-----", "")
+                        .Trim();
+                var keyBytes = Convert.FromBase64String(key);
+                Ed25519Key = Key.Import(SignatureAlgorithm.Ed25519, keyBytes, KeyBlobFormat.PkixPrivateKey);
+            }
+
+            var resultBytes = SignatureAlgorithm.Ed25519.Sign(Ed25519Key, data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+#else
+            throw new InvalidOperationException();
+#endif
+        }
+
        private RSA CreateRSA()
        {
            var rsa = RSA.Create();
@@ -465,10 +501,13 @@ namespace CryptoExchange.Net.Authentication
        /// <returns></returns>
        protected static string GetSerializedBody(IMessageSerializer serializer, IDictionary<string, object> parameters)
        {
-            if (parameters.Count == 1 && parameters.TryGetValue(Constants.BodyPlaceHolderKey, out object? value))
-                return serializer.Serialize(value);
+            if (serializer is not IStringMessageSerializer stringSerializer)
+                throw new InvalidOperationException("Non-string message serializer can't get serialized request body");
+
+            if (parameters?.Count == 1 && parameters.TryGetValue(Constants.BodyPlaceHolderKey, out object? value))
+                return stringSerializer.Serialize(value);
            else
-                return serializer.Serialize(parameters);
+                return stringSerializer.Serialize(parameters);
        }
    }

@@ -1,11 +1,18 @@
 using System;
 using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading;

 namespace CryptoExchange.Net.Caching
 {
    internal class MemoryCache
    {
        private readonly ConcurrentDictionary<string, CacheItem> _cache = new ConcurrentDictionary<string, CacheItem>();
+#if NET9_0_OR_GREATER
+        private readonly Lock _lock = new Lock();
+#else
+        private readonly object _lock = new object();
+#endif

        /// <summary>
        /// Add a new cache entry. Will override an existing entry if it already exists
@@ -26,16 +33,13 @@ namespace CryptoExchange.Net.Caching
        /// <returns>Cached value if it was in cache</returns>
        public object? Get(string key, TimeSpan maxAge)
        {
+            foreach (var item in _cache.Where(x => DateTime.UtcNow - x.Value.CacheTime > maxAge).ToList())
+                _cache.TryRemove(item.Key, out _);
+            
            _cache.TryGetValue(key, out CacheItem? value);
            if (value == null)
                return null;

-            if (DateTime.UtcNow - value.CacheTime > maxAge)
-            {
-                _cache.TryRemove(key, out _);
-                return null;
-            }
-
            return value.Value;
        }

@@ -1,7 +1,7 @@
 using System;
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Interfaces.Clients;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Logging;
@@ -39,7 +39,10 @@ namespace CryptoExchange.Net.Clients
        public bool OutputOriginalData { get; }

        /// <inheritdoc />
-        public bool Authenticated => ApiOptions.ApiCredentials != null || ClientOptions.ApiCredentials != null;
+        public bool Authenticated => ApiCredentials != null;
+
+        /// <inheritdoc />
+        public ApiCredentials? ApiCredentials { get; set; }

        /// <summary>
        /// Api options
@@ -51,6 +54,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>
@@ -68,9 +76,10 @@ namespace CryptoExchange.Net.Clients
            ApiOptions = apiOptions;
            OutputOriginalData = outputOriginalData;
            BaseAddress = baseAddress;
+            ApiCredentials = apiCredentials?.Copy();

-            if (apiCredentials != null)
-                AuthenticationProvider = CreateAuthenticationProvider(apiCredentials.Copy());
+            if (ApiCredentials != null)
+                AuthenticationProvider = CreateAuthenticationProvider(ApiCredentials);
        }

        /// <summary>
@@ -83,12 +92,22 @@ 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
        {
-            ApiOptions.ApiCredentials = credentials;
-            if (credentials != null)
-                AuthenticationProvider = CreateAuthenticationProvider(credentials.Copy());
+            ApiCredentials = credentials?.Copy();
+            if (ApiCredentials != null)
+                AuthenticationProvider = CreateAuthenticationProvider(ApiCredentials);
        }

        /// <inheritdoc />
@@ -97,9 +116,9 @@ namespace CryptoExchange.Net.Clients
            ClientOptions.Proxy = options.Proxy;
            ClientOptions.RequestTimeout = options.RequestTimeout ?? ClientOptions.RequestTimeout;

-            ApiOptions.ApiCredentials = options.ApiCredentials ?? ClientOptions.ApiCredentials;
-            if (options.ApiCredentials != null)
-                AuthenticationProvider = CreateAuthenticationProvider(options.ApiCredentials.Copy());
+            ApiCredentials = options.ApiCredentials?.Copy() ?? ApiCredentials;
+            if (ApiCredentials != null)
+                AuthenticationProvider = CreateAuthenticationProvider(ApiCredentials);
        }

        /// <summary>
@@ -1,9 +1,9 @@
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
 using System;
 using System.Collections.Generic;
+using System.Threading;

 namespace CryptoExchange.Net.Clients
 {
@@ -49,7 +49,11 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        protected internal ILogger _logger;

+#if NET9_0_OR_GREATER
+        private readonly Lock _versionLock = new Lock();
+#else
        private readonly object _versionLock = new object();
+#endif
        private Version _exchangeVersion;

        /// <summary>
@@ -66,8 +70,6 @@ namespace CryptoExchange.Net.Clients
        protected BaseClient(ILoggerFactory? logger, string exchange)
 #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
        {
-            _logger = logger?.CreateLogger(exchange) ?? NullLoggerFactory.Instance.CreateLogger(exchange);
-
            Exchange = exchange;
        }

@@ -104,7 +106,6 @@ namespace CryptoExchange.Net.Clients
            if (ClientOptions == null)
                throw new InvalidOperationException("Client should have called Initialize before adding API clients");

-            _logger.Log(LogLevel.Trace, $"  {apiClient.GetType().Name}, base address: {apiClient.BaseAddress}");
            ApiClients.Add(apiClient);
            return apiClient;
        }
@@ -124,7 +125,6 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        public virtual void Dispose()
        {
-            _logger.Log(LogLevel.Debug, "Disposing client");
            foreach (var client in ApiClients)
                client.Dispose();
        }
@@ -1,6 +1,7 @@
 using System.Linq;
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;

 namespace CryptoExchange.Net.Clients
 {
@@ -19,6 +20,9 @@ namespace CryptoExchange.Net.Clients
        /// <param name="name">The name of the API this client is for</param>
        protected BaseRestClient(ILoggerFactory? loggerFactory, string name) : base(loggerFactory, name)
        {
+            _logger = loggerFactory?.CreateLogger(name + ".RestClient") ?? NullLoggerFactory.Instance.CreateLogger(name);
+
+            LibraryHelpers.StaticLogger = loggerFactory?.CreateLogger("CryptoExchange");
        }
    }
 }
@@ -1,12 +1,14 @@
-using System;
+using CryptoExchange.Net.Interfaces.Clients;
+using CryptoExchange.Net.Logging.Extensions;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Sockets;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Logging.Extensions;
-using CryptoExchange.Net.Objects.Sockets;
-using Microsoft.Extensions.Logging;

 namespace CryptoExchange.Net.Clients
 {
@@ -28,15 +30,21 @@ namespace CryptoExchange.Net.Clients
        public int CurrentSubscriptions => ApiClients.OfType<SocketApiClient>().Sum(s => s.CurrentSubscriptions);
        /// <inheritdoc />
        public double IncomingKbps => ApiClients.OfType<SocketApiClient>().Sum(s => s.IncomingKbps);
+
+        /// <inheritdoc />
+        public new SocketExchangeOptions ClientOptions => (SocketExchangeOptions)base.ClientOptions;
        #endregion

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="logger">Logger</param>
-        /// <param name="exchange">The name of the exchange this client is for</param>
-        protected BaseSocketClient(ILoggerFactory? logger, string exchange) : base(logger, exchange)
+        /// <param name="loggerFactory">Logger factory</param>
+        /// <param name="name">The name of the exchange this client is for</param>
+        protected BaseSocketClient(ILoggerFactory? loggerFactory, string name) : base(loggerFactory, name)
        {
+            _logger = loggerFactory?.CreateLogger(name + ".SocketClient") ?? NullLoggerFactory.Instance.CreateLogger(name);
+
+            LibraryHelpers.StaticLogger = loggerFactory?.CreateLogger("CryptoExchange");
        }

        /// <summary>
@@ -1,8 +1,5 @@
-using CryptoExchange.Net.Interfaces;
-using Microsoft.Extensions.DependencyInjection;
+using CryptoExchange.Net.Interfaces.Clients;
 using System;
-using System.Collections.Generic;
-using System.Linq;

 namespace CryptoExchange.Net.Clients
 {
@@ -1,4 +1,4 @@
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
 using System;

 namespace CryptoExchange.Net.Clients
@@ -1,3 +1,15 @@
+using CryptoExchange.Net.Caching;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
+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;
+using CryptoExchange.Net.Requests;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -5,17 +17,10 @@ using System.IO;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using CryptoExchange.Net.Caching;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Logging.Extensions;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.RateLimiting;
-using CryptoExchange.Net.RateLimiting.Interfaces;
-using CryptoExchange.Net.Requests;
-using Microsoft.Extensions.Logging;

 namespace CryptoExchange.Net.Clients
 {
@@ -54,7 +59,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
@@ -89,6 +94,11 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        private readonly static MemoryCache _cache = new MemoryCache();

+        /// <summary>
+        /// The message handler
+        /// </summary>
+        protected abstract IRestMessageHandler MessageHandler { get; }
+        
        /// <summary>
        /// ctor
        /// </summary>
@@ -105,7 +115,7 @@ namespace CryptoExchange.Net.Clients
                  options,
                  apiOptions)
        {
-            RequestFactory.Configure(options.Proxy, options.RequestTimeout, httpClient);
+            RequestFactory.Configure(options, httpClient);
        }

        /// <summary>
@@ -203,6 +213,13 @@ namespace CryptoExchange.Net.Clients
            int? weightSingleLimiter = null,
            string? rateLimitKeySuffix = null)
        {
+            var requestId = ExchangeHelpers.NextId();
+            if (definition.Authenticated && AuthenticationProvider == null)
+            {
+                _logger.RestApiNoApiCredentials(requestId, definition.Path);
+                return new WebCallResult<T>(new NoApiCredentialsError());
+            }
+
            string? cacheKey = null;
            if (ShouldCache(definition))
            {
@@ -223,11 +240,21 @@ namespace CryptoExchange.Net.Clients
            while (true)
            {
                currentTry++;
-                var requestId = ExchangeHelpers.NextId();

-                var prepareResult = await PrepareAsync(requestId, baseAddress, definition, cancellationToken, additionalHeaders, weight, weightSingleLimiter, rateLimitKeySuffix).ConfigureAwait(false);
-                if (!prepareResult)
-                    return new WebCallResult<T>(prepareResult.Error!);
+                var error = await CheckTimeSync(requestId, definition).ConfigureAwait(false);
+                if (error != null)
+                    return new WebCallResult<T>(error);
+
+                error = await RateLimitAsync(
+                    baseAddress,
+                    requestId,
+                    definition,
+                    weight ?? definition.Weight,
+                    cancellationToken,
+                    weightSingleLimiter,
+                    rateLimitKeySuffix).ConfigureAwait(false);
+                if (error != null)
+                    return new WebCallResult<T>(error);

                var request = CreateRequest(
                    requestId,
@@ -236,15 +263,24 @@ namespace CryptoExchange.Net.Clients
                    uriParameters,
                    bodyParameters,
                    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)}]")));
+
+                if (_logger.IsEnabled(LogLevel.Debug))
+                    _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 GetResponseAsync2<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]";
                    if (!result)
-                        _logger.RestApiErrorReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), result.Error?.ToString());
+                    {
+                        _logger.RestApiErrorReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), result.Error?.ToString(), originalData, result.Error?.Exception);
+                    }
                    else
-                        _logger.RestApiResponseReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), OutputOriginalData ? result.OriginalData : "[Data only available when OutputOriginal = true]");
+                    {
+                        if (_logger.IsEnabled(LogLevel.Debug))
+                            _logger.RestApiResponseReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), originalData);
+                    }
                }
                else
                {
@@ -264,55 +300,42 @@ namespace CryptoExchange.Net.Clients
            }
        }

+        private async ValueTask<Error?> CheckTimeSync(int requestId, RequestDefinition definition)
+        {
+            if (!definition.Authenticated)
+                return null;
+
+            var syncTask = SyncTimeAsync();
+            var timeSyncInfo = GetTimeSyncInfo();
+
+            if (timeSyncInfo != null && timeSyncInfo.TimeSyncState.LastSyncTime == default)
+            {
+                // Initially with first request we'll need to wait for the time syncing, if it's not the first request we can just continue
+                var syncTimeError = await syncTask.ConfigureAwait(false);
+                if (syncTimeError != null)
+                {
+                    _logger.RestApiFailedToSyncTime(requestId, syncTimeError!.ToString());
+                    return syncTimeError;
+                }
+            }
+
+            return null;
+        }
+
        /// <summary>
-        /// Prepare before sending a request. Sync time between client and server and check rate limits
+        /// Check rate limits for the request
        /// </summary>
-        /// <param name="requestId">Request id</param>
-        /// <param name="baseAddress">Host and schema</param>
-        /// <param name="definition">Request definition</param>
-        /// <param name="cancellationToken">Cancellation token</param>
-        /// <param name="additionalHeaders">Additional headers for this request</param>
-        /// <param name="weight">Override the request weight for this request</param>
-        /// <param name="weightSingleLimiter">Specify the weight to apply to the individual rate limit guard for this request</param>
-        /// <param name="rateLimitKeySuffix">An additional optional suffix for the key selector</param>
-        /// <returns></returns>
-        /// <exception cref="Exception"></exception>
-        protected virtual async Task<CallResult> PrepareAsync(
+        protected virtual async ValueTask<Error?> RateLimitAsync(
+            string host,
            int requestId,
-            string baseAddress,
            RequestDefinition definition,
+            int weight,
            CancellationToken cancellationToken,
-            Dictionary<string, string>? additionalHeaders = null,
-            int? weight = null,
            int? weightSingleLimiter = null,
            string? rateLimitKeySuffix = null)
        {
-            // Time sync
-            if (definition.Authenticated)
-            {
-                if (AuthenticationProvider == null)
-                {
-                    _logger.RestApiNoApiCredentials(requestId, definition.Path);
-                    return new CallResult<IRequest>(new NoApiCredentialsError());
-                }
-
-                var syncTask = SyncTimeAsync();
-                var timeSyncInfo = GetTimeSyncInfo();
-
-                if (timeSyncInfo != null && timeSyncInfo.TimeSyncState.LastSyncTime == default)
-                {
-                    // Initially with first request we'll need to wait for the time syncing, if it's not the first request we can just continue
-                    var syncTimeResult = await syncTask.ConfigureAwait(false);
-                    if (!syncTimeResult)
-                    {
-                        _logger.RestApiFailedToSyncTime(requestId, syncTimeResult.Error!.ToString());
-                        return syncTimeResult.AsDataless();
-                    }
-                }
-            }            
-
            // Rate limiting
-            var requestWeight = weight ?? definition.Weight;
+            var requestWeight = weight;
            if (requestWeight != 0)
            {
                if (definition.RateLimitGate == null)
@@ -320,9 +343,9 @@ namespace CryptoExchange.Net.Clients

                if (ClientOptions.RateLimiterEnabled)
                {
-                    var limitResult = await definition.RateLimitGate.ProcessAsync(_logger, requestId, RateLimitItemType.Request, definition, baseAddress, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
+                    var limitResult = await definition.RateLimitGate.ProcessAsync(_logger, requestId, RateLimitItemType.Request, definition, host, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
                    if (!limitResult)
-                        return new CallResult(limitResult.Error!);
+                        return limitResult.Error!;
                }
            }

@@ -335,13 +358,13 @@ namespace CryptoExchange.Net.Clients
                if (ClientOptions.RateLimiterEnabled)
                {
                    var singleRequestWeight = weightSingleLimiter ?? 1;
-                    var limitResult = await definition.RateLimitGate.ProcessSingleAsync(_logger, requestId, definition.LimitGuard, RateLimitItemType.Request, definition, baseAddress, AuthenticationProvider?._credentials.Key, singleRequestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
+                    var limitResult = await definition.RateLimitGate.ProcessSingleAsync(_logger, requestId, definition.LimitGuard, RateLimitItemType.Request, definition, host, AuthenticationProvider?._credentials.Key, singleRequestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
                    if (!limitResult)
-                        return new CallResult(limitResult.Error!);
+                        return limitResult.Error!;
                }
            }

-            return CallResult.SuccessResult;
+            return null;
        }

        /// <summary>
@@ -362,74 +385,62 @@ namespace CryptoExchange.Net.Clients
            ParameterCollection? bodyParameters,
            Dictionary<string, string>? additionalHeaders)
        {
-            var uriParams = uriParameters == null ? null : CreateParameterDictionary(uriParameters);
-            var bodyParams = bodyParameters == null ? null : CreateParameterDictionary(bodyParameters);
+            var requestConfiguration = new RestRequestConfiguration(
+                definition,
+                baseAddress,
+                uriParameters == null ? null : CreateParameterDictionary(uriParameters),
+                bodyParameters == null ? null : CreateParameterDictionary(bodyParameters),
+                additionalHeaders,
+                definition.ArraySerialization ?? ArraySerialization,
+                definition.ParameterPosition ?? ParameterPositions[definition.Method],
+                definition.RequestBodyFormat ?? RequestBodyFormat);

-            var uri = new Uri(baseAddress.AppendPath(definition.Path));
-            var arraySerialization = definition.ArraySerialization ?? ArraySerialization;
-            var bodyFormat = definition.RequestBodyFormat ?? RequestBodyFormat;
-            var parameterPosition = definition.ParameterPosition ?? ParameterPositions[definition.Method];
-
-            Dictionary<string, string>? headers = null;
-            if (AuthenticationProvider != null)
+            try
            {
-                try
-                {
-                    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);
-                }
+                AuthenticationProvider?.ProcessRequest(this, requestConfiguration);
            }
-
-            // Add the auth parameters to the uri, start with a new URI to be able to sort the parameters including the auth parameters
-            if (uriParams != null)
-                uri = uri.SetParameters(uriParams, arraySerialization);
-
-            var request = RequestFactory.Create(definition.Method, uri, requestId);
-            request.Accept = Constants.JsonContentHeader;
-
-            if (headers != null)
+            catch (Exception ex)
            {
-                foreach (var header in headers)
+                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}";
+
+            var uri = new Uri(baseAddress.AppendPath(definition.Path) + queryString);
+            var request = RequestFactory.Create(ClientOptions.HttpVersion, definition.Method, uri, requestId);
+            request.Accept = MessageHandler.AcceptHeader;
+
+            if (requestConfiguration.Headers != null) 
+            {
+                foreach (var header in requestConfiguration.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
+                requestConfiguration.Headers ??= new Dictionary<string, string>();
+                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
-                    if (additionalHeaders?.ContainsKey(header.Key) != true)
-                        request.AddHeader(header.Key, header.Value);
+                    request.SetContent(bodyContent, contentType);
                }
-            }
-
-            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;
@@ -438,11 +449,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>(
+        protected virtual async Task<WebCallResult<T>> GetResponseAsync2<T>(
+            RequestDefinition requestDefinition,
            IRequest request,
            IRateLimitGate? gate,
            CancellationToken cancellationToken)
@@ -450,27 +463,48 @@ namespace CryptoExchange.Net.Clients
            var sw = Stopwatch.StartNew();
            Stream? responseStream = null;
            IResponse? response = null;
-            IStreamMessageAccessor? accessor = null;
+
            try
            {
                response = await request.GetResponseAsync(cancellationToken).ConfigureAwait(false);
                sw.Stop();
-                var statusCode = response.StatusCode;
-                var headers = response.ResponseHeaders;
-                var responseLength = response.ContentLength;
-                responseStream = await response.GetResponseStreamAsync().ConfigureAwait(false);
+                responseStream = await response.GetResponseStreamAsync(cancellationToken).ConfigureAwait(false);
+                string? originalData = null;
                var outputOriginalData = ApiOptions.OutputOriginalData ?? ClientOptions.OutputOriginalData;
-
-                accessor = CreateAccessor();
-                if (!response.IsSuccessStatusCode)
+                if (outputOriginalData || MessageHandler.RequiresSeekableStream)
                {
-                    // Error response
-                    await accessor.Read(responseStream, true).ConfigureAwait(false);
+                    // If we want to return the original string data from the stream, but still want to process it
+                    // we'll need to copy it as the stream isn't seekable, and thus we can only read it once
+                    var memoryStream = new MemoryStream();
+                    await responseStream.CopyToAsync(memoryStream).ConfigureAwait(false);
+                    using var reader = new StreamReader(memoryStream, Encoding.UTF8, false, 4096, true);
+                    if (outputOriginalData) 
+                    {
+                        memoryStream.Position = 0;
+                        originalData = await reader.ReadToEndAsync().ConfigureAwait(false);
+
+                        if (_logger.IsEnabled(LogLevel.Trace))
+                            _logger.RestApiReceivedResponse(request.RequestId, originalData);
+                    }
+
+                    // Continue processing from the memory stream since the response stream is already read and we can't seek it
+                    responseStream.Close();
+                    memoryStream.Position = 0;
+                    responseStream = memoryStream;
+                }
+
+                if (!response.IsSuccessStatusCode && !requestDefinition.TryParseOnNonSuccess)
+                {
+                    // If the response status is not success it is an error by definition

                    Error error;
                    if (response.StatusCode == (HttpStatusCode)418 || response.StatusCode == (HttpStatusCode)429)
                    {
-                        var rateError = ParseRateLimitResponse((int)response.StatusCode, response.ResponseHeaders, accessor);
+                        // Specifically handle rate limit errors
+                        var rateError = await MessageHandler.ParseErrorRateLimitResponse(
+                            (int)response.StatusCode,
+                            response.ResponseHeaders,
+                            responseStream).ConfigureAwait(false);
                        if (rateError.RetryAfter != null && gate != null && ClientOptions.RateLimiterEnabled)
                        {
                            _logger.RestApiRateLimitPauseUntil(request.RequestId, rateError.RetryAfter.Value);
@@ -481,29 +515,25 @@ namespace CryptoExchange.Net.Clients
                    }
                    else
                    {
-                        error = ParseErrorResponse((int)response.StatusCode, response.ResponseHeaders, accessor);
+                        // Handle a 'normal' error response. Can still be either a json error message or some random HTML or other string
+                        error = await MessageHandler.ParseErrorResponse(
+                            (int)response.StatusCode,
+                            response.ResponseHeaders,
+                            responseStream).ConfigureAwait(false);
                    }

-                    if (error.Code == null || error.Code == 0)
-                        error.Code = (int)response.StatusCode;
-
-                    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!);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
                }

                if (typeof(T) == typeof(object))
                    // Success status code and expected empty response, assume it's correct
-                    return new WebCallResult<T>(statusCode, headers, sw.Elapsed, 0, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, null);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, 0, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, null);

-                var valid = await accessor.Read(responseStream, outputOriginalData).ConfigureAwait(false);
-                if (!valid)
-                {
-                    // Invalid json
-                    var error = new ServerError("Failed to parse response: " + valid.Error!.Message, accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Data only available when OutputOriginal = true in client options]");
-                    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);
+                // Data response received, inspect the message and check if it is an error or not
+                var parsedError = await MessageHandler.CheckForErrorResponse(
+                    requestDefinition,
+                    response.ResponseHeaders,
+                    responseStream).ConfigureAwait(false);
                if (parsedError != null)
                {
                    if (parsedError is ServerRateLimitError rateError)
@@ -516,49 +546,75 @@ namespace CryptoExchange.Net.Clients
                    }

                    // Success status code, but TryParseError determined it was an error response
-                    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, parsedError);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, parsedError);
                }

-                var deserializeResult = accessor.Deserialize<T>();
-                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, deserializeResult.Data, deserializeResult.Error);
+                if (MessageHandler.RequiresSeekableStream)
+                    // Reset stream read position as it might not be at the start if `CheckForErrorResponse` has read from it
+                    responseStream.Position = 0;
+
+                // Try deserialization into the expected type
+                var (deserializeResult, deserializeError) = await MessageHandler.TryDeserializeAsync<T>(responseStream, cancellationToken).ConfigureAwait(false);                              
+                if (deserializeError != null)
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult, deserializeError); ;
+
+                // Check the deserialized response to see if it's an error or not
+                var responseError = MessageHandler.CheckDeserializedResponse(response.ResponseHeaders, deserializeResult);
+                if (responseError != null)
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult, responseError);
+
+                return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult, null);
            }
            catch (HttpRequestException requestException)
            {
                // Request exception, can't reach server for instance
-                var exceptionInfo = requestException.ToLogString();
-                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(exceptionInfo));
+                var error = new WebError(requestException.Message, requestException);
+                return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
            }
            catch (OperationCanceledException canceledException)
            {
                if (cancellationToken != default && canceledException.CancellationToken == cancellationToken)
                {
                    // Cancellation token canceled by caller
-                    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 CancellationRequestedError());
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new CancellationRequestedError(canceledException));
                }
                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"));
+                    var error = new WebError($"Request timed out", exception: canceledException);
+                    error.ErrorType = ErrorType.Timeout;
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
                }
            }
+            catch (ArgumentException argumentException)
+            {
+                if (argumentException.Message.StartsWith("Only HTTP/"))
+                {
+                    // Unsupported HTTP version error .net framework
+                    var error = ArgumentError.Invalid(nameof(RestExchangeOptions.HttpVersion), $"Invalid HTTP version {request.HttpVersion}: " + argumentException.Message);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                }
+
+                throw;
+            }
+            catch (NotSupportedException notSupportedException)
+            {
+                if (notSupportedException.Message.StartsWith("Request version value must be one of"))
+                {
+                    // Unsupported HTTP version error dotnet code
+                    var error = ArgumentError.Invalid(nameof(RestExchangeOptions.HttpVersion), $"Invalid HTTP version {request.HttpVersion}: " + notSupportedException.Message);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                }
+
+                throw;
+            }
            finally
            {
-                accessor?.Clear();
                responseStream?.Close();
                response?.Close();
            }
        }

-        /// <summary>
-        /// Can be used to parse an error even though response status indicates success. Some apis always return 200 OK, even though there is an error.
-        /// 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="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;
-
        /// <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.
        /// Note that this is always called; even when the request might be successful
@@ -568,7 +624,7 @@ namespace CryptoExchange.Net.Clients
        /// <param name="callResult">The result of the call</param>
        /// <param name="tries">The current try number</param>
        /// <returns>True if call should retry, false if the call should return</returns>
-        protected virtual async Task<bool> ShouldRetryRequestAsync<T>(IRateLimitGate? gate, WebCallResult<T> callResult, int tries)
+        protected virtual async ValueTask<bool> ShouldRetryRequestAsync<T>(IRateLimitGate? gate, WebCallResult<T> callResult, int tries)
        {
            if (tries >= 2)
                // Only retry once
@@ -603,12 +659,16 @@ namespace CryptoExchange.Net.Clients
        {
            if (contentType == Constants.JsonContentHeader)
            {
+                var serializer = CreateSerializer();
+                if (serializer is not IStringMessageSerializer stringSerializer)
+                    throw new InvalidOperationException("Non-string message serializer can't get serialized request body");
+
                // Write the parameters as json in the body
                string stringData;
                if (parameters.Count == 1 && parameters.TryGetValue(Constants.BodyPlaceHolderKey, out object? value))
-                    stringData = CreateSerializer().Serialize(value);
+                    stringData = stringSerializer.Serialize(value);
                else
-                    stringData = CreateSerializer().Serialize(parameters);
+                    stringData = stringSerializer.Serialize(parameters);
                request.SetContent(stringData, contentType);
            }
            else if (contentType == Constants.FormContentHeader)
@@ -619,45 +679,6 @@ namespace CryptoExchange.Net.Clients
            }
        }

-        /// <summary>
-        /// Parse an error response from the server. Only used when server returns a status other than Success(200) or ratelimit error (429 or 418)
-        /// </summary>
-        /// <param name="httpStatusCode">The response status code</param>
-        /// <param name="responseHeaders">The response headers</param>
-        /// <param name="accessor">Data accessor</param>
-        /// <returns></returns>
-        protected virtual Error ParseErrorResponse(int httpStatusCode, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor)
-        {
-            var message = accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Error response content only available when OutputOriginal = true in client options]";
-            return new ServerError(message);
-        }
-
-        /// <summary>
-        /// Parse a rate limit error response from the server. Only used when server returns http status 429 or 418
-        /// </summary>
-        /// <param name="httpStatusCode">The response status code</param>
-        /// <param name="responseHeaders">The response headers</param>
-        /// <param name="accessor">Data accessor</param>
-        /// <returns></returns>
-        protected virtual ServerRateLimitError ParseRateLimitResponse(int httpStatusCode, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor)
-        {
-            var message = accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Error response content only available when OutputOriginal = true in client options]";
-
-            // Handle retry after header
-            var retryAfterHeader = responseHeaders.SingleOrDefault(r => r.Key.Equals("Retry-After", StringComparison.InvariantCultureIgnoreCase));
-            if (retryAfterHeader.Value?.Any() != true)
-                return new ServerRateLimitError(message);
-
-            var value = retryAfterHeader.Value.First();
-            if (int.TryParse(value, out var seconds))
-                return new ServerRateLimitError(message) { RetryAfter = DateTime.UtcNow.AddSeconds(seconds) };
-
-            if (DateTime.TryParse(value, out var datetime))
-                return new ServerRateLimitError(message) { RetryAfter = datetime };
-
-            return new ServerRateLimitError(message);
-        }
-
        /// <summary>
        /// Create the parameter IDictionary
        /// </summary>
@@ -682,21 +703,21 @@ namespace CryptoExchange.Net.Clients
        {
            base.SetOptions(options);

-            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout);
+            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout, ClientOptions.HttpKeepAliveInterval);
        }

-        internal async Task<WebCallResult<bool>> SyncTimeAsync()
+        internal async ValueTask<Error?> SyncTimeAsync()
        {
            var timeSyncParams = GetTimeSyncInfo();
            if (timeSyncParams == null)
-                return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
+                return null;

            if (await timeSyncParams.TimeSyncState.Semaphore.WaitAsync(0).ConfigureAwait(false))
            {
                if (!timeSyncParams.SyncTime || DateTime.UtcNow - timeSyncParams.TimeSyncState.LastSyncTime < timeSyncParams.RecalculationInterval)
                {
                    timeSyncParams.TimeSyncState.Semaphore.Release();
-                    return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
+                    return null;
                }

                var localTime = DateTime.UtcNow;
@@ -704,7 +725,7 @@ namespace CryptoExchange.Net.Clients
                if (!result)
                {
                    timeSyncParams.TimeSyncState.Semaphore.Release();
-                    return result.As(false);
+                    return result.Error;
                }

                if (TotalRequestsMade == 1)
@@ -715,7 +736,7 @@ namespace CryptoExchange.Net.Clients
                    if (!result)
                    {
                        timeSyncParams.TimeSyncState.Semaphore.Release();
-                        return result.As(false);
+                        return result.Error;
                    }
                }

@@ -725,12 +746,13 @@ namespace CryptoExchange.Net.Clients
                timeSyncParams.TimeSyncState.Semaphore.Release();
            }

-            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
+            return null;
        }

        private bool ShouldCache(RequestDefinition definition)
            => ClientOptions.CachingEnabled
            && definition.Method == HttpMethod.Get
            && !definition.PreventCaching;
+
    }
 }
@@ -1,10 +1,19 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
 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;
 using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.Sockets;
+using CryptoExchange.Net.Sockets.Default;
+using CryptoExchange.Net.Sockets.Default.Interfaces;
+using CryptoExchange.Net.Sockets.HighPerf;
+using CryptoExchange.Net.Sockets.HighPerf.Interfaces;
+using CryptoExchange.Net.Sockets.Interfaces;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Concurrent;
@@ -25,11 +34,18 @@ namespace CryptoExchange.Net.Clients
        #region Fields
        /// <inheritdoc/>
        public IWebsocketFactory SocketFactory { get; set; } = new WebsocketFactory();
+        /// <inheritdoc/>
+        public IHighPerfConnectionFactory? HighPerfConnectionFactory { get; set; }

        /// <summary>
        /// List of socket connections currently connecting/connected
        /// </summary>
-        protected internal ConcurrentDictionary<int, SocketConnection> socketConnections = new();
+        protected internal ConcurrentDictionary<int, SocketConnection> _socketConnections = new();
+
+        /// <summary>
+        /// List of HighPerf socket connections currently connecting/connected
+        /// </summary>
+        protected internal ConcurrentDictionary<int, HighPerfSocketConnection> _highPerfSocketConnections = new();

        /// <summary>
        /// Semaphore used while creating sockets
@@ -41,6 +57,11 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        protected TimeSpan KeepAliveInterval { get; set; } = TimeSpan.FromSeconds(10);

+        /// <summary>
+        /// Keep alive timeout for websocket connection
+        /// </summary>
+        protected TimeSpan KeepAliveTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
        /// <summary>
        /// Handlers for data from the socket which doesn't need to be forwarded to the caller. Ping or welcome messages for example.
        /// </summary>
@@ -65,7 +86,7 @@ namespace CryptoExchange.Net.Clients
        /// Periodic task registrations
        /// </summary>
        protected List<PeriodicTaskRegistration> PeriodicTaskRegistrations { get; set; } = new List<PeriodicTaskRegistration>();
-
+        
        /// <summary>
        /// List of address to keep an alive connection to
        /// </summary>
@@ -76,30 +97,35 @@ 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
        {
            get
            {
-                if (socketConnections.IsEmpty)
+                if (_socketConnections.IsEmpty)
                    return 0;

-                return socketConnections.Sum(s => s.Value.IncomingKbps);
+                return _socketConnections.Sum(s => s.Value.IncomingKbps);
            }
        }

        /// <inheritdoc />
-        public int CurrentConnections => socketConnections.Count;
+        public int CurrentConnections => _socketConnections.Count;

        /// <inheritdoc />
        public int CurrentSubscriptions
        {
            get
            {
-                if (socketConnections.IsEmpty)
+                if (_socketConnections.IsEmpty)
                    return 0;

-                return socketConnections.Sum(s => s.Value.UserSubscriptionCount);
+                return _socketConnections.Sum(s => s.Value.UserSubscriptionCount);
            }
        }

@@ -109,6 +135,11 @@ namespace CryptoExchange.Net.Clients
        /// <inheritdoc />
        public new SocketApiOptions ApiOptions => (SocketApiOptions)base.ApiOptions;

+        /// <summary>
+        /// The max number of individual subscriptions on a single connection
+        /// </summary>
+        public int? MaxIndividualSubscriptionsPerConnection { get; set; }
+
        #endregion

        /// <summary>
@@ -132,7 +163,7 @@ namespace CryptoExchange.Net.Clients
        /// Create a message accessor instance
        /// </summary>
        /// <returns></returns>
-        protected internal abstract IByteMessageAccessor CreateAccessor();
+        protected internal abstract IByteMessageAccessor CreateAccessor(WebSocketMessageType messageType);

        /// <summary>
        /// Create a serializer instance
@@ -157,7 +188,7 @@ namespace CryptoExchange.Net.Clients
        /// <param name="interval"></param>
        /// <param name="queryDelegate"></param>
        /// <param name="callback"></param>
-        protected virtual void RegisterPeriodicQuery(string identifier, TimeSpan interval, Func<SocketConnection, Query> queryDelegate, Action<SocketConnection, CallResult>? callback)
+        protected virtual void RegisterPeriodicQuery(string identifier, TimeSpan interval, Func<ISocketConnection, Query> queryDelegate, Action<SocketConnection, CallResult>? callback)
        {
            PeriodicTaskRegistrations.Add(new PeriodicTaskRegistration
            {
@@ -197,6 +228,9 @@ namespace CryptoExchange.Net.Clients
                return new CallResult<UpdateSubscription>(new NoApiCredentialsError());
            }

+            if (subscription.IndividualSubscriptionCount > MaxIndividualSubscriptionsPerConnection)
+                return new CallResult<UpdateSubscription>(ArgumentError.Invalid("subscriptions", $"Max number of subscriptions in a single call is {MaxIndividualSubscriptionsPerConnection}"));
+
            SocketConnection socketConnection;
            var released = false;
            // Wait for a semaphore here, so we only connect 1 socket at a time.
@@ -205,9 +239,9 @@ namespace CryptoExchange.Net.Clients
            {
                await semaphoreSlim.WaitAsync(ct).ConfigureAwait(false);
            }
-            catch (OperationCanceledException)
+            catch (OperationCanceledException tce)
            {
-                return new CallResult<UpdateSubscription>(new CancellationRequestedError());
+                return new CallResult<UpdateSubscription>(new CancellationRequestedError(tce));
            }

            try
@@ -215,7 +249,7 @@ namespace CryptoExchange.Net.Clients
                while (true)
                {
                    // Get a new or existing socket connection
-                    var socketResult = await GetSocketConnection(url, subscription.Authenticated, false, subscription.Topic).ConfigureAwait(false);
+                    var socketResult = await GetSocketConnection(url, subscription.Authenticated, false, ct, subscription.Topic, subscription.IndividualSubscriptionCount).ConfigureAwait(false);
                    if (!socketResult)
                        return socketResult.As<UpdateSubscription>(null);

@@ -238,7 +272,7 @@ namespace CryptoExchange.Net.Clients

                    var needsConnecting = !socketConnection.Connected;

-                    var connectResult = await ConnectIfNeededAsync(socketConnection, subscription.Authenticated).ConfigureAwait(false);
+                    var connectResult = await ConnectIfNeededAsync(socketConnection, subscription.Authenticated, ct).ConfigureAwait(false);
                    if (!connectResult)
                        return new CallResult<UpdateSubscription>(connectResult.Error!);

@@ -254,59 +288,164 @@ 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);
+            void HandleSubscriptionComplete(bool success, object? response)
+            {
+                if (!success)
+                    return;
+
+                subscription.HandleSubQueryResponse(response);
+                subscription.Status = SubscriptionStatus.Subscribed;
+                if (ct != default)
+                {
+                    subscription.CancellationTokenRegistration = ct.Register(async () =>
+                    {
+                        _logger.CancellationTokenSetClosingSubscription(socketConnection.SocketId, subscription.Id);
+                        await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
+                    }, false);
+                }
+            }
+
+            subscription.Status = SubscriptionStatus.Subscribing;
+            var subQuery = subscription.CreateSubscriptionQuery(socketConnection);
            if (subQuery != null)
            {
+                subQuery.OnComplete = () => HandleSubscriptionComplete(subQuery.Result?.Success ?? false, subQuery.Response);
+
                // Send the request and wait for answer
-                var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, waitEvent).ConfigureAwait(false);
+                var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, ct).ConfigureAwait(false);
                if (!subResult)
                {
-                    waitEvent?.Set();
                    var isTimeout = subResult.Error is CancellationRequestedError;
-                    if (isTimeout && subscription.Confirmed)
+                    if (isTimeout && subscription.Status == SubscriptionStatus.Subscribed)
                    {
                        // No response received, but the subscription did receive updates. We'll assume success
                    }
                    else
                    {
                        _logger.FailedToSubscribe(socketConnection.SocketId, subResult.Error?.ToString());
-                        // If this was a timeout we still need to send an unsubscribe to prevent messages coming in later
+                        // If this was a server process error we still might need to send an unsubscribe to prevent messages coming in later
+                        subscription.Status = SubscriptionStatus.Pending;
                        await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
                        return new CallResult<UpdateSubscription>(subResult.Error!);
                    }
                }
-
-                subscription.HandleSubQueryResponse(subQuery.Response!);
+            }
+            else 
+            {
+                HandleSubscriptionComplete(true, null);
+            }
+
+            _logger.SubscriptionCompletedSuccessfully(socketConnection.SocketId, subscription.Id);
+            return new CallResult<UpdateSubscription>(new UpdateSubscription(socketConnection, subscription));
+        }
+
+        /// <summary>
+        /// Connect to an url and listen for data
+        /// </summary>
+        /// <param name="url">The URL to connect to</param>
+        /// <param name="subscription">The subscription</param>
+        /// <param name="connectionFactory">The factory for creating a socket connection</param>
+        /// <param name="ct">Cancellation token for closing this subscription</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<HighPerfUpdateSubscription>> SubscribeHighPerfAsync<TUpdateType>(
+            string url,
+            HighPerfSubscription<TUpdateType> subscription,
+            IHighPerfConnectionFactory connectionFactory,
+            CancellationToken ct)
+        {
+            if (_disposing)
+                return new CallResult<HighPerfUpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
+
+            HighPerfSocketConnection<TUpdateType> socketConnection;
+            var released = false;
+            // Wait for a semaphore here, so we only connect 1 socket at a time.
+            // This is necessary for being able to see if connections can be combined
+            try
+            {
+                await semaphoreSlim.WaitAsync(ct).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException tce)
+            {
+                return new CallResult<HighPerfUpdateSubscription>(new CancellationRequestedError(tce));
+            }
+
+            try
+            {
+                while (true)
+                {
+                    // Get a new or existing socket connection
+                    var socketResult = await GetHighPerfSocketConnection<TUpdateType>(url, connectionFactory, ct).ConfigureAwait(false);
+                    if (!socketResult)
+                        return socketResult.As<HighPerfUpdateSubscription>(null);
+
+                    socketConnection = socketResult.Data;
+
+                    // Add a subscription on the socket connection
+                    var success = socketConnection.AddSubscription(subscription);
+                    if (!success)
+                    {
+                        _logger.FailedToAddSubscriptionRetryOnDifferentConnection(socketConnection.SocketId);
+                        continue;
+                    }
+
+                    if (ClientOptions.SocketSubscriptionsCombineTarget == 1)
+                    {
+                        // Only 1 subscription per connection, so no need to wait for connection since a new subscription will create a new connection anyway
+                        semaphoreSlim.Release();
+                        released = true;
+                    }
+
+                    var needsConnecting = !socketConnection.Connected;
+
+                    var connectResult = await ConnectIfNeededAsync(socketConnection, false, ct).ConfigureAwait(false);
+                    if (!connectResult)
+                        return new CallResult<HighPerfUpdateSubscription>(connectResult.Error!);
+
+                    break;
+                }
+            }
+            finally
+            {
+                if (!released)
+                    semaphoreSlim.Release();
+            }
+
+            var subRequest = subscription.CreateSubscriptionQuery(socketConnection);
+            if (subRequest != null)
+            {
+                // Send the request and wait for answer
+                var sendResult = await socketConnection.SendAsync(subRequest).ConfigureAwait(false);
+                if (!sendResult)
+                {
+                    await socketConnection.CloseAsync().ConfigureAwait(false);
+                    return new CallResult<HighPerfUpdateSubscription>(sendResult.Error!);                    
+                }
            }

-            subscription.Confirmed = true;
            if (ct != default)
            {
                subscription.CancellationTokenRegistration = ct.Register(async () =>
                {
                    _logger.CancellationTokenSetClosingSubscription(socketConnection.SocketId, subscription.Id);
-                    await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
+                    await socketConnection.CloseAsync().ConfigureAwait(false);
                }, false);
            }

-            waitEvent?.Set();
            _logger.SubscriptionCompletedSuccessfully(socketConnection.SocketId, subscription.Id);
-            return new CallResult<UpdateSubscription>(new UpdateSubscription(socketConnection, subscription));
+            return new CallResult<HighPerfUpdateSubscription>(new HighPerfUpdateSubscription(socketConnection, subscription));
        }

        /// <summary>
        /// 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);
        }
@@ -315,12 +454,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"));
@@ -333,7 +471,7 @@ namespace CryptoExchange.Net.Clients
            await semaphoreSlim.WaitAsync().ConfigureAwait(false);
            try
            {
-                var socketResult = await GetSocketConnection(url, query.Authenticated, true).ConfigureAwait(false);
+                var socketResult = await GetSocketConnection(url, query.Authenticated, true, ct).ConfigureAwait(false);
                if (!socketResult)
                    return socketResult.As<THandlerResponse>(default);

@@ -346,7 +484,7 @@ namespace CryptoExchange.Net.Clients
                    released = true;
                }

-                var connectResult = await ConnectIfNeededAsync(socketConnection, query.Authenticated).ConfigureAwait(false);
+                var connectResult = await ConnectIfNeededAsync(socketConnection, query.Authenticated, ct).ConfigureAwait(false);
                if (!connectResult)
                    return new CallResult<THandlerResponse>(connectResult.Error!);
            }
@@ -359,13 +497,13 @@ 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)
                return new CallResult<THandlerResponse>(new CancellationRequestedError());

-            return await socketConnection.SendAndWaitQueryAsync(query, null, ct).ConfigureAwait(false);
+            return await socketConnection.SendAndWaitQueryAsync(query, ct).ConfigureAwait(false);
        }

        /// <summary>
@@ -373,13 +511,14 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        /// <param name="socket">The connection to check</param>
        /// <param name="authenticated">Whether the socket should authenticated</param>
+        /// <param name="ct">Cancellation token</param>
        /// <returns></returns>
-        protected virtual async Task<CallResult> ConnectIfNeededAsync(SocketConnection socket, bool authenticated)
+        protected virtual async Task<CallResult> ConnectIfNeededAsync(ISocketConnection socket, bool authenticated, CancellationToken ct)
        {
            if (socket.Connected)
                return CallResult.SuccessResult;

-            var connectResult = await ConnectSocketAsync(socket).ConfigureAwait(false);
+            var connectResult = await ConnectSocketAsync(socket, ct).ConfigureAwait(false);
            if (!connectResult)
                return connectResult;

@@ -389,7 +528,10 @@ namespace CryptoExchange.Net.Clients
            if (!authenticated || socket.Authenticated)
                return CallResult.SuccessResult;

-            var result = await AuthenticateSocketAsync(socket).ConfigureAwait(false);
+            if (socket is not SocketConnection sc)
+                throw new InvalidOperationException("HighPerfSocketConnection not supported for authentication");
+
+            var result = await AuthenticateSocketAsync(sc).ConfigureAwait(false);
            if (!result)
                await socket.CloseAsync().ConfigureAwait(false);

@@ -442,7 +584,7 @@ namespace CryptoExchange.Net.Clients
        protected void AddSystemSubscription(SystemSubscription systemSubscription)
        {
            systemSubscriptions.Add(systemSubscription);
-            foreach (var connection in socketConnections.Values)
+            foreach (var connection in _socketConnections.Values)
                connection.AddSubscription(systemSubscription);
        }

@@ -462,7 +604,7 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        /// <param name="connection"></param>
        /// <returns></returns>
-        protected internal virtual Task<Uri?> GetReconnectUriAsync(SocketConnection connection)
+        protected internal virtual Task<Uri?> GetReconnectUriAsync(ISocketConnection connection)
        {
            return Task.FromResult<Uri?>(connection.ConnectionUri);
        }
@@ -483,37 +625,91 @@ namespace CryptoExchange.Net.Clients
        /// <param name="address">The address the socket is for</param>
        /// <param name="authenticated">Whether the socket should be authenticated</param>
        /// <param name="dedicatedRequestConnection">Whether a dedicated request connection should be returned</param>
+        /// <param name="ct">Cancellation token</param>
        /// <param name="topic">The subscription topic, can be provided when multiple of the same topics are not allowed on a connection</param>
+        /// <param name="individualSubscriptionCount">The number of individual subscriptions in this subscribe request</param>
        /// <returns></returns>
-        protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(string address, bool authenticated, bool dedicatedRequestConnection, string? topic = null)
+        protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(
+            string address,
+            bool authenticated,
+            bool dedicatedRequestConnection, 
+            CancellationToken ct,
+            string? topic = null,
+            int individualSubscriptionCount = 1)
        {
-            var socketQuery = socketConnections.Where(s => (s.Value.Status == SocketConnection.SocketStatus.None || s.Value.Status == SocketConnection.SocketStatus.Connected)
-                                                      && s.Value.Tag.TrimEnd('/') == address.TrimEnd('/')
+            var socketQuery = _socketConnections.Where(s => s.Value.Tag.TrimEnd('/') == address.TrimEnd('/')
                                                      && s.Value.ApiClient.GetType() == GetType()
-                                                      && (s.Value.Authenticated == authenticated || !authenticated)
-                                                      && (AllowTopicsOnTheSameConnection || !s.Value.Topics.Contains(topic))
-                                                      && s.Value.Connected);
+                                                      && (AllowTopicsOnTheSameConnection || !s.Value.Topics.Contains(topic)))
+                                                .Select(x => x.Value)
+                                                .ToList();

-            SocketConnection connection;
+            // If all current socket connections are reconnecting or resubscribing wait for that to finish as we can probably use the existing connection
+            var delayStart = DateTime.UtcNow;
+            var delayed = false;
+            while (socketQuery.Count >= 1 && socketQuery.All(x => x.Status == SocketStatus.Reconnecting || x.Status == SocketStatus.Resubscribing))
+            {
+                if (DateTime.UtcNow - delayStart > TimeSpan.FromSeconds(10))
+                {
+                    if (socketQuery.Count >= 1 && socketQuery.All(x => x.Status == SocketStatus.Reconnecting || x.Status == SocketStatus.Resubscribing))
+                    {
+                        // If after this time we still trying to reconnect/reprocess there is some issue in the connection
+                        _logger.TimeoutWaitingForReconnectingSocket();
+                        return new CallResult<SocketConnection>(new CantConnectError());
+                    }
+
+                    break;
+                }
+
+                delayed = true;
+                try { await Task.Delay(50, ct).ConfigureAwait(false); } catch (Exception) { }
+
+                if (ct.IsCancellationRequested)
+                    return new CallResult<SocketConnection>(new CancellationRequestedError());
+            }
+
+            if (delayed)
+                _logger.WaitedForReconnectingSocket((long)(DateTime.UtcNow - delayStart).TotalMilliseconds);
+
+            socketQuery = socketQuery.Where(s => (s.Status == SocketStatus.None || s.Status == SocketStatus.Connected)                                                     
+                                                && (s.Authenticated == authenticated || !authenticated)
+                                                && s.Connected).ToList();
+
+            SocketConnection? connection;
            if (!dedicatedRequestConnection)
            {
-                connection = socketQuery.Where(s => !s.Value.DedicatedRequestConnection.IsDedicatedRequestConnection).OrderBy(s => s.Value.UserSubscriptionCount).FirstOrDefault().Value;
+                connection = socketQuery.Where(s => !s.DedicatedRequestConnection.IsDedicatedRequestConnection).OrderBy(s => s.UserSubscriptionCount).FirstOrDefault();
            }
            else
            {
-                connection = socketQuery.Where(s => s.Value.DedicatedRequestConnection.IsDedicatedRequestConnection).FirstOrDefault().Value;
+                connection = socketQuery.Where(s => s.DedicatedRequestConnection.IsDedicatedRequestConnection).FirstOrDefault();
                if (connection != null && !connection.DedicatedRequestConnection.Authenticated)
                    // Mark dedicated request connection as authenticated if the request is authenticated
                    connection.DedicatedRequestConnection.Authenticated = authenticated;
            }

+            bool maxConnectionsReached = _socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections);
            if (connection != null)
            {
-                if (connection.UserSubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget || (socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections) && socketConnections.All(s => s.Value.UserSubscriptionCount >= ClientOptions.SocketSubscriptionsCombineTarget)))
+                bool lessThanBatchSubCombineTarget = connection.UserSubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget;
+                bool lessThanIndividualSubCombineTarget = connection.Subscriptions.Sum(x => x.IndividualSubscriptionCount) < ClientOptions.SocketIndividualSubscriptionCombineTarget;
+
+                if ((lessThanBatchSubCombineTarget && lessThanIndividualSubCombineTarget)
+                    || maxConnectionsReached) 
+                {
                    // Use existing socket if it has less than target connections OR it has the least connections and we can't make new
-                    return new CallResult<SocketConnection>(connection);
+                    // If there is a max subscriptions per connection limit also only use existing if the new subscription doesn't go over the limit
+                    if (MaxIndividualSubscriptionsPerConnection == null)
+                        return new CallResult<SocketConnection>(connection);
+                                        
+                    var currentCount = connection.Subscriptions.Sum(x => x.IndividualSubscriptionCount);
+                    if (currentCount + individualSubscriptionCount <= MaxIndividualSubscriptionsPerConnection)
+                        return new CallResult<SocketConnection>(connection);
+                }
            }

+            if (maxConnectionsReached)
+                return new CallResult<SocketConnection>(new InvalidOperationError("Max amount of socket connections reached"));
+
            var connectionAddress = await GetConnectionUrlAsync(address, authenticated).ConfigureAwait(false);
            if (!connectionAddress)
            {
@@ -524,9 +720,8 @@ namespace CryptoExchange.Net.Clients
            if (connectionAddress.Data != address)
                _logger.ConnectionAddressSetTo(connectionAddress.Data!);

-            // Create new socket
-            var socket = CreateSocket(connectionAddress.Data!);
-            var socketConnection = new SocketConnection(_logger, this, socket, address);
+            // Create new socket connection
+            var socketConnection = new SocketConnection(_logger, SocketFactory, GetWebSocketParameters(connectionAddress.Data!), this, address);
            socketConnection.UnhandledMessage += HandleUnhandledMessage;
            socketConnection.ConnectRateLimitedAsync += HandleConnectRateLimitedAsync;
            if (dedicatedRequestConnection)
@@ -547,6 +742,38 @@ namespace CryptoExchange.Net.Clients
            return new CallResult<SocketConnection>(socketConnection);
        }

+
+        /// <summary>
+        /// Gets a connection for a new subscription or query. Can be an existing if there are open position or a new one.
+        /// </summary>
+        /// <param name="address">The address the socket is for</param>
+        /// <param name="connectionFactory">The factory for creating a socket connection</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<HighPerfSocketConnection<TUpdateType>>> GetHighPerfSocketConnection<TUpdateType>(
+            string address,
+            IHighPerfConnectionFactory connectionFactory,
+            CancellationToken ct)
+        {
+            var connectionAddress = await GetConnectionUrlAsync(address, false).ConfigureAwait(false);
+            if (!connectionAddress)
+            {
+                _logger.FailedToDetermineConnectionUrl(connectionAddress.Error?.ToString());
+                return connectionAddress.As<HighPerfSocketConnection<TUpdateType>>(null);
+            }
+
+            if (connectionAddress.Data != address)
+                _logger.ConnectionAddressSetTo(connectionAddress.Data!);
+
+            // Create new socket connection
+            var socketConnection = connectionFactory.CreateHighPerfConnection<TUpdateType>(_logger, SocketFactory, GetWebSocketParameters(connectionAddress.Data!), this, address);
+            foreach (var ptg in PeriodicTaskRegistrations)
+                socketConnection.QueryPeriodic(ptg.Identifier, ptg.Interval, (con) => ptg.QueryDelegate(con).Request);
+
+            return new CallResult<HighPerfSocketConnection<TUpdateType>>(socketConnection);
+        }
+
+
        /// <summary>
        /// Process an unhandled message
        /// </summary>
@@ -560,11 +787,12 @@ namespace CryptoExchange.Net.Clients
        /// </summary>
        protected async virtual Task HandleConnectRateLimitedAsync()
        {
-            if (ClientOptions.RateLimiterEnabled && RateLimiter is not null && ClientOptions.ConnectDelayAfterRateLimited is not null)
+            if (ClientOptions.RateLimiterEnabled && ClientOptions.ConnectDelayAfterRateLimited.HasValue)
            {
                var retryAfter = DateTime.UtcNow.Add(ClientOptions.ConnectDelayAfterRateLimited.Value);
                _logger.AddingRetryAfterGuard(retryAfter);
-                await RateLimiter.SetRetryAfterGuardAsync(retryAfter, RateLimiting.RateLimitItemType.Connection).ConfigureAwait(false);
+                RateLimiter ??= new RateLimitGate("Connection");
+                await RateLimiter.SetRetryAfterGuardAsync(retryAfter, RateLimitItemType.Connection).ConfigureAwait(false);
            }
        }

@@ -572,13 +800,17 @@ namespace CryptoExchange.Net.Clients
        /// Connect a socket
        /// </summary>
        /// <param name="socketConnection">The socket to connect</param>
+        /// <param name="ct">Cancellation token</param>
        /// <returns></returns>
-        protected virtual async Task<CallResult> ConnectSocketAsync(SocketConnection socketConnection)
+        protected virtual async Task<CallResult> ConnectSocketAsync(ISocketConnection socketConnection, CancellationToken ct)
        {
-            var connectResult = await socketConnection.ConnectAsync().ConfigureAwait(false);
+            var connectResult = await socketConnection.ConnectAsync(ct).ConfigureAwait(false);
            if (connectResult)
            {
-                socketConnections.TryAdd(socketConnection.SocketId, socketConnection);
+                if (socketConnection is SocketConnection sc)
+                    _socketConnections.TryAdd(socketConnection.SocketId, sc);
+                else if (socketConnection is HighPerfSocketConnection hsc)
+                    _highPerfSocketConnections.TryAdd(socketConnection.SocketId, hsc);
                return connectResult;
            }

@@ -595,26 +827,16 @@ namespace CryptoExchange.Net.Clients
            => new(new Uri(address), ClientOptions.ReconnectPolicy)
            {
                KeepAliveInterval = KeepAliveInterval,
+                KeepAliveTimeout = KeepAliveTimeout,
                ReconnectInterval = ClientOptions.ReconnectInterval,
                RateLimiter = ClientOptions.RateLimiterEnabled ? RateLimiter : null,
                RateLimitingBehavior = ClientOptions.RateLimitingBehaviour,
                Proxy = ClientOptions.Proxy,
                Timeout = ApiOptions.SocketNoDataTimeout ?? ClientOptions.SocketNoDataTimeout,
                ReceiveBufferSize = ClientOptions.ReceiveBufferSize,
+                UseUpdatedDeserialization = ClientOptions.UseUpdatedDeserialization
            };

-        /// <summary>
-        /// Create a socket for an address
-        /// </summary>
-        /// <param name="address">The address the socket should connect to</param>
-        /// <returns></returns>
-        protected virtual IWebsocket CreateSocket(string address)
-        {
-            var socket = SocketFactory.CreateWebsocket(_logger, GetWebSocketParameters(address));
-            _logger.SocketCreatedForAddress(socket.Id, address);
-            return socket;
-        }
-
        /// <summary>
        /// Unsubscribe an update subscription
        /// </summary>
@@ -624,7 +846,7 @@ namespace CryptoExchange.Net.Clients
        {
            Subscription? subscription = null;
            SocketConnection? connection = null;
-            foreach (var socket in socketConnections.Values.ToList())
+            foreach (var socket in _socketConnections.Values.ToList())
            {
                subscription = socket.GetSubscription(subscriptionId);
                if (subscription != null)
@@ -662,21 +884,25 @@ namespace CryptoExchange.Net.Clients
        /// <returns></returns>
        public virtual async Task UnsubscribeAllAsync()
        {
-            var sum = socketConnections.Sum(s => s.Value.UserSubscriptionCount);
+            var sum = _socketConnections.Sum(s => s.Value.UserSubscriptionCount) + _highPerfSocketConnections.Sum(s => s.Value.UserSubscriptionCount);
            if (sum == 0)
                return;

-            _logger.UnsubscribingAll(socketConnections.Sum(s => s.Value.UserSubscriptionCount));
+            _logger.UnsubscribingAll(sum);
            var tasks = new List<Task>();
+            
+            var socketList = _socketConnections.Values;
+            foreach (var connection in socketList)
            {
-                var socketList = socketConnections.Values;
-                foreach (var connection in socketList)
-                {
-                    foreach(var subscription in connection.Subscriptions.Where(x => x.UserSubscription))
-                        tasks.Add(connection.CloseAsync(subscription));
-                }
+                foreach(var subscription in connection.Subscriptions.Where(x => x.UserSubscription))
+                    tasks.Add(connection.CloseAsync(subscription));
            }

+            var highPerfSocketList = _highPerfSocketConnections.Values;
+            foreach (var connection in highPerfSocketList)
+                tasks.Add(connection.CloseAsync());
+            
+
            await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
        }

@@ -686,10 +912,10 @@ namespace CryptoExchange.Net.Clients
        /// <returns></returns>
        public virtual async Task ReconnectAsync()
        {
-            _logger.ReconnectingAllConnections(socketConnections.Count);
+            _logger.ReconnectingAllConnections(_socketConnections.Count);
            var tasks = new List<Task>();
            {
-                var socketList = socketConnections.Values;
+                var socketList = _socketConnections.Values;
                foreach (var sub in socketList)
                    tasks.Add(sub.TriggerReconnectAsync());
            }
@@ -702,11 +928,11 @@ namespace CryptoExchange.Net.Clients
        {
            foreach (var item in DedicatedConnectionConfigs)
            {
-                var socketResult = await GetSocketConnection(item.SocketAddress, item.Authenticated, true).ConfigureAwait(false);
+                var socketResult = await GetSocketConnection(item.SocketAddress, item.Authenticated, true, CancellationToken.None).ConfigureAwait(false);
                if (!socketResult)
                    return socketResult.AsDataless();

-                var connectResult = await ConnectIfNeededAsync(socketResult.Data, item.Authenticated).ConfigureAwait(false);
+                var connectResult = await ConnectIfNeededAsync(socketResult.Data, item.Authenticated, default).ConfigureAwait(false);
                if (!connectResult)
                    return new CallResult(connectResult.Error!);
            }
@@ -721,7 +947,7 @@ namespace CryptoExchange.Net.Clients
            base.SetOptions(options);

            if ((!previousProxyIsSet && options.Proxy == null)
-                || socketConnections.IsEmpty)
+                || _socketConnections.IsEmpty)
            {
                return;
            }
@@ -729,7 +955,7 @@ namespace CryptoExchange.Net.Clients
            _logger.LogInformation("Reconnecting websockets to apply proxy");

            // Update proxy, also triggers reconnect
-            foreach (var connection in socketConnections)
+            foreach (var connection in _socketConnections)
                _ = connection.Value.UpdateProxy(options.Proxy);
        }

@@ -748,15 +974,15 @@ namespace CryptoExchange.Net.Clients
        /// <returns></returns>
        public SocketApiClientState GetState(bool includeSubDetails = true)
        {
-            var connectionStates = new List<SocketConnection.SocketConnectionState>();
-            foreach (var socketIdAndConnection in socketConnections)
+            var connectionStates = new List<SocketConnectionState>();
+            foreach (var socketIdAndConnection in _socketConnections)
            {
                SocketConnection connection = socketIdAndConnection.Value;
-                SocketConnection.SocketConnectionState connectionState = connection.GetState(includeSubDetails);
+                SocketConnectionState connectionState = connection.GetState(includeSubDetails);
                connectionStates.Add(connectionState);
            }

-            return new SocketApiClientState(socketConnections.Count, CurrentSubscriptions, IncomingKbps, connectionStates);
+            return new SocketApiClientState(_socketConnections.Count, CurrentSubscriptions, IncomingKbps, connectionStates);
        }

        /// <summary>
@@ -770,7 +996,7 @@ namespace CryptoExchange.Net.Clients
            int Connections,
            int Subscriptions,
            double DownloadSpeed,
-            List<SocketConnection.SocketConnectionState> ConnectionStates)
+            List<SocketConnectionState> ConnectionStates)
        {
            /// <summary>
            /// Print the state of the client
@@ -799,9 +1025,9 @@ namespace CryptoExchange.Net.Clients
                        cs.SubscriptionStates.ForEach(subState =>
                        {
                            sb.AppendLine($"\t\t\tId: {subState.Id}");
-                            sb.AppendLine($"\t\t\tConfirmed: {subState.Confirmed}");
+                            sb.AppendLine($"\t\t\tStatus: {subState.Status}");
                            sb.AppendLine($"\t\t\tInvocations: {subState.Invocations}");
-                            sb.AppendLine($"\t\t\tIdentifiers: [{string.Join(",", subState.Identifiers)}]");
+                            sb.AppendLine($"\t\t\tIdentifiers: [{subState.ListenMatcher.ToString()}]");
                        });
                    }
                });
@@ -818,7 +1044,7 @@ namespace CryptoExchange.Net.Clients
            _disposing = true;
            var tasks = new List<Task>();
            {
-                var socketList = socketConnections.Values.Where(x => x.UserSubscriptionCount > 0 || x.Connected);
+                var socketList = _socketConnections.Values.Where(x => x.UserSubscriptionCount > 0 || x.Connected);
                if (socketList.Any())
                    _logger.DisposingSocketClient();

@@ -842,10 +1068,16 @@ namespace CryptoExchange.Net.Clients
        /// <summary>
        /// Preprocess a stream message
        /// </summary>
-        /// <param name="connection"></param>
-        /// <param name="type"></param>
-        /// <param name="data"></param>
-        /// <returns></returns>
+        public virtual ReadOnlySpan<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlySpan<byte> data) => data;
+        /// <summary>
+        /// Preprocess a stream message
+        /// </summary>
        public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
+
+        /// <summary>
+        /// Create a new message converter instance
+        /// </summary>
+        /// <returns></returns>
+        public abstract ISocketMessageHandler CreateMessageConverter(WebSocketMessageType messageType);
    }
 }
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Concurrent;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters
+{
+    /// <summary>
+    /// Caching for JsonSerializerContext instances
+    /// </summary>
+    public static class JsonSerializerContextCache
+    {
+        private static ConcurrentDictionary<Type, JsonSerializerContext> _cache = new ConcurrentDictionary<Type, JsonSerializerContext>();
+
+        /// <summary>
+        /// Get the instance of the provided type T. It will be created if it doesn't exist yet.
+        /// </summary>
+        /// <typeparam name="T">Implementation type of the JsonSerializerContext</typeparam>
+        public static JsonSerializerContext GetOrCreate<T>() where T: JsonSerializerContext, new()
+        {
+            var contextType = typeof(T);
+            if (_cache.TryGetValue(contextType, out var context))
+                return context;
+
+            var instance = new T();
+            _cache[contextType] = instance;
+            return instance;
+        }
+    }
+}
@@ -0,0 +1,64 @@
+using CryptoExchange.Net.Objects;
+using System.IO;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// REST message handler
+    /// </summary>
+    public interface IRestMessageHandler
+    {
+        /// <summary>
+        /// The `accept` HTTP response header for the request
+        /// </summary>
+        MediaTypeWithQualityHeaderValue AcceptHeader { get; }
+
+        /// <summary>
+        /// Whether a seekable stream is required
+        /// </summary>
+        bool RequiresSeekableStream { get; }
+
+        /// <summary>
+        /// Parse the response when the HTTP response status indicated an error
+        /// </summary>
+        ValueTask<Error> ParseErrorResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <summary>
+        /// Parse the response when the HTTP response status indicated a rate limit error
+        /// </summary>
+        ValueTask<ServerRateLimitError> ParseErrorRateLimitResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <summary>
+        /// Check if the response is an error response; if so return the error.<br />
+        /// Note that if the API returns a standard result wrapper, something like this:
+        /// <code>{ "code": 400, "msg": "error", "data": {} }</code> 
+        /// then the `CheckDeserializedResponse` method should be used for checking the result
+        /// </summary>
+        ValueTask<Error?> CheckForErrorResponse(
+            RequestDefinition request,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <summary>
+        /// Deserialize the response stream
+        /// </summary>
+        ValueTask<(T? Result, Error? Error)> TryDeserializeAsync<T>(
+            Stream responseStream,
+            CancellationToken ct);
+
+        /// <summary>
+        /// Check whether the resulting T object indicates an error or not
+        /// </summary>
+        Error? CheckDeserializedResponse<T>(HttpResponseHeaders responseHeaders, T result);
+    }
+
+}
@@ -0,0 +1,27 @@
+using System;
+using System.Net.WebSockets;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// WebSocket message handler
+    /// </summary>
+    public interface ISocketMessageHandler
+    {
+        /// <summary>
+        /// Get an identifier for the message which can be used to determine the type of the message
+        /// </summary>
+        string? GetTypeIdentifier(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType);
+
+        /// <summary>
+        /// Get optional topic filter, for example a symbol name
+        /// </summary>
+        string? GetTopicFilter(object deserializedObject);
+
+        /// <summary>
+        /// Deserialize to the provided type
+        /// </summary>
+        object Deserialize(ReadOnlySpan<byte> data, Type type);
+    }
+
+}
@@ -0,0 +1,46 @@
+using System;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// Message type definition
+    /// </summary>
+    public class MessageTypeDefinition
+    {
+        /// <summary>
+        /// Whether to immediately select the definition when it is matched. Can only be used when the evaluator has a single unique field to look for
+        /// </summary>
+        public bool ForceIfFound { get; set; }
+        /// <summary>
+        /// The fields a message needs to contain for this definition
+        /// </summary>
+        public MessageFieldReference[] Fields { get; set; } = [];
+        /// <summary>
+        /// The callback for getting the identifier string
+        /// </summary>
+        public Func<SearchResult, string>? TypeIdentifierCallback { get; set; }
+        /// <summary>
+        /// The static identifier string to return when this evaluator is matched
+        /// </summary>
+        public string? StaticIdentifier { get; set; }
+        
+        internal string? GetMessageType(SearchResult result)
+        {
+            if (StaticIdentifier != null)
+                return StaticIdentifier;
+
+            return TypeIdentifierCallback!(result);
+        }
+
+        internal bool Satisfied(SearchResult result)
+        {
+            foreach(var field in Fields)
+            {
+                if (!result.Contains(field))
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}
@@ -0,0 +1,15 @@
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    internal class MessageEvalutorFieldReference
+    {
+        public bool SkipReading { get; set; }
+        public bool OverlappingField { get; set; }
+        public MessageFieldReference Field { get; set; }
+        public MessageTypeDefinition? ForceEvaluator { get; set; }
+
+        public MessageEvalutorFieldReference(MessageFieldReference field)
+        {
+            Field = field;
+        }
+    }
+}
@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// Reference to a message field
+    /// </summary>
+    public abstract class MessageFieldReference
+    {
+        /// <summary>
+        /// The name for this search field
+        /// </summary>
+        public string SearchName { get; set; }
+        /// <summary>
+        /// The depth at which to look for this field
+        /// </summary>
+        public int Depth { get; set; } = 1;
+        /// <summary>
+        /// Callback to check if the field value matches an expected constraint
+        /// </summary>
+        public Func<string?, bool>? Constraint { get; private set; }
+
+        /// <summary>
+        /// Check whether the value is one of the string values in the set
+        /// </summary>
+        public MessageFieldReference WithFilterConstraint(HashSet<string?> set)
+        {
+            Constraint = set.Contains;
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value is equal to a string
+        /// </summary>
+        public MessageFieldReference WithEqualConstraint(string compare)
+        {
+            Constraint = x => x != null && x.Equals(compare, StringComparison.Ordinal);
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value is not equal to a string
+        /// </summary>
+        public MessageFieldReference WithNotEqualConstraint(string compare)
+        {
+            Constraint = x => x == null || !x.Equals(compare, StringComparison.Ordinal);
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value is not null
+        /// </summary>
+        public MessageFieldReference WithNotNullConstraint()
+        {
+            Constraint = x => x != null;
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value starts with a certain string
+        /// </summary>
+        public MessageFieldReference WithStartsWithConstraint(string start)
+        {
+            Constraint = x => x != null && x.StartsWith(start, StringComparison.Ordinal);
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value starts with a certain string
+        /// </summary>
+        public MessageFieldReference WithStartsWithConstraints(params string[] startValues)
+        {
+            Constraint = x =>
+            {
+                if (x == null)
+                    return false;
+
+                foreach (var item in startValues)
+                {
+                    if (x!.StartsWith(item, StringComparison.Ordinal))
+                        return true;
+                }
+
+                return false;
+            };
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value starts with a certain string
+        /// </summary>
+        public MessageFieldReference WithCustomConstraint(Func<string?, bool> constraint)
+        {
+            Constraint = constraint;
+            return this;
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public MessageFieldReference(string searchName)
+        {
+            SearchName = searchName;
+        }
+    }
+
+    /// <summary>
+    /// Reference to a property message field
+    /// </summary>
+    public class PropertyFieldReference : MessageFieldReference
+    {
+        /// <summary>
+        /// The property name in the JSON
+        /// </summary>
+        public byte[] PropertyName { get; set; }
+        /// <summary>
+        /// Whether the property value is array values
+        /// </summary>
+        public bool ArrayValues { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public PropertyFieldReference(string propertyName) : base(propertyName)
+        {
+            PropertyName = Encoding.UTF8.GetBytes(propertyName);
+        }
+    }
+
+    /// <summary>
+    /// Reference to an array message field
+    /// </summary>
+    public class ArrayFieldReference : MessageFieldReference
+    {
+        /// <summary>
+        /// The index in the array
+        /// </summary>
+        public int ArrayIndex { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ArrayFieldReference(string searchName, int depth, int index) : base(searchName)
+        {
+            Depth = depth;
+            ArrayIndex = index;
+        }
+    }
+
+}
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// The results of a search for fields in a JSON message
+    /// </summary>
+    public class SearchResult
+    {
+        private List<SearchResultItem> _items = new List<SearchResultItem>();
+
+        /// <summary>
+        /// Get the value of a field
+        /// </summary>
+        public string? FieldValue(string searchName)
+        {
+            foreach (var item in _items)
+            {
+                if (item.Field.SearchName.Equals(searchName, StringComparison.Ordinal))
+                    return item.Value;
+            }
+
+            throw new Exception($"No field value found for {searchName}");
+        }
+
+        /// <summary>
+        /// The number of found search field values
+        /// </summary>
+        public int Count => _items.Count;
+
+        /// <summary>
+        /// Clear the search result
+        /// </summary>
+        public void Clear() => _items.Clear();
+
+        /// <summary>
+        /// Whether the value for a specific field was found
+        /// </summary>
+        public bool Contains(MessageFieldReference field)
+        {
+            foreach (var item in _items)
+            {
+                if (item.Field == field)
+                    return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Write a value to the result
+        /// </summary>
+        public void Write(MessageFieldReference field, string? value) => _items.Add(new SearchResultItem
+        {
+            Field = field,
+            Value = value
+        });
+    }
+}
@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// Search result value
+    /// </summary>
+    public struct SearchResultItem
+    {
+        /// <summary>
+        /// The field the values is for
+        /// </summary>
+        public MessageFieldReference Field { get; set; }
+        /// <summary>
+        /// The value of the field
+        /// </summary>
+        public string? Value { get; set; }
+    }
+}
@@ -1,13 +1,13 @@
-using System;
-using System.Collections.Concurrent;
+using CryptoExchange.Net.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
-using System.Text.Json.Serialization;
 using System.Text.Json;
-using CryptoExchange.Net.Attributes;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+using System.Threading;

 namespace CryptoExchange.Net.Converters.SystemTextJson
 {
@@ -16,13 +16,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
    /// with [ArrayProperty(x)] where x is the index of the property in the array
    /// </summary>
 #if NET5_0_OR_GREATER
-    public class ArrayConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TContext> : JsonConverter<T> where T : new() where TContext: JsonSerializerContext
-# else
-    public class ArrayConverter<T, TContext> : JsonConverter<T> where T : new() where TContext: JsonSerializerContext
+    public class ArrayConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T> : JsonConverter<T> where T : new()
+#else
+    public class ArrayConverter<T> : JsonConverter<T> where T : new()
 #endif
    {
-        private static readonly ConcurrentDictionary<Type, List<ArrayPropertyInfo>> _typeAttributesCache = new ConcurrentDictionary<Type, List<ArrayPropertyInfo>>();
-        private static readonly ConcurrentDictionary<JsonConverter, JsonSerializerOptions> _converterOptionsCache = new ConcurrentDictionary<JsonConverter, JsonSerializerOptions>();
+        private static SortedDictionary<int, List<ArrayPropertyInfo>>? _typePropertyInfo;

        /// <inheritdoc />
 #if NET5_0_OR_GREATER
@@ -37,58 +36,59 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                return;
            }

+            if (_typePropertyInfo == null)
+                _typePropertyInfo = CacheTypeAttributes();
+
            writer.WriteStartArray();
-
-            var valueType = typeof(T);
-            if (!_typeAttributesCache.TryGetValue(valueType, out var typeAttributes))
-                typeAttributes = CacheTypeAttributes(valueType);
-
-            var ordered = typeAttributes.Where(x => x.ArrayProperty != null).OrderBy(p => p.ArrayProperty.Index);
            var last = -1;
-            foreach (var prop in ordered)
+            foreach (var indexProps in _typePropertyInfo)
            {
-                if (prop.ArrayProperty.Index == last)
-                    continue;
-
-                while (prop.ArrayProperty.Index != last + 1)
+                foreach (var prop in indexProps.Value)
                {
-                    writer.WriteNullValue();
-                    last += 1;
-                }
+                    if (prop.ArrayProperty.Index == last)
+                        // Don't write the same index twice
+                        continue;

-                last = prop.ArrayProperty.Index;
-
-                var objValue = prop.PropertyInfo.GetValue(value);
-                if (objValue == null)
-                {
-                    writer.WriteNullValue();
-                    continue;
-                }
-
-                JsonSerializerOptions? typeOptions = null;
-                if (prop.JsonConverter != null)
-                {
-                    typeOptions = new JsonSerializerOptions
+                    while (prop.ArrayProperty.Index != last + 1)
                    {
-                        NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals,
-                        PropertyNameCaseInsensitive = false,
-                        TypeInfoResolver = (TContext)Activator.CreateInstance(typeof(TContext))!,
-                    };
-                    typeOptions.Converters.Add(prop.JsonConverter);
-                }
+                        writer.WriteNullValue();
+                        last += 1;
+                    }

-                if (prop.JsonConverter == null && IsSimple(prop.PropertyInfo.PropertyType))
-                {
-                    if (prop.TargetType == typeof(string))
-                        writer.WriteStringValue(Convert.ToString(objValue, CultureInfo.InvariantCulture));
-                    else if (prop.TargetType == typeof(bool))
-                        writer.WriteBooleanValue((bool)objValue);
+                    last = prop.ArrayProperty.Index;
+
+                    var objValue = prop.PropertyInfo.GetValue(value);
+                    if (objValue == null)
+                    {
+                        writer.WriteNullValue();
+                        continue;
+                    }
+
+                    JsonSerializerOptions? typeOptions = null;
+                    if (prop.JsonConverter != null)
+                    {
+                        typeOptions = new JsonSerializerOptions
+                        {
+                            NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals,
+                            PropertyNameCaseInsensitive = false,
+                            TypeInfoResolver = options.TypeInfoResolver,
+                        };
+                        typeOptions.Converters.Add(prop.JsonConverter);
+                    }
+
+                    if (prop.JsonConverter == null && IsSimple(prop.PropertyInfo.PropertyType))
+                    {
+                        if (prop.TargetType == typeof(string))
+                            writer.WriteStringValue(Convert.ToString(objValue, CultureInfo.InvariantCulture));
+                        else if (prop.TargetType == typeof(bool))
+                            writer.WriteBooleanValue((bool)objValue);
+                        else
+                            writer.WriteRawValue(Convert.ToString(objValue, CultureInfo.InvariantCulture)!);
+                    }
                    else
-                        writer.WriteRawValue(Convert.ToString(objValue, CultureInfo.InvariantCulture)!);
-                }
-                else
-                {
-                    JsonSerializer.Serialize(writer, objValue, typeOptions ?? options);
+                    {
+                        JsonSerializer.Serialize(writer, objValue, typeOptions ?? options);
+                    }
                }
            }

@@ -101,8 +101,86 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            if (reader.TokenType == JsonTokenType.Null)
                return default;

-            var result = Activator.CreateInstance(typeof(T))!;
-            return (T)ParseObject(ref reader, result, typeof(T), options);
+            var result = new T();
+            return ParseObject(ref reader, result, options);
+        }
+
+
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        private static T ParseObject(ref Utf8JsonReader reader, T result, JsonSerializerOptions options)
+#else
+        private static T ParseObject(ref Utf8JsonReader reader, T result, JsonSerializerOptions options)
+#endif
+        {
+            if (reader.TokenType != JsonTokenType.StartArray)
+                throw new CeDeserializationException("Not an array");
+
+
+            if (_typePropertyInfo == null)
+                _typePropertyInfo = CacheTypeAttributes();
+
+            int index = 0;
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndArray)
+                    break;
+
+                if(!_typePropertyInfo.TryGetValue(index, out var indexAttributes))
+                {
+                    index++;
+                    continue;
+                }
+
+                foreach (var attribute in indexAttributes)
+                {
+                    var targetType = attribute.TargetType;
+                    object? value = null;
+                    if (attribute.JsonConverter != null)
+                    {
+                        if (attribute.JsonSerializerOptions == null)
+                        {
+                            attribute.JsonSerializerOptions = new JsonSerializerOptions
+                            {
+                                NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals,
+                                PropertyNameCaseInsensitive = false,
+                                Converters = { attribute.JsonConverter },
+                                TypeInfoResolver = options.TypeInfoResolver,
+                            };
+                        }
+
+                        var doc = JsonDocument.ParseValue(ref reader);
+                        value = doc.Deserialize(attribute.PropertyInfo.PropertyType, attribute.JsonSerializerOptions);
+                    }
+                    else if (attribute.DefaultDeserialization)
+                    {
+                        value = JsonDocument.ParseValue(ref reader).Deserialize(options.GetTypeInfo(attribute.PropertyInfo.PropertyType));
+                    }
+                    else
+                    {
+                        value = reader.TokenType switch
+                        {
+                            JsonTokenType.Null => null,
+                            JsonTokenType.False => false,
+                            JsonTokenType.True => true,
+                            JsonTokenType.String => reader.GetString(),
+                            JsonTokenType.Number => reader.GetDecimal(),
+                            JsonTokenType.StartObject => JsonSerializer.Deserialize(ref reader, attribute.TargetType, options),
+                            _ => throw new CeDeserializationException($"Array deserialization of type {reader.TokenType} not supported"),
+                        };
+                    }
+
+                    if (targetType.IsAssignableFrom(value?.GetType()))
+                        attribute.PropertyInfo.SetValue(result, value);
+                    else
+                        attribute.PropertyInfo.SetValue(result, value == null ? null : Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture));
+                }
+
+                index++;
+            }
+
+            return result;
        }

        private static bool IsSimple(Type type)
@@ -121,13 +199,13 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #if NET5_0_OR_GREATER
        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        private static List<ArrayPropertyInfo> CacheTypeAttributes([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type)
+        private static SortedDictionary<int, List<ArrayPropertyInfo>> CacheTypeAttributes()
 #else
-        private static List<ArrayPropertyInfo> CacheTypeAttributes(Type type)
+        private static SortedDictionary<int, List<ArrayPropertyInfo>> CacheTypeAttributes()
 #endif
        {
-            var attributes = new List<ArrayPropertyInfo>();
-            var properties = type.GetProperties();
+            var result = new SortedDictionary<int, List<ArrayPropertyInfo>>();
+            var properties = typeof(T).GetProperties();
            foreach (var property in properties)
            {
                var att = property.GetCustomAttribute<ArrayPropertyAttribute>();
@@ -136,7 +214,13 @@ namespace CryptoExchange.Net.Converters.SystemTextJson

                var targetType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
                var converterType = property.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType ?? targetType.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType;
-                attributes.Add(new ArrayPropertyInfo
+                if (!result.TryGetValue(att.Index, out var indexList))
+                {
+                    indexList = new List<ArrayPropertyInfo>();
+                    result[att.Index] = indexList;
+                }
+
+                indexList.Add(new ArrayPropertyInfo
                {
                    ArrayProperty = att,
                    PropertyInfo = property,
@@ -146,87 +230,6 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                });
            }

-            _typeAttributesCache.TryAdd(type, attributes);
-            return attributes;
-        }
-
-
-#if NET5_0_OR_GREATER
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-        private static object ParseObject(ref Utf8JsonReader reader, object result, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type objectType, JsonSerializerOptions options)
-#else
-        private static object ParseObject(ref Utf8JsonReader reader, object result, Type objectType, JsonSerializerOptions options)
-#endif
-        {
-            if (reader.TokenType != JsonTokenType.StartArray)
-                throw new Exception("Not an array");
-
-            if (!_typeAttributesCache.TryGetValue(objectType, out var attributes))
-                attributes = CacheTypeAttributes(objectType);
-
-            int index = 0;
-            while (reader.Read())
-            {
-                if (reader.TokenType == JsonTokenType.EndArray)
-                    break;
-
-                var indexAttributes = attributes.Where(a => a.ArrayProperty.Index == index);
-                if (!indexAttributes.Any())
-                {
-                    index++;
-                    continue;
-                }
-
-                foreach (var attribute in indexAttributes)
-                {
-                    var targetType = attribute.TargetType;
-                    object? value = null;
-                    if (attribute.JsonConverter != null)
-                    {
-                        if (!_converterOptionsCache.TryGetValue(attribute.JsonConverter, out var newOptions))
-                        {                            
-                            newOptions = new JsonSerializerOptions
-                            {
-                                NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals,
-                                PropertyNameCaseInsensitive = false,
-                                Converters = { attribute.JsonConverter },
-                                TypeInfoResolver = options.TypeInfoResolver,
-                            };
-                            _converterOptionsCache.TryAdd(attribute.JsonConverter, newOptions);
-                        }
-
-                        var doc = JsonDocument.ParseValue(ref reader);
-                        value = doc.Deserialize(attribute.PropertyInfo.PropertyType, newOptions);
-                    }
-                    else if (attribute.DefaultDeserialization)
-                    {
-                        // Use default deserialization
-                        value = JsonDocument.ParseValue(ref reader).Deserialize(attribute.PropertyInfo.PropertyType, SerializerOptions.WithConverters((TContext)Activator.CreateInstance(typeof(TContext))!));
-                    }
-                    else
-                    {
-                        value = reader.TokenType switch
-                        {
-                            JsonTokenType.Null => null,
-                            JsonTokenType.False => false,
-                            JsonTokenType.True => true,
-                            JsonTokenType.String => reader.GetString(),
-                            JsonTokenType.Number => reader.GetDecimal(),
-                            JsonTokenType.StartObject => JsonSerializer.Deserialize(ref reader, attribute.TargetType, options),
-                            _ => throw new NotImplementedException($"Array deserialization of type {reader.TokenType} not supported"),
-                        };
-                    }
-
-                    if (targetType.IsAssignableFrom(value?.GetType()))
-                        attribute.PropertyInfo.SetValue(result, value);
-                    else
-                        attribute.PropertyInfo.SetValue(result, value == null ? null : Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture));
-                }
-
-                index++;
-            }
-
            return result;
        }

@@ -237,6 +240,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            public JsonConverter? JsonConverter { get; set; }
            public bool DefaultDeserialization { get; set; }
            public Type TargetType { get; set; } = null!;
+            public JsonSerializerOptions? JsonSerializerOptions { get; set; } = null;
        }
    }
 }
@@ -1,5 +1,5 @@
-using System;
-using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+using System;
 using System.Runtime.Serialization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -20,58 +20,15 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        /// <inheritdoc />
        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
        {
-            return typeToConvert == typeof(bool) ? new BoolConverterInner<bool>() : new BoolConverterInner<bool?>();
+            return typeToConvert == typeof(bool) ? new BoolConverterInner() : new BoolConverterInnerNullable();
        }

-        private class BoolConverterInner<T> : JsonConverter<T>
+        private class BoolConverterInnerNullable : JsonConverter<bool?>
        {
-            public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-                => (T)((object?)ReadBool(ref reader, typeToConvert, options) ?? default(T))!;
+            public override bool? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+                => ReadBool(ref reader, typeToConvert, options);
            
-            public bool? ReadBool(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-            {
-                if (reader.TokenType == JsonTokenType.True)
-                    return true;
-
-                if (reader.TokenType == JsonTokenType.False)
-                    return false;
-
-                var value = reader.TokenType switch
-                {
-                    JsonTokenType.String => reader.GetString(),
-                    JsonTokenType.Number => reader.GetInt16().ToString(),
-                    _ => null
-                };
-
-                value = value?.ToLowerInvariant().Trim();
-                if (string.IsNullOrEmpty(value))
-                {
-                    if (typeToConvert == typeof(bool))
-                        Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received null bool value, but property type is not a nullable bool");
-                    return default;
-                }
-
-                switch (value)
-                {
-                    case "true":
-                    case "yes":
-                    case "y":
-                    case "1":
-                    case "on":
-                        return true;
-                    case "false":
-                    case "no":
-                    case "n":
-                    case "0":
-                    case "off":
-                    case "-1":
-                        return false;
-                }
-
-                throw new SerializationException($"Can't convert bool value {value}");
-            }
-
-            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+            public override void Write(Utf8JsonWriter writer, bool? value, JsonSerializerOptions options)
            {
                if (value is bool boolVal)
                    writer.WriteBooleanValue(boolVal);
@@ -80,5 +37,59 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            }
        }

+        private class BoolConverterInner : JsonConverter<bool>
+        {
+            public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+                => ReadBool(ref reader, typeToConvert, options) ?? false;
+
+            public override void Write(Utf8JsonWriter writer, bool value, JsonSerializerOptions options)
+            {
+                writer.WriteBooleanValue(value);
+            }
+        }
+
+        private static bool? ReadBool(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.True)
+                return true;
+
+            if (reader.TokenType == JsonTokenType.False)
+                return false;
+
+            var value = reader.TokenType switch
+            {
+                JsonTokenType.String => reader.GetString(),
+                JsonTokenType.Number => reader.GetInt16().ToString(),
+                _ => null
+            };
+
+            value = value?.ToLowerInvariant().Trim();
+            if (string.IsNullOrEmpty(value))
+            {
+                if (typeToConvert == typeof(bool))
+                    LibraryHelpers.StaticLogger?.LogWarning("Received null or empty bool value, but property type is not a nullable bool. Resolver: {Resolver}", options.TypeInfoResolver?.GetType()?.Name);
+                return default;
+            }
+
+            switch (value)
+            {
+                case "true":
+                case "yes":
+                case "y":
+                case "1":
+                case "on":
+                    return true;
+                case "false":
+                case "no":
+                case "n":
+                case "0":
+                case "off":
+                case "-1":
+                    return false;
+            }
+
+            throw new SerializationException($"Can't convert bool value {value}");
+        }
+
    }
 }
@@ -1,8 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;

@@ -21,7 +19,11 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        /// <inheritdoc />
        public override T[]? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
-            return (reader.GetString()?.Split(',').Select(x => (T)EnumConverter.ParseString<T>(x)!).ToArray() ?? []);
+            var str = reader.GetString();
+            if (string.IsNullOrEmpty(str))
+                return [];
+
+            return str!.Split(',').Select(x => (T)EnumConverter.ParseString<T>(x)!).ToArray() ?? [];
        }

        /// <inheritdoc />
@@ -1,5 +1,5 @@
-using System;
-using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Text.Json;
@@ -14,8 +14,8 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
    {
        private static readonly DateTime _epoch = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        private const long _ticksPerSecond = TimeSpan.TicksPerMillisecond * 1000;
-        private const double _ticksPerMicrosecond = TimeSpan.TicksPerMillisecond / 1000d;
-        private const double _ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000d / 1000;
+        private const decimal _ticksPerMicrosecond = TimeSpan.TicksPerMillisecond / 1000m;
+        private const decimal _ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000m / 1000;

        /// <inheritdoc />
        public override bool CanConvert(Type typeToConvert)
@@ -26,92 +26,107 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        /// <inheritdoc />
        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
        {
-            return typeToConvert == typeof(DateTime) ? new DateTimeConverterInner<DateTime>() : new DateTimeConverterInner<DateTime?>();
+            return typeToConvert == typeof(DateTime) ? new DateTimeConverterInner() : new NullableDateTimeConverterInner();
        }

-        private class DateTimeConverterInner<T> : JsonConverter<T>
+        private class NullableDateTimeConverterInner : JsonConverter<DateTime?>
        {
-            public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-                => (T)((object?)ReadDateTime(ref reader, typeToConvert, options) ?? default(T))!;
+            public override DateTime? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+                => ReadDateTime(ref reader, typeToConvert, options);

-            private DateTime? ReadDateTime(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-            {
-                if (reader.TokenType == JsonTokenType.Null)
-                {
-                    if (typeToConvert == typeof(DateTime))
-                        Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | DateTime value of null, but property is not nullable");
-                    return default;
-                }
-
-                if (reader.TokenType is JsonTokenType.Number)
-                {
-                    var longValue = reader.GetDouble();
-                    if (longValue == 0 || longValue < 0)
-                        return default;
-
-                    return ParseFromDouble(longValue);
-                }
-                else if (reader.TokenType is JsonTokenType.String)
-                {
-                    var stringValue = reader.GetString();
-                    if (string.IsNullOrWhiteSpace(stringValue)
-                        || stringValue == "-1"
-                        || stringValue == "0001-01-01T00:00:00Z"
-                        || double.TryParse(stringValue, out var doubleVal) && doubleVal == 0)
-                    {
-                        return default;
-                    }
-
-                    return ParseFromString(stringValue!);
-                }
-                else
-                {
-                    return reader.GetDateTime();
-                }
-            }
-
-            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+            public override void Write(Utf8JsonWriter writer, DateTime? value, JsonSerializerOptions options)
            {
                if (value == null)
                {
                    writer.WriteNullValue();
+                    return;
                }
+
+                if (value.Value == default)
+                    writer.WriteStringValue(default(DateTime));
                else
+                    writer.WriteNumberValue((long)Math.Round((value.Value - new DateTime(1970, 1, 1)).TotalMilliseconds));
+            }
+        }
+
+        private class DateTimeConverterInner : JsonConverter<DateTime>
+        {
+            public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+                => ReadDateTime(ref reader, typeToConvert, options) ?? default;            
+
+            public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
+            {
+                var dtValue = value;
+                if (dtValue == default)
+                    writer.WriteStringValue(default(DateTime));
+                else
+                    writer.WriteNumberValue((long)Math.Round((dtValue - new DateTime(1970, 1, 1)).TotalMilliseconds));
+            }
+        }
+
+        private static DateTime? ReadDateTime(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+            {
+                if (typeToConvert == typeof(DateTime))
+                    LibraryHelpers.StaticLogger?.LogWarning("DateTime value of null, but property is not nullable. Resolver: {Resolver}", options.TypeInfoResolver?.GetType()?.Name);
+                return default;
+            }
+
+            if (reader.TokenType is JsonTokenType.Number)
+            {
+                var decValue = reader.GetDecimal();
+                if (decValue == 0 || decValue < 0)
+                    return default;
+
+                return ParseFromDecimal(decValue);
+            }
+            else if (reader.TokenType is JsonTokenType.String)
+            {
+                var stringValue = reader.GetString();
+                if (string.IsNullOrWhiteSpace(stringValue)
+                    || stringValue!.Equals("-1", StringComparison.Ordinal)
+                    || stringValue!.Equals("0001-01-01T00:00:00Z", StringComparison.OrdinalIgnoreCase)
+                    || decimal.TryParse(stringValue, out var decVal) && decVal == 0)
                {
-                    var dtValue = (DateTime)(object)value;
-                    if (dtValue == default)
-                        writer.WriteStringValue(default(DateTime));
-                    else
-                        writer.WriteNumberValue((long)Math.Round((dtValue - new DateTime(1970, 1, 1)).TotalMilliseconds));
+                    return default;
                }
+
+                return ParseFromString(stringValue!, options.TypeInfoResolver?.GetType()?.Name);
+            }
+            else
+            {
+                return reader.GetDateTime();
            }
        }

        /// <summary>
-        /// Parse a long value to datetime
+        /// Parse a double value to datetime
        /// </summary>
-        /// <param name="longValue"></param>
-        /// <returns></returns>
-        public static DateTime ParseFromDouble(double longValue)
-        {
-            if (longValue < 19999999999)
-                return ConvertFromSeconds(longValue);
-            if (longValue < 19999999999999)
-                return ConvertFromMilliseconds(longValue);
-            if (longValue < 19999999999999999)
-                return ConvertFromMicroseconds(longValue);
+        public static DateTime ParseFromDouble(double value)
+            => ParseFromDecimal((decimal)value);

-            return ConvertFromNanoseconds(longValue);
+        /// <summary>
+        /// Parse a decimal value to datetime
+        /// </summary>
+        public static DateTime ParseFromDecimal(decimal value)
+        {
+            if (value < 19999999999)
+                return ConvertFromSeconds(value);
+            if (value < 19999999999999)
+                return ConvertFromMilliseconds(value);
+            if (value < 19999999999999999)
+                return ConvertFromMicroseconds(value);
+
+            return ConvertFromNanoseconds(value);
        }

        /// <summary>
        /// Parse a string value to datetime
        /// </summary>
-        /// <param name="stringValue"></param>
-        /// <returns></returns>
-        public static DateTime ParseFromString(string stringValue)
+        public static DateTime ParseFromString(string stringValue, string? resolverName)
        {
-            if (stringValue!.Length == 12 && stringValue.StartsWith("202"))
+            if (stringValue!.Length == 12 && stringValue.StartsWith("202", StringComparison.OrdinalIgnoreCase))
            {
                // Parse 202303261200 format
                if (!int.TryParse(stringValue.Substring(0, 4), out var year)
@@ -120,7 +135,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                    || !int.TryParse(stringValue.Substring(8, 2), out var hour)
                    || !int.TryParse(stringValue.Substring(10, 2), out var minute))
                {
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                    return default;
                }
                return new DateTime(year, month, day, hour, minute, 0, DateTimeKind.Utc);
@@ -133,7 +148,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                    || !int.TryParse(stringValue.Substring(4, 2), out var month)
                    || !int.TryParse(stringValue.Substring(6, 2), out var day))
                {
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                    return default;
                }
                return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
@@ -146,25 +161,25 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                    || !int.TryParse(stringValue.Substring(2, 2), out var month)
                    || !int.TryParse(stringValue.Substring(4, 2), out var day))
                {
-                    Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                    return default;
                }
                return new DateTime(year + 2000, month, day, 0, 0, 0, DateTimeKind.Utc);
            }

-            if (double.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
+            if (decimal.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var decimalValue))
            {
                // Parse 1637745563.000 format
-                if (doubleValue <= 0)
+                if (decimalValue <= 0)
                    return default;
-                if (doubleValue < 19999999999)
-                    return ConvertFromSeconds(doubleValue);
-                if (doubleValue < 19999999999999)
-                    return ConvertFromMilliseconds((long)doubleValue);
-                if (doubleValue < 19999999999999999)
-                    return ConvertFromMicroseconds((long)doubleValue);
+                if (decimalValue < 19999999999)
+                    return ConvertFromSeconds(decimalValue);
+                if (decimalValue < 19999999999999)
+                    return ConvertFromMilliseconds(decimalValue);
+                if (decimalValue < 19999999999999999)
+                    return ConvertFromMicroseconds(decimalValue);

-                return ConvertFromNanoseconds((long)doubleValue);
+                return ConvertFromNanoseconds(decimalValue);
            }

            if (stringValue.Length == 10)
@@ -175,7 +190,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                    || !int.TryParse(values[1], out var month)
                    || !int.TryParse(values[2], out var day))
                {
-                    Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                    return default;
                }

@@ -188,54 +203,70 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        /// <summary>
        /// Convert a seconds since epoch (01-01-1970) value to DateTime
        /// </summary>
-        /// <param name="seconds"></param>
-        /// <returns></returns>
-        public static DateTime ConvertFromSeconds(double seconds) => _epoch.AddTicks((long)Math.Round(seconds * _ticksPerSecond));
-        /// <summary>
-        /// Convert a milliseconds since epoch (01-01-1970) value to DateTime
-        /// </summary>
-        /// <param name="milliseconds"></param>
-        /// <returns></returns>
-        public static DateTime ConvertFromMilliseconds(double milliseconds) => _epoch.AddTicks((long)Math.Round(milliseconds * TimeSpan.TicksPerMillisecond));
-        /// <summary>
-        /// Convert a microseconds since epoch (01-01-1970) value to DateTime
-        /// </summary>
-        /// <param name="microseconds"></param>
-        /// <returns></returns>
-        public static DateTime ConvertFromMicroseconds(double microseconds) => _epoch.AddTicks((long)Math.Round(microseconds * _ticksPerMicrosecond));
+        public static DateTime ConvertFromSeconds(decimal seconds) => _epoch.AddTicks((long)Math.Round(seconds * _ticksPerSecond));
        /// <summary>
        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
        /// </summary>
-        /// <param name="nanoseconds"></param>
-        /// <returns></returns>
-        public static DateTime ConvertFromNanoseconds(double nanoseconds) => _epoch.AddTicks((long)Math.Round(nanoseconds * _ticksPerNanosecond));
+        public static DateTime ConvertFromSeconds(double seconds) => ConvertFromSeconds((decimal)seconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromSeconds(long seconds) => ConvertFromSeconds((decimal)seconds);
+        /// <summary>
+        /// Convert a milliseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMilliseconds(decimal milliseconds) => _epoch.AddTicks((long)Math.Round(milliseconds * TimeSpan.TicksPerMillisecond));
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMilliseconds(double milliseconds) => ConvertFromMilliseconds((decimal)milliseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMilliseconds(long milliseconds) => ConvertFromMilliseconds((decimal)milliseconds);
+        /// <summary>
+        /// Convert a microseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMicroseconds(decimal microseconds) => _epoch.AddTicks((long)Math.Round(microseconds * _ticksPerMicrosecond));
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMicroseconds(double microseconds) => ConvertFromMicroseconds((decimal)microseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMicroseconds(long microseconds) => ConvertFromMicroseconds((decimal)microseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromNanoseconds(decimal nanoseconds) => _epoch.AddTicks((long)Math.Round(nanoseconds * _ticksPerNanosecond));
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromNanoseconds(double nanoseconds) => ConvertFromNanoseconds((decimal)nanoseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromNanoseconds(long nanoseconds) => ConvertFromNanoseconds((decimal)nanoseconds);

        /// <summary>
        /// Convert a DateTime value to seconds since epoch (01-01-1970) value
        /// </summary>
-        /// <param name="time"></param>
-        /// <returns></returns>
        [return: NotNullIfNotNull("time")]
        public static long? ConvertToSeconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).TotalSeconds);
        /// <summary>
        /// Convert a DateTime value to milliseconds since epoch (01-01-1970) value
        /// </summary>
-        /// <param name="time"></param>
-        /// <returns></returns>
        [return: NotNullIfNotNull("time")]
        public static long? ConvertToMilliseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).TotalMilliseconds);
        /// <summary>
        /// Convert a DateTime value to microseconds since epoch (01-01-1970) value
        /// </summary>
-        /// <param name="time"></param>
-        /// <returns></returns>
        [return: NotNullIfNotNull("time")]
        public static long? ConvertToMicroseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).Ticks / _ticksPerMicrosecond);
        /// <summary>
        /// Convert a DateTime value to nanoseconds since epoch (01-01-1970) value
        /// </summary>
-        /// <param name="time"></param>
-        /// <returns></returns>
        [return: NotNullIfNotNull("time")]
        public static long? ConvertToNanoseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).Ticks / _ticksPerNanosecond);
    }
@@ -1,5 +1,4 @@
 using System;
-using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;

@@ -19,22 +18,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            if (reader.TokenType == JsonTokenType.String)
            {
                var value = reader.GetString();
-                if (string.IsNullOrEmpty(value) || string.Equals("null", 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)
-                {
-                    // Value doesn't fit decimal, default to max value
-                    return decimal.MaxValue;
-                }
+                return ExchangeHelpers.ParseDecimal(value);
            }

            try
@@ -1,8 +1,11 @@
 using CryptoExchange.Net.Attributes;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Concurrent;
+#if NET8_0_OR_GREATER
+using System.Collections.Frozen;
+#endif
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
@@ -64,9 +67,29 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #endif
         : JsonConverter<T>, INullableConverterFactory where T : struct, Enum
    {
-        private static List<KeyValuePair<T, string>>? _mapping = null;
+        class EnumMapping
+        {
+            public T Value { get; set; }
+            public string StringValue { get; set; }
+
+            public EnumMapping(T value, string stringValue)
+            {
+                Value = value;
+                StringValue = stringValue;
+            }
+        }
+
+#if NET8_0_OR_GREATER
+        private static FrozenSet<EnumMapping>? _mappingToEnum = null;
+        private static FrozenDictionary<T, string>? _mappingToString = null;
+#else
+        private static List<EnumMapping>? _mappingToEnum = null;
+        private static Dictionary<T, string>? _mappingToString = null;
+#endif
        private NullableEnumConverter? _nullableEnumConverter = null;

+        private static ConcurrentBag<string> _unknownValuesWarned = new ConcurrentBag<string>();
+
        internal class NullableEnumConverter : JsonConverter<T?>
        {
            private readonly EnumConverter<T> _enumConverter;
@@ -99,15 +122,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            var t = ReadNullable(ref reader, typeToConvert, options, out var isEmptyString);
            if (t == null)
            {
-                if (isEmptyString)
+                if (isEmptyString && !_unknownValuesWarned.Contains(null))
                {
                    // We received an empty string and have no mapping for it, and the property isn't nullable
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received empty string as enum value, but property type is not a nullable enum. EnumType: {typeof(T).Name}. If you think {typeof(T).Name} should be nullable please open an issue on the Github repo");
-                }
-                else
-                {
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received null enum value, but property type is not a nullable enum. EnumType: {typeof(T).Name}. If you think {typeof(T).Name} should be nullable please open an issue on the Github repo");
+                    LibraryHelpers.StaticLogger?.LogWarning($"Received null or empty enum value, but property type is not a nullable enum. EnumType: {typeof(T).FullName}. If you think {typeof(T).FullName} should be nullable please open an issue on the Github repo");
                }
+
                return new T(); // return default value
            }
            else
@@ -120,23 +140,23 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        {
            isEmptyString = false;
            var enumType = typeof(T);
-            if (_mapping == null)
-                _mapping = AddMapping();
+            if (_mappingToEnum == null)
+                CreateMapping();

            var stringValue = reader.TokenType switch
            {
                JsonTokenType.String => reader.GetString(),
-                JsonTokenType.Number => reader.GetInt16().ToString(),
+                JsonTokenType.Number => reader.GetInt32().ToString(),
                JsonTokenType.True => reader.GetBoolean().ToString(),
                JsonTokenType.False => reader.GetBoolean().ToString(),
                JsonTokenType.Null => null,
                _ => throw new Exception("Invalid token type for enum deserialization: " + reader.TokenType)
            };

-            if (string.IsNullOrEmpty(stringValue))
+            if (stringValue is null)
                return null;

-            if (!GetValue(enumType, stringValue!, out var result))
+            if (!GetValue(enumType, stringValue, out var result))
            {
                if (string.IsNullOrWhiteSpace(stringValue))
                {
@@ -145,7 +165,11 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                else
                {
                    // We received an enum value but weren't able to parse it.
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Cannot map enum value. EnumType: {enumType.Name}, Value: {stringValue}, Known values: {string.Join(", ", _mapping.Select(m => m.Value))}. If you think {stringValue} should added please open an issue on the Github repo");
+                    if (!_unknownValuesWarned.Contains(stringValue))
+                    {
+                        _unknownValuesWarned.Add(stringValue!);
+                        LibraryHelpers.StaticLogger?.LogWarning($"Cannot map enum value. EnumType: {enumType.FullName}, Value: {stringValue}, Known values: {string.Join(", ", _mappingToEnum!.Select(m => m.Value))}. If you think {stringValue} should added please open an issue on the Github repo");
+                    }
                }

                return null;
@@ -163,16 +187,35 @@ namespace CryptoExchange.Net.Converters.SystemTextJson

        private static bool GetValue(Type objectType, string value, out T? result)
        {
-            if (_mapping != null)
+            if (_mappingToEnum != null)
            {
-                // Check for exact match first, then if not found fallback to a case insensitive match 
-                var mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
-                if (mapping.Equals(default(KeyValuePair<T, string>)))
-                    mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
-
-                if (!mapping.Equals(default(KeyValuePair<T, string>)))
+                EnumMapping? mapping = null;
+                // Try match on full equals
+                foreach (var item in _mappingToEnum)
                {
-                    result = mapping.Key;
+                    if (item.StringValue.Equals(value, StringComparison.Ordinal))
+                    {
+                        mapping = item;
+                        break;
+                    }
+                }
+
+                // If not found, try matching ignoring case
+                if (mapping == null)
+                {
+                    foreach (var item in _mappingToEnum)
+                    {
+                        if (item.StringValue.Equals(value, StringComparison.OrdinalIgnoreCase))
+                        {
+                            mapping = item;
+                            break;
+                        }
+                    }
+                }
+
+                if (mapping != null)
+                {
+                    result = mapping.Value;
                    return true;
                }
            }
@@ -184,6 +227,21 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                return true;
            }

+            if (_unknownValuesWarned.Contains(value))
+            {
+                // Check if it is an known unknown value
+                // Done here to prevent lookup overhead for normal conversions, but prevent expensive exception throwing
+                result = default;
+                return false;
+            }
+
+            if (String.IsNullOrEmpty(value))
+            {
+                // An empty/null value will always fail when parsing, so just return here
+                result = default;
+                return false;
+            }
+
            try
            {
                // If no explicit mapping is found try to parse string
@@ -197,9 +255,11 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            }
        }

-        private static List<KeyValuePair<T, string>> AddMapping()
+        private static void CreateMapping()
        {
-            var mapping = new List<KeyValuePair<T, string>>();
+            var mappingToEnum = new List<EnumMapping>();
+            var mappingToString = new Dictionary<T, string>();
+
            var enumType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
            var enumMembers = enumType.GetFields();
            foreach (var member in enumMembers)
@@ -208,12 +268,22 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                foreach (MapAttribute attribute in maps)
                {
                    foreach (var value in attribute.Values)
-                        mapping.Add(new KeyValuePair<T, string>((T)Enum.Parse(enumType, member.Name), value));
+                    {
+                        var enumVal = (T)Enum.Parse(enumType, member.Name);
+                        mappingToEnum.Add(new EnumMapping(enumVal, value));
+                        if (!mappingToString.ContainsKey(enumVal))
+                            mappingToString.Add(enumVal, value);
+                    }
                }
            }

-            _mapping = mapping;
-            return mapping;
+#if NET8_0_OR_GREATER
+            _mappingToEnum = mappingToEnum.ToFrozenSet();
+            _mappingToString = mappingToString.ToFrozenDictionary();
+#else
+            _mappingToEnum = mappingToEnum;
+            _mappingToString = mappingToString;
+#endif
        }

        /// <summary>
@@ -224,10 +294,10 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        [return: NotNullIfNotNull("enumValue")]
        public static string? GetString(T? enumValue)
        {
-            if (_mapping == null)
-                _mapping = AddMapping();
+            if (_mappingToString == null)
+                CreateMapping();

-            return enumValue == null ? null : (_mapping.FirstOrDefault(v => v.Key.Equals(enumValue)).Value ?? enumValue.ToString());
+            return enumValue == null ? null : (_mappingToString!.TryGetValue(enumValue.Value, out var str) ? str : enumValue.ToString());
        }

        /// <summary>
@@ -238,15 +308,35 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        public static T? ParseString(string value)
        {
            var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
-            if (_mapping == null)
-                _mapping = AddMapping();
+            if (_mappingToEnum == null)
+                CreateMapping();

-            var mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
-            if (mapping.Equals(default(KeyValuePair<T, string>)))
-                mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+            EnumMapping? mapping = null;
+            // Try match on full equals
+            foreach(var item in _mappingToEnum!)
+            {
+                if (item.StringValue.Equals(value, StringComparison.Ordinal))
+                {
+                    mapping = item;
+                    break;
+                }
+            }

-            if (!mapping.Equals(default(KeyValuePair<T, string>)))
-                return mapping.Key;
+            // If not found, try matching ignoring case
+            if (mapping == null)
+            {
+                foreach (var item in _mappingToEnum)
+                {
+                    if (item.StringValue.Equals(value, StringComparison.OrdinalIgnoreCase))
+                    {
+                        mapping = item;
+                        break;
+                    }
+                }
+            }
+
+            if (mapping != null)
+                return mapping.Value;

            try
            {
@@ -1,5 +1,4 @@
 using System;
-using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;

@@ -0,0 +1,117 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
+{
+    /// <summary>
+    /// JSON REST message handler
+    /// </summary>
+    public abstract class JsonRestMessageHandler : IRestMessageHandler
+    {
+        private static MediaTypeWithQualityHeaderValue _acceptJsonContent = new MediaTypeWithQualityHeaderValue(Constants.JsonContentHeader);
+
+        /// <summary>
+        /// Empty rate limit error
+        /// </summary>
+        protected static readonly ServerRateLimitError _emptyRateLimitError = new ServerRateLimitError();
+
+        /// <inheritdoc />
+        public virtual bool RequiresSeekableStream => false;
+
+        /// <summary>
+        /// The serializer options to use
+        /// </summary>
+        public abstract JsonSerializerOptions Options { get; }
+
+        /// <inheritdoc />
+        public MediaTypeWithQualityHeaderValue AcceptHeader => _acceptJsonContent;
+
+        /// <inheritdoc />
+        public virtual ValueTask<ServerRateLimitError> ParseErrorRateLimitResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream)
+        {
+            // Handle retry after header
+            var retryAfterHeader = responseHeaders.SingleOrDefault(r => r.Key.Equals("Retry-After", StringComparison.InvariantCultureIgnoreCase));
+            if (retryAfterHeader.Value?.Any() != true)
+                return new ValueTask<ServerRateLimitError>(_emptyRateLimitError);
+
+            var value = retryAfterHeader.Value.First();
+            if (int.TryParse(value, out var seconds))
+                return new ValueTask<ServerRateLimitError>(new ServerRateLimitError() { RetryAfter = DateTime.UtcNow.AddSeconds(seconds) });
+
+            if (DateTime.TryParse(value, out var datetime))
+                return new ValueTask<ServerRateLimitError>(new ServerRateLimitError() { RetryAfter = datetime });
+
+            return new ValueTask<ServerRateLimitError>(_emptyRateLimitError);
+        }
+
+        /// <inheritdoc />
+        public abstract ValueTask<Error> ParseErrorResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <inheritdoc />
+        public virtual ValueTask<Error?> CheckForErrorResponse(
+            RequestDefinition request,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream) => new ValueTask<Error?>((Error?)null);
+
+        /// <summary>
+        /// Read the response into a JsonDocument object
+        /// </summary>
+        protected virtual async ValueTask<(Error?, JsonDocument?)> GetJsonDocument(Stream stream)
+        {
+            try
+            {
+                var document = await JsonDocument.ParseAsync(stream).ConfigureAwait(false);
+                return (null, document);
+            }
+            catch (Exception ex)
+            {
+                return (new ServerError(new ErrorInfo(ErrorType.DeserializationFailed, false, "Deserialization failed, invalid JSON"), ex), null);
+            }
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public async ValueTask<(T? Result, Error? Error)> TryDeserializeAsync<T>(Stream responseStream, CancellationToken cancellationToken)
+        {
+            try
+            {
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+                var result = await JsonSerializer.DeserializeAsync<T>(responseStream, Options)!.ConfigureAwait(false)!;
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+                return (result, null);
+            }            
+            catch (JsonException ex)
+            {
+                var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+                return (default, new DeserializeError(info, ex));
+            }
+            catch (Exception ex)
+            {
+                return (default, new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
+            }
+        }
+
+        /// <inheritdoc />
+        public virtual Error? CheckDeserializedResponse<T>(HttpResponseHeaders responseHeaders, T result) => null;
+    }
+}
@@ -0,0 +1,348 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
+{
+    /// <summary>
+    /// JSON WebSocket message handler, sequentially read the JSON and looks for specific predefined fields to identify the message
+    /// </summary>
+    public abstract class JsonSocketMessageHandler : ISocketMessageHandler
+    {
+        /// <summary>
+        /// The serializer options to use
+        /// </summary>
+        public abstract JsonSerializerOptions Options { get; }
+
+        /// <summary>
+        /// Message evaluators
+        /// </summary>
+        protected abstract MessageTypeDefinition[] TypeEvaluators { get; }
+
+        private readonly SearchResult _searchResult = new();
+
+        private bool _hasArraySearches;
+        private bool _initialized;
+        private int _maxSearchDepth;
+        private MessageTypeDefinition? _topEvaluator;
+        private List<MessageEvalutorFieldReference>? _searchFields;
+        private Dictionary<Type, Func<object, string?>>? _baseTypeMapping;
+        private Dictionary<Type, Func<object, string?>>? _mapping;
+
+        /// <summary>
+        /// Add a mapping of a specific object of a type to a specific topic
+        /// </summary>
+        /// <typeparam name="T">Type to get topic for</typeparam>
+        /// <param name="mapping">The topic retrieve delegate</param>
+        protected void AddTopicMapping<T>(Func<T, string?> mapping)
+        {
+            _mapping ??= new Dictionary<Type, Func<object, string?>>();
+            _mapping.Add(typeof(T), x => mapping((T)x));
+        }
+
+        private void InitializeConverter()
+        {
+            if (_initialized)
+                return;
+
+            _maxSearchDepth = int.MinValue;
+            _searchFields = new List<MessageEvalutorFieldReference>();
+            foreach (var evaluator in TypeEvaluators)
+            {
+                _topEvaluator ??= evaluator;
+                foreach (var field in evaluator.Fields)
+                {
+                    var overlapping = _searchFields.Where(otherField =>
+                    {
+                        if (field is PropertyFieldReference propRef
+                            && otherField.Field is PropertyFieldReference otherPropRef)
+                        {
+                            return field.Depth == otherPropRef.Depth && propRef.PropertyName.SequenceEqual(otherPropRef.PropertyName);
+                        }
+                        else if (field is ArrayFieldReference arrayRef
+                            && otherField.Field is ArrayFieldReference otherArrayPropRef)
+                        {
+                            return field.Depth == otherArrayPropRef.Depth && arrayRef.ArrayIndex == otherArrayPropRef.ArrayIndex;
+                        }
+
+                        return false;
+                    }).ToList();
+
+                    if (overlapping.Any())
+                    {
+                        foreach (var overlap in overlapping)
+                            overlap.OverlappingField = true;
+                    }
+
+                    List<MessageEvalutorFieldReference>? existingSameSearchField = new();
+                    if (field is ArrayFieldReference arrayField)
+                    {
+                        _hasArraySearches = true;
+                        existingSameSearchField = _searchFields.Where(x =>
+                            x.Field is ArrayFieldReference arrayFieldRef
+                            && arrayFieldRef.ArrayIndex == arrayField.ArrayIndex
+                            && arrayFieldRef.Depth == arrayField.Depth
+                            && arrayFieldRef.Constraint == null && arrayField.Constraint == null).ToList();
+                    }
+                    else if (field is PropertyFieldReference propField)
+                    {
+                        existingSameSearchField = _searchFields.Where(x =>
+                            x.Field is PropertyFieldReference propFieldRef
+                            && propFieldRef.PropertyName.SequenceEqual(propField.PropertyName)
+                            && propFieldRef.Depth == propField.Depth
+                            && propFieldRef.Constraint == null && propFieldRef.Constraint == null).ToList();
+                    }
+
+                    foreach(var sameSearchField in existingSameSearchField)
+                    {
+                        if (sameSearchField.SkipReading == true
+                            && (evaluator.TypeIdentifierCallback != null || field.Constraint != null))
+                        {
+                            sameSearchField.SkipReading = false;
+                        }
+
+                        if (evaluator.ForceIfFound)
+                        {
+                            if (evaluator.Fields.Length > 1 || sameSearchField.ForceEvaluator != null)
+                                throw new Exception("Invalid config");
+
+                            //sameSearchField.ForceEvaluator = evaluator;
+                        }
+                    }
+
+                    _searchFields.Add(new MessageEvalutorFieldReference(field)
+                    {
+                        SkipReading = evaluator.TypeIdentifierCallback == null && field.Constraint == null,
+                        ForceEvaluator = !existingSameSearchField.Any() ? evaluator.ForceIfFound ? evaluator : null : null,
+                        OverlappingField = overlapping.Any()
+                    });
+
+                    if (field.Depth > _maxSearchDepth)
+                        _maxSearchDepth = field.Depth;
+                }
+            }
+
+            _initialized = true;
+        }
+
+        /// <inheritdoc />
+        public virtual string? GetTopicFilter(object deserializedObject)
+        {
+            if (_mapping == null)
+                return null;
+
+            // Cache the found type for future 
+            var currentType = deserializedObject.GetType();
+            if (_baseTypeMapping != null)
+            {
+                if (_baseTypeMapping.TryGetValue(currentType, out var typeMapping))
+                    return typeMapping(deserializedObject);
+            }
+
+            var mappedBase = false;
+            while (currentType != null)
+            {
+                if (_mapping.TryGetValue(currentType, out var mapping))
+                {
+                    if (mappedBase) 
+                    {
+                        _baseTypeMapping ??= new Dictionary<Type, Func<object, string?>>();
+                        _baseTypeMapping.Add(deserializedObject.GetType(), mapping);
+                    }
+
+                    return mapping(deserializedObject);
+                }
+
+                mappedBase = true;
+                currentType = currentType.BaseType;
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc />
+        public virtual string? GetTypeIdentifier(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType)
+        {
+            InitializeConverter();
+
+            int? arrayIndex = null;
+
+            _searchResult.Clear();
+            var reader = new Utf8JsonReader(data);
+            while (reader.Read())
+            {
+                if ((reader.TokenType == JsonTokenType.StartArray
+                    || reader.TokenType == JsonTokenType.StartObject)
+                    && reader.CurrentDepth == _maxSearchDepth)
+                {
+                    // There is no field we need to search for on a depth deeper than this, skip
+                    reader.Skip();
+                    continue;
+                }
+
+                if (reader.TokenType == JsonTokenType.StartArray)
+                    arrayIndex = -1;
+                else if (reader.TokenType == JsonTokenType.EndArray)
+                    arrayIndex = null;
+                else if (arrayIndex != null)
+                    arrayIndex++;
+
+                if (reader.TokenType == JsonTokenType.PropertyName
+                    || arrayIndex != null && _hasArraySearches)
+                {
+                    bool written = false;
+
+                    string? value = null;
+                    byte[]? propName = null;
+                    foreach (var field in _searchFields!)
+                    {
+                        if (field.Field.Depth != reader.CurrentDepth)
+                            continue;
+
+                        bool readArrayValues = false;
+                        if (field.Field is PropertyFieldReference propFieldRef)
+                        {
+                            if (propName == null)
+                            {
+                                if (reader.TokenType != JsonTokenType.PropertyName)
+                                    continue;
+
+                                if (!reader.ValueTextEquals(propFieldRef.PropertyName))
+                                    continue;
+
+                                propName = propFieldRef.PropertyName;
+                                readArrayValues = propFieldRef.ArrayValues;
+                                reader.Read();
+                            }
+                            else if (!propFieldRef.PropertyName.SequenceEqual(propName))
+                            {
+                                continue;
+                            }
+                        }
+                        else if (field.Field is ArrayFieldReference arrayFieldRef)
+                        {
+                            if (propName != null)
+                                continue;
+
+                            if (reader.TokenType == JsonTokenType.PropertyName)
+                                continue;
+
+                            if (arrayFieldRef.ArrayIndex != arrayIndex)
+                                continue;
+                        }
+
+                        if (!field.SkipReading)
+                        {
+                            if (value == null)
+                            {
+                                if (readArrayValues)
+                                {
+                                    if (reader.TokenType != JsonTokenType.StartArray)
+                                        // error
+                                        return null;
+
+                                    var sb = new StringBuilder();
+                                    reader.Read();// Read start array
+                                    bool first = true;
+                                    while(reader.TokenType != JsonTokenType.EndArray)
+                                    {
+                                        if (!first)
+                                            sb.Append(",");
+
+                                        first = false;
+                                        sb.Append(reader.GetString());
+                                        reader.Read();
+                                    }
+
+                                    value = first ? null : sb.ToString();
+                                }
+                                else
+                                {
+                                    switch (reader.TokenType)
+                                    {
+                                        case JsonTokenType.Number:
+                                            value = reader.GetDecimal().ToString();
+                                            break;
+                                        case JsonTokenType.String:
+                                            value = reader.GetString()!;
+                                            break;
+                                        case JsonTokenType.True:
+                                        case JsonTokenType.False:
+                                            value = reader.GetBoolean().ToString()!;
+                                            break;
+                                        case JsonTokenType.Null:
+                                            value = null;
+                                            break;
+                                        case JsonTokenType.StartObject:
+                                        case JsonTokenType.StartArray:
+                                            value = null;
+                                            break;
+                                        default:
+                                            continue;
+                                    }
+                                }
+                            }
+
+                            if (field.Field.Constraint != null
+                                && !field.Field.Constraint(value))
+                            {
+                                continue;
+                            }
+                        }
+
+                        _searchResult.Write(field.Field, value);
+
+                        if (field.ForceEvaluator != null)
+                        {
+                            if (field.ForceEvaluator.StaticIdentifier != null)
+                                return field.ForceEvaluator.StaticIdentifier;
+
+                            // Force the immediate return upon encountering this field
+                            return field.ForceEvaluator.GetMessageType(_searchResult);
+                        }
+
+                        written = true;
+                        if (!field.OverlappingField)
+                            break;
+                    }
+
+                    if (!written)
+                        continue;
+
+                    if (_topEvaluator!.Satisfied(_searchResult))
+                        return _topEvaluator.GetMessageType(_searchResult);
+
+                    if (_searchFields.Count == _searchResult.Count)
+                        break;
+                }
+            }
+
+            foreach (var evaluator in TypeEvaluators)
+            {
+                if (evaluator.Satisfied(_searchResult))
+                    return evaluator.GetMessageType(_searchResult);
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public virtual object Deserialize(ReadOnlySpan<byte> data, Type type)
+        {
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            return JsonSerializer.Deserialize(data, type, Options)!;
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+        }
+    }
+}
@@ -0,0 +1,63 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using System;
+using System.Net.WebSockets;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
+{
+    /// <summary>
+    /// JSON WebSocket message handler, reads the json data info a JsonDocument after which the data can be inspected to identify the message
+    /// </summary>
+    public abstract class JsonSocketPreloadMessageHandler : ISocketMessageHandler
+    {
+        /// <summary>
+        /// The serializer options to use
+        /// </summary>
+        public abstract JsonSerializerOptions Options { get; }
+
+        /// <inheritdoc />
+        public virtual string? GetTypeIdentifier(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType)
+        {
+            var reader = new Utf8JsonReader(data);
+            var jsonDocument = JsonDocument.ParseValue(ref reader);
+
+            return GetTypeIdentifier(jsonDocument);
+        }
+
+        /// <summary>
+        /// Get the message identifier for this document
+        /// </summary>
+        protected abstract string? GetTypeIdentifier(JsonDocument document);
+
+        /// <summary>
+        /// Get optional topic filter, for example a symbol name
+        /// </summary>
+        public virtual string? GetTopicFilter(object deserializedObject) => null;
+
+        /// <inheritdoc />
+        public virtual object Deserialize(ReadOnlySpan<byte> data, Type type)
+        {
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            return JsonSerializer.Deserialize(data, type, Options)!;
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+        }
+
+        /// <summary>
+        /// Get the string value for a path, or an emtpy string if not found
+        /// </summary>
+        protected string StringOrEmpty(JsonDocument document, string path)
+        {
+            if (!document.RootElement.TryGetProperty(path, out var element))
+                return string.Empty;
+
+            if (element.ValueKind == JsonValueKind.String)
+                return element.GetString() ?? string.Empty;
+            else if (element.ValueKind == JsonValueKind.Number)
+                return element.GetDecimal().ToString();
+
+            return string.Empty;
+        }
+    }
+}
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Text.Json.Serialization.Metadata;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;

 namespace CryptoExchange.Net.Converters.SystemTextJson
 {
@@ -14,7 +14,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        /// <summary>
        /// Get Json serializer settings which includes standard converters for DateTime, bool, enum and number types
        /// </summary>
-        public static JsonSerializerOptions WithConverters(JsonSerializerContext typeResolver)
+        public static JsonSerializerOptions WithConverters(JsonSerializerContext typeResolver, params JsonConverter[] additionalConverters)
        {
            if (!_cache.TryGetValue(typeResolver, out var options))
            {
@@ -33,6 +33,11 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                    },
                    TypeInfoResolver = typeResolver,
                };
+
+                foreach (var converter in additionalConverters)
+                    options.Converters.Add(converter);
+
+                options.TypeInfoResolver = typeResolver;
                _cache.TryAdd(typeResolver, options);
            }

@@ -0,0 +1,58 @@
+using CryptoExchange.Net.SharedApis;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    internal class SharedQuantityConverter : SharedQuantityReferenceConverter<SharedQuantity> { }
+    internal class SharedOrderQuantityConverter : SharedQuantityReferenceConverter<SharedOrderQuantity> { }
+
+    internal class SharedQuantityReferenceConverter<T> : JsonConverter<T> where T: SharedQuantityReference, new()
+    {
+        public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType != JsonTokenType.StartArray)
+                throw new Exception("");
+
+            reader.Read(); // Start array
+            var baseQuantity = reader.TokenType == JsonTokenType.Null ? (decimal?)null : reader.GetDecimal();
+            reader.Read();
+            var quoteQuantity = reader.TokenType == JsonTokenType.Null ? (decimal?)null : reader.GetDecimal();
+            reader.Read();
+            var contractQuantity = reader.TokenType == JsonTokenType.Null ? (decimal?)null : reader.GetDecimal();
+            reader.Read();
+
+            if (reader.TokenType != JsonTokenType.EndArray)
+                throw new Exception("");
+
+            reader.Read(); // End array
+
+            var result = new T();
+            result.QuantityInBaseAsset = baseQuantity;
+            result.QuantityInQuoteAsset = quoteQuantity;
+            result.QuantityInContracts = contractQuantity;
+            return result;
+        }
+
+        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+        {
+            writer.WriteStartArray();
+            if (value.QuantityInBaseAsset == null)
+                writer.WriteNullValue();
+            else
+                writer.WriteNumberValue(value.QuantityInBaseAsset.Value);
+
+            if (value.QuantityInQuoteAsset == null)
+                writer.WriteNullValue();
+            else
+                writer.WriteNumberValue(value.QuantityInQuoteAsset.Value);
+
+            if (value.QuantityInContracts == null)
+                writer.WriteNullValue();
+            else
+                writer.WriteNumberValue(value.QuantityInContracts.Value);
+            writer.WriteEndArray();
+        }
+    }
+}
@@ -0,0 +1,44 @@
+using CryptoExchange.Net.SharedApis;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    internal class SharedSymbolConverter : JsonConverter<SharedSymbol>
+    {
+        public override SharedSymbol? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType != JsonTokenType.StartArray)
+                throw new Exception("");
+
+            reader.Read(); // Start array
+            var tradingMode = (TradingMode)Enum.Parse(typeof(TradingMode), reader.GetString()!);
+            reader.Read();
+            var baseAsset = reader.GetString()!;
+            reader.Read();
+            var quoteAsset = reader.GetString()!;
+            reader.Read();
+            var timeStr = reader.GetString()!;
+            var deliverTime = string.IsNullOrEmpty(timeStr) ? (DateTime?)null : DateTime.Parse(timeStr);
+            reader.Read();
+
+            if (reader.TokenType != JsonTokenType.EndArray)
+                throw new Exception("");
+
+            reader.Read(); // End array
+
+            return new SharedSymbol(tradingMode, baseAsset, quoteAsset, deliverTime);
+        }
+
+        public override void Write(Utf8JsonWriter writer, SharedSymbol value, JsonSerializerOptions options)
+        {
+            writer.WriteStartArray();
+            writer.WriteStringValue(value.TradingMode.ToString());
+            writer.WriteStringValue(value.BaseAsset);
+            writer.WriteStringValue(value.QuoteAsset);
+            writer.WriteStringValue(value.DeliverTime?.ToString());
+            writer.WriteEndArray();
+        }
+    }
+}
@@ -2,7 +2,6 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Text;
@@ -24,7 +23,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        private readonly JsonSerializerOptions? _customSerializerOptions;

        /// <inheritdoc />
-        public bool IsJson { get; set; }
+        public bool IsValid { get; set; }

        /// <inheritdoc />
        public abstract bool OriginalDataAvailable { get; }
@@ -47,7 +46,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #endif
        public CallResult<object> Deserialize(Type type, MessagePath? path = null)
        {
-            if (!IsJson)
+            if (!IsValid)
                return new CallResult<object>(GetOriginalString());

            if (_document == null)
@@ -60,13 +59,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            }
            catch (JsonException ex)
            {
-                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
-                return new CallResult<object>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+                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(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+                return new CallResult<object>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
            }
        }

@@ -87,20 +85,19 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            }
            catch (JsonException ex)
            {
-                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
-                return new CallResult<T>(new DeserializeError(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+                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(info, OriginalDataAvailable ? GetOriginalString() : "[Data only available when OutputOriginal = true in client options]"));
+                return new CallResult<T>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
            }
        }

        /// <inheritdoc />
        public NodeType? GetNodeType()
        {
-            if (!IsJson)
+            if (!IsValid)
                throw new InvalidOperationException("Can't access json data on non-json message");

            if (_document == null)
@@ -117,7 +114,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        /// <inheritdoc />
        public NodeType? GetNodeType(MessagePath path)
        {
-            if (!IsJson)
+            if (!IsValid)
                throw new InvalidOperationException("Can't access json data on non-json message");

            var node = GetPathNode(path);
@@ -139,7 +136,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #endif
        public T? GetValue<T>(MessagePath path)
        {
-            if (!IsJson)
+            if (!IsValid)
                throw new InvalidOperationException("Can't access json data on non-json message");

            var value = GetPathNode(path);
@@ -171,9 +168,9 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
 #endif
-        public List<T?>? GetValues<T>(MessagePath path)
+        public T?[]? GetValues<T>(MessagePath path)
        {
-            if (!IsJson)
+            if (!IsValid)
                throw new InvalidOperationException("Can't access json data on non-json message");

            var value = GetPathNode(path);
@@ -183,12 +180,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            if (value.Value.ValueKind != JsonValueKind.Array)
                return default;

-            return value.Value.Deserialize<List<T>>(_customSerializerOptions)!;
+            return value.Value.Deserialize<T[]>(_customSerializerOptions)!;
        }

        private JsonElement? GetPathNode(MessagePath path)
        {
-            if (!IsJson)
+            if (!IsValid)
                throw new InvalidOperationException("Can't access json data on non-json message");

            if (_document == null)
@@ -279,14 +276,14 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
            try
            {
                _document = await JsonDocument.ParseAsync(_stream ?? stream).ConfigureAwait(false);
-                IsJson = true;
+                IsValid = true;
                return CallResult.SuccessResult;
            }
            catch (Exception ex)
            {
                // Not a json message
-                IsJson = false;
-                return new CallResult(new ServerError("JsonError: " + ex.Message));
+                IsValid = false;
+                return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
            }
        }

@@ -337,19 +334,19 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                if (firstByte != 0x7b && firstByte != 0x5b)
                {
                    // Value doesn't start with `{` or `[`, prevent deserialization attempt as it's slow
-                    IsJson = false;
-                    return new CallResult(new ServerError("Not a json value"));
+                    IsValid = false;
+                    return new CallResult(new DeserializeError("Not a json value"));
                }

                _document = JsonDocument.Parse(data);
-                IsJson = true;
+                IsValid = true;
                return CallResult.SuccessResult;
            }
            catch (Exception ex)
            {
                // Not a json message
-                IsJson = false;
-                return new CallResult(new ServerError("JsonError: " + ex.Message));
+                IsValid = false;
+                return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
            }
        }

@@ -1,13 +1,11 @@
 using CryptoExchange.Net.Interfaces;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
-using System.Text.Json.Serialization;
-using System.Text.Json.Serialization.Metadata;

 namespace CryptoExchange.Net.Converters.SystemTextJson
 {
    /// <inheritdoc />
-    public class SystemTextJsonMessageSerializer : IMessageSerializer
+    public class SystemTextJsonMessageSerializer : IStringMessageSerializer
    {
        private readonly JsonSerializerOptions _options;

@@ -1,16 +1,16 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0;net10.0</TargetFrameworks>
  </PropertyGroup>
  <PropertyGroup>
    <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>8.8.0</PackageVersion>
-    <AssemblyVersion>8.8.0</AssemblyVersion>
-    <FileVersion>8.8.0</FileVersion>
+    <PackageVersion>10.0.0</PackageVersion>
+    <AssemblyVersion>10.0.0</AssemblyVersion>
+    <FileVersion>10.0.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>
@@ -20,15 +20,15 @@
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
    <PackageReleaseNotes>https://github.com/JKorf/CryptoExchange.Net?tab=readme-ov-file#release-notes</PackageReleaseNotes>
    <Nullable>enable</Nullable>
-    <LangVersion>12.0</LangVersion>
+    <LangVersion>latest</LangVersion>
    <PackageLicenseExpression>MIT</PackageLicenseExpression>
  </PropertyGroup>
  <ItemGroup>
    <None Include="Icon\icon.png" Pack="true" PackagePath="\" />
    <None Include="..\README.md" Pack="true" PackagePath="\" />
  </ItemGroup>
-  <PropertyGroup Label="AOT" Condition=" '$(TargetFramework)' == 'NET8_0' Or '$(TargetFramework)' == 'NET9_0' ">
-	  <IsAotCompatible>true</IsAotCompatible>
+  <PropertyGroup Label="AOT" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
+    <IsAotCompatible>true</IsAotCompatible>
  </PropertyGroup>
  <PropertyGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
    <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -37,12 +37,6 @@
    <EmbedUntrackedSources>true</EmbedUntrackedSources>
    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
  </PropertyGroup>
-  <ItemGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
  <PropertyGroup>
    <DocumentationFile>CryptoExchange.Net.xml</DocumentationFile>
  </PropertyGroup>
@@ -51,16 +45,19 @@
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="9.0.0">
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="10.0.101">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
  </ItemGroup>
  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0" />
-    <PackageReference Include="System.Text.Json" Version="9.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.1" />
+    <PackageReference Include="System.Text.Json" Version="10.0.1" />
+    <PackageReference Include="NSec.Cryptography" Version="25.4.0" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))" />
+  </ItemGroup>
+  <ItemGroup Label="Transitive Client Packages">
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.1" />
+    <PackageReference Include="System.Threading.Channels" Version="10.0.1" />
  </ItemGroup>
 </Project>
@@ -0,0 +1,24 @@
+using System;
+
+namespace CryptoExchange.Net.Exceptions
+{
+    /// <summary>
+    /// Exception during deserialization
+    /// </summary>
+    public class CeDeserializationException : Exception
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CeDeserializationException(string message) : base(message)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CeDeserializationException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}
@@ -1,7 +1,9 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Threading;
@@ -87,8 +89,6 @@ namespace CryptoExchange.Net
                    value -= offset;
                else value += (step.Value - offset);
            }
-
-            value = RoundDown(value, 8);
                
            return value.Normalize();
        }
@@ -112,6 +112,34 @@ namespace CryptoExchange.Net
            return RoundToSignificantDigits(value, precision.Value, roundingType);
        }

+        /// <summary>
+        /// Apply the provided rules to the value
+        /// </summary>
+        /// <param name="value">Value to be adjusted</param>
+        /// <param name="decimals">Max decimal places</param>
+        /// <param name="valueStep">The value step for increase/decrease value</param>
+        /// <returns></returns>
+        public static decimal ApplyRules(
+            decimal value,
+            int? decimals = null,
+            decimal? valueStep = null)
+        {
+            if (valueStep.HasValue)
+            {
+                var offset = value % valueStep.Value;
+                if (offset != 0)
+                {
+                    if (offset < valueStep.Value / 2)
+                        value -= offset;
+                    else value += (valueStep.Value - offset);
+                }
+            }
+            if (decimals.HasValue)
+                value = Math.Round(value, decimals.Value);
+
+            return value;
+        }
+
        /// <summary>
        /// Round a value to have the provided total number of digits. For example, value 253.12332 with 5 digits would be 253.12 
        /// </summary>
@@ -313,5 +341,146 @@ namespace CryptoExchange.Net
            adjustedQuantity = symbol.QuantityDecimals.HasValue ? (minNotionalAdjust ? RoundUp(adjustedQuantity, symbol.QuantityDecimals.Value) : RoundDown(adjustedQuantity, symbol.QuantityDecimals.Value)) : adjustedQuantity;

        }
+
+        /// <summary>
+        /// Queue updates received from a websocket subscriptions and process them async
+        /// </summary>
+        /// <typeparam name="T">The queued update type</typeparam>
+        /// <param name="subscribeCall">The subscribe call</param>
+        /// <param name="asyncHandler">The async update handler</param>
+        /// <param name="maxQueuedItems">The max number of updates to be queued up. When happens when the queue is full and a new write is attempted can be specified with <see>fullMode</see></param>
+        /// <param name="fullBehavior">What should happen if the queue contains <see>maxQueuedItems</see> pending updates. If no max is set this setting is ignored</param>
+        public static async Task<CallResult<UpdateSubscription>> ProcessQueuedAsync<T>(
+            Func<Action<DataEvent<T>>, Task<CallResult<UpdateSubscription>>> subscribeCall,
+            Func<DataEvent<T>, Task> asyncHandler,
+            int? maxQueuedItems = null,
+            QueueFullBehavior? fullBehavior = null)
+        {
+            var processor = new ProcessQueue<DataEvent<T>>(asyncHandler, maxQueuedItems, fullBehavior);
+            await processor.StartAsync().ConfigureAwait(false);
+            var result = await subscribeCall(upd => processor.Write(upd)).ConfigureAwait(false);
+            if (!result)
+            {
+                await processor.StopAsync().ConfigureAwait(false);
+                return result;
+            }
+
+            processor.Exception += result.Data._subscription.InvokeExceptionHandler;
+            result.Data.SubscriptionStatusChanged += (upd) =>
+            {
+                if (upd == CryptoExchange.Net.Objects.SubscriptionStatus.Closed)
+                    _ = processor.StopAsync(true);
+            };
+
+            return result;
+        }
+
+        /// <summary>
+        /// Queue updates and process them async
+        /// </summary>
+        /// <typeparam name="T">The queued update type</typeparam>
+        /// <param name="subscribeCall">The subscribe call</param>
+        /// <param name="asyncHandler">The async update handler</param>
+        /// <param name="maxQueuedItems">The max number of updates to be queued up. When happens when the queue is full and a new write is attempted can be specified with <see>fullMode</see></param>
+        /// <param name="fullBehavior">What should happen if the queue contains <see>maxQueuedItems</see> pending updates. If no max is set this setting is ignored</param>
+        /// <param name="ct">Cancellation token to stop the processing</param>
+        public static async Task ProcessQueuedAsync<T>(
+            Func<Action<T>, Task> subscribeCall,
+            Func<T, Task> asyncHandler,
+            CancellationToken ct,
+            int? maxQueuedItems = null,
+            QueueFullBehavior? fullBehavior = null)
+        {
+            var processor = new ProcessQueue<T>(asyncHandler, maxQueuedItems, fullBehavior);
+            await processor.StartAsync().ConfigureAwait(false);
+            ct.Register(async () =>
+            {
+                await processor.StopAsync().ConfigureAwait(false);
+            });
+
+            await subscribeCall(upd => processor.Write(upd)).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Queue updates received from a websocket subscriptions and process them async
+        /// </summary>
+        /// <typeparam name="TEventType">The type of the queued item</typeparam>
+        /// <typeparam name="TOutputType">The type of the item to pass to the processor</typeparam>
+        /// <param name="subscribeCall">The subscribe call</param>
+        /// <param name="mapper">The mapper function to go from <see>TEventType</see> to <see>TOutputType</see></param>
+        /// <param name="asyncHandler">The async update handler</param>
+        /// <param name="maxQueuedItems">The max number of updates to be queued up. When happens when the queue is full and a new write is attempted can be specified with <see>fullMode</see></param>
+        /// <param name="fullBehavior">What should happen if the queue contains <see>maxQueuedItems</see> pending updates. If no max is set this setting is ignored</param>
+        public static async Task<CallResult<UpdateSubscription>> ProcessQueuedAsync<TEventType, TOutputType>(
+            Func<ProcessQueue<DataEvent<TEventType>>, Task<CallResult<UpdateSubscription>>> subscribeCall,
+            Func<DataEvent<TEventType>, DataEvent<TOutputType>> mapper,
+            Func<DataEvent<TOutputType>, Task> asyncHandler,
+            int? maxQueuedItems = null,
+            QueueFullBehavior? fullBehavior = null
+            )
+        {
+            var processor = new ProcessQueue<DataEvent<TEventType>>((update) => {
+                return asyncHandler.Invoke(mapper.Invoke(update));
+            }, maxQueuedItems, fullBehavior);
+            await processor.StartAsync().ConfigureAwait(false);
+            var result = await subscribeCall(processor).ConfigureAwait(false);
+            if (!result)
+            {
+                await processor.StopAsync().ConfigureAwait(false);
+                return result;
+            }
+
+            processor.Exception += result.Data._subscription.InvokeExceptionHandler;
+            result.Data.SubscriptionStatusChanged += (upd) =>
+            {
+                if (upd == SubscriptionStatus.Closed)
+                    _ = processor.StopAsync(true);
+            };
+
+            return result;
+        }
+
+        /// <summary>
+        /// Parse a decimal value from a string
+        /// </summary>
+        public static decimal? ParseDecimal(string? value)
+        {
+            // 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;
+            }
+
+            // Infinity value should be parsed to min/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;
+        }
    }
 }
@@ -3,7 +3,6 @@ using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;

 namespace CryptoExchange.Net
 {
@@ -23,14 +22,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, x.QuoteAsset, (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, x.QuoteAsset, (x as SharedFuturesSymbol)?.DeliveryTime) { SymbolName = x.Name }));
+            _symbolInfos[topicId] = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x.SharedSymbol));
        }

        /// <summary>
@@ -1,18 +1,15 @@
-using System;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.SharedApis;
+using Microsoft.Extensions.DependencyInjection;
+using System;
 using System.Collections.Generic;
-using System.IO.Compression;
+using System.Globalization;
 using System.IO;
+using System.IO.Compression;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Web;
-using CryptoExchange.Net.Objects;
-using System.Globalization;
-using Microsoft.Extensions.DependencyInjection;
-using CryptoExchange.Net.SharedApis;
-using System.Text.Json.Serialization.Metadata;
-using System.Text.Json;
-using System.Text.Json.Serialization;

 namespace CryptoExchange.Net
 {
@@ -64,30 +61,71 @@ namespace CryptoExchange.Net
        /// <returns></returns>
        public static string CreateParamString(this IDictionary<string, object> parameters, bool urlEncodeValues, ArrayParametersSerialization serializationType)
        {
-            var uriString = string.Empty;
-            var arraysParameters = parameters.Where(p => p.Value.GetType().IsArray).ToList();
-            foreach (var arrayEntry in arraysParameters)
+            var uriString = new StringBuilder();
+            bool first = true;
+            foreach(var parameter in parameters)
            {
-                if (serializationType == ArrayParametersSerialization.Array)
+                if (!first)
+                    uriString.Append("&");
+
+                first = false;
+
+                if (parameter.GetType().IsArray)
                {
-                    uriString += $"{string.Join("&", ((object[])(urlEncodeValues ? Uri.EscapeDataString(arrayEntry.Value.ToString()!) : arrayEntry.Value)).Select(v => $"{arrayEntry.Key}[]={string.Format(CultureInfo.InvariantCulture, "{0}", v)}"))}&";
+                    if (serializationType == ArrayParametersSerialization.Array)
+                    {
+                        foreach(var entry in (object[])parameter.Value)
+                        {
+                            uriString.Append(parameter.Key);
+                            uriString.Append("[]=");
+                            if (urlEncodeValues)
+                                uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", entry)));
+                            else
+                                uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", entry));
+                        }
+                    }
+                    else if (serializationType == ArrayParametersSerialization.MultipleValues)
+                    {
+                        foreach (var entry in (object[])parameter.Value)
+                        {
+                            uriString.Append(parameter.Key);
+                            uriString.Append("=");
+                            if (urlEncodeValues)
+                                uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", entry)));
+                            else
+                                uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", entry));
+                        }
+                    }
+                    else
+                    {
+                        uriString.Append('[');
+                        var firstArrayEntry = true;
+                        foreach (var entry in (object[])parameter.Value)
+                        {
+                            if (!firstArrayEntry)
+                                uriString.Append(',');                            
+
+                            firstArrayEntry = false;
+                            if (urlEncodeValues)
+                                uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", entry)));
+                            else
+                                uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", entry));
+                        }
+                        uriString.Append(']');
+                    }
                }
-                else if (serializationType == ArrayParametersSerialization.MultipleValues)
+                else 
                {
-                    var array = (Array)arrayEntry.Value;
-                    uriString += string.Join("&", array.OfType<object>().Select(a => $"{arrayEntry.Key}={Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", a))}"));
-                    uriString += "&";
-                }
-                else
-                {
-                    var array = (Array)arrayEntry.Value;
-                    uriString += $"{arrayEntry.Key}=[{string.Join(",", array.OfType<object>().Select(a => string.Format(CultureInfo.InvariantCulture, "{0}", a)))}]&";
+                    uriString.Append(parameter.Key);
+                    uriString.Append('=');
+                    if (urlEncodeValues)
+                        uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", parameter.Value)));
+                    else
+                        uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", parameter.Value));
                }
            }

-            uriString += $"{string.Join("&", parameters.Where(p => !p.Value.GetType().IsArray).Select(s => $"{s.Key}={(urlEncodeValues ? Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", s.Value)) : string.Format(CultureInfo.InvariantCulture, "{0}", s.Value))}"))}";
-            uriString = uriString.TrimEnd('&');
-            return uriString;
+            return uriString.ToString();
        }

        /// <summary>
@@ -233,18 +271,16 @@ namespace CryptoExchange.Net
        /// <summary>
        /// Append a base url with provided path
        /// </summary>
-        /// <param name="url"></param>
-        /// <param name="path"></param>
-        /// <returns></returns>
        public static string AppendPath(this string url, params string[] path)
        {
-            if (!url.EndsWith("/"))
-                url += "/";
+            var sb = new StringBuilder(url.TrimEnd('/'));
+            foreach (var subPath in path)
+            {
+                sb.Append('/');
+                sb.Append(subPath.Trim('/'));
+            }

-            foreach (var item in path)
-                url += item.Trim('/') + "/";
-
-            return url.TrimEnd('/');
+            return sb.ToString();
        }

        /// <summary>
@@ -366,19 +402,40 @@ namespace CryptoExchange.Net
        /// <summary>
        /// Decompress using GzipStream
        /// </summary>
-        /// <param name="data"></param>
-        /// <returns></returns>
+        public static ReadOnlySpan<byte> DecompressGzip(this ReadOnlySpan<byte> data)
+        {
+            using var decompressedStream = new MemoryStream();
+            using var deflateStream = new GZipStream(new MemoryStream(data.ToArray()), CompressionMode.Decompress);
+            deflateStream.CopyTo(decompressedStream);
+            return new ReadOnlySpan<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
+        }
+
+        /// <summary>
+        /// Decompress using GzipStream
+        /// </summary>
        public static ReadOnlyMemory<byte> DecompressGzip(this ReadOnlyMemory<byte> data)
        {
            using var decompressedStream = new MemoryStream();
            using var dataStream = MemoryMarshal.TryGetArray(data, out var arraySegment)
                ? new MemoryStream(arraySegment.Array!, arraySegment.Offset, arraySegment.Count)
                : new MemoryStream(data.ToArray());
-            using var deflateStream = new GZipStream(new MemoryStream(data.ToArray()), CompressionMode.Decompress);
+            using var deflateStream = new GZipStream(dataStream, CompressionMode.Decompress);
            deflateStream.CopyTo(decompressedStream);
            return new ReadOnlyMemory<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
        }

+        /// <summary>
+        /// Decompress using GzipStream
+        /// </summary>
+        public static ReadOnlySpan<byte> Decompress(this ReadOnlySpan<byte> input)
+        {
+            using var output = new MemoryStream();
+            using var compressStream = new MemoryStream(input.ToArray());
+            using var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress);
+            decompressor.CopyTo(output);
+            return new ReadOnlySpan<byte>(output.GetBuffer(), 0, (int)output.Length);
+        }
+
        /// <summary>
        /// Decompress using DeflateStream
        /// </summary>
@@ -388,10 +445,9 @@ namespace CryptoExchange.Net
        {
            var output = new MemoryStream();

-            using (var compressStream = new MemoryStream(input.ToArray()))
-            using (var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress))
-                decompressor.CopyTo(output);
-
+            using var compressStream = new MemoryStream(input.ToArray());
+            using var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress);
+            decompressor.CopyTo(output);
            output.Position = 0;
            return new ReadOnlyMemory<byte>(output.GetBuffer(), 0, (int)output.Length);
        }
@@ -399,7 +455,7 @@ namespace CryptoExchange.Net
        /// <summary>
        /// Whether the trading mode is linear
        /// </summary>
-        public static bool IsLinear(this TradingMode type) => type == TradingMode.PerpetualLinear || type == TradingMode.DeliveryLinear;
+        public static bool IsLinear(this TradingMode type) => type == TradingMode.PerpetualLinear || type == TradingMode.DeliveryLinear;        

        /// <summary>
        /// Whether the trading mode is inverse
@@ -416,6 +472,36 @@ namespace CryptoExchange.Net
        /// </summary>
        public static bool IsDelivery(this TradingMode type) => type == TradingMode.DeliveryInverse || type == TradingMode.DeliveryLinear;

+        /// <summary>
+        /// Whether the account type is a futures account
+        /// </summary>
+        public static bool IsFuturesAccount(this SharedAccountType type) =>
+            type == SharedAccountType.PerpetualLinearFutures
+            || type == SharedAccountType.DeliveryLinearFutures
+            || type == SharedAccountType.PerpetualInverseFutures
+            || type == SharedAccountType.DeliveryInverseFutures;
+
+        /// <summary>
+        /// Whether the account type is a margin account
+        /// </summary>
+        public static bool IsMarginAccount(this SharedAccountType type) =>
+            type == SharedAccountType.CrossMargin
+            || type == SharedAccountType.IsolatedMargin;
+
+        /// <summary>
+        /// Map a TradingMode value to a SharedAccountType enum value
+        /// </summary>
+        public static SharedAccountType ToAccountType(this TradingMode mode)
+        {
+            if (mode == TradingMode.Spot) return SharedAccountType.Spot;
+            if (mode == TradingMode.PerpetualLinear) return SharedAccountType.PerpetualLinearFutures;
+            if (mode == TradingMode.PerpetualInverse) return SharedAccountType.PerpetualInverseFutures;
+            if (mode == TradingMode.DeliveryInverse) return SharedAccountType.DeliveryInverseFutures;
+            if (mode == TradingMode.DeliveryLinear) return SharedAccountType.DeliveryLinearFutures;
+
+            throw new ArgumentException(nameof(mode), "Unmapped trading mode");
+        }
+
        /// <summary>
        /// Register rest client interfaces
        /// </summary>
@@ -443,6 +529,10 @@ namespace CryptoExchange.Net
                services.AddTransient(x => (IWithdrawRestClient)client(x)!);
            if (typeof(IFeeRestClient).IsAssignableFrom(typeof(T)))
                services.AddTransient(x => (IFeeRestClient)client(x)!);
+            if (typeof(IBookTickerRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IBookTickerRestClient)client(x)!);
+            if (typeof(ITransferRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITransferRestClient)client(x)!);

            if (typeof(ISpotOrderRestClient).IsAssignableFrom(typeof(T)))
                services.AddTransient(x => (ISpotOrderRestClient)client(x)!);
@@ -450,6 +540,10 @@ namespace CryptoExchange.Net
                services.AddTransient(x => (ISpotSymbolRestClient)client(x)!);
            if (typeof(ISpotTickerRestClient).IsAssignableFrom(typeof(T)))
                services.AddTransient(x => (ISpotTickerRestClient)client(x)!);
+            if (typeof(ISpotTriggerOrderRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ISpotTriggerOrderRestClient)client(x)!);
+            if (typeof(ISpotOrderClientIdRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ISpotOrderClientIdRestClient)client(x)!);

            if (typeof(IFundingRateRestClient).IsAssignableFrom(typeof(T)))
                services.AddTransient(x => (IFundingRateRestClient)client(x)!);
@@ -471,6 +565,12 @@ namespace CryptoExchange.Net
                services.AddTransient(x => (IPositionHistoryRestClient)client(x)!);
            if (typeof(IPositionModeRestClient).IsAssignableFrom(typeof(T)))
                services.AddTransient(x => (IPositionModeRestClient)client(x)!);
+            if (typeof(IFuturesTpSlRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFuturesTpSlRestClient)client(x)!);
+            if (typeof(IFuturesTriggerOrderRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFuturesTriggerOrderRestClient)client(x)!);
+            if (typeof(IFuturesOrderClientIdRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IFuturesOrderClientIdRestClient)client(x)!);

            return services;
        }
@@ -486,8 +586,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)))
-                services.AddTransient(x => (IOrderBookRestClient)client(x)!);
+            if (typeof(IOrderBookSocketClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (IOrderBookSocketClient)client(x)!);
            if (typeof(ITickerSocketClient).IsAssignableFrom(typeof(T)))
                services.AddTransient(x => (ITickerSocketClient)client(x)!);
            if (typeof(ITickersSocketClient).IsAssignableFrom(typeof(T)))
@@ -1,10 +1,9 @@
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using System;

-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces.Clients
 {
    /// <summary>
    /// Base api client
@@ -1,6 +1,6 @@
 using System;

-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces.Clients
 {
    /// <summary>
    /// Client for accessing REST API's for different exchanges
@@ -1,6 +1,6 @@
 using System;

-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces.Clients
 {
    /// <summary>
    /// Client for accessing Websocket API's for different exchanges
@@ -1,4 +1,4 @@
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces.Clients
 {
    /// <summary>
    /// Base rest API client
@@ -1,7 +1,7 @@
 using System;
 using CryptoExchange.Net.Objects.Options;

-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces.Clients
 {
    /// <summary>
    /// Base class for rest API implementations
@@ -1,9 +1,11 @@
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Sockets.Default.Interfaces;
+using CryptoExchange.Net.Sockets.HighPerf.Interfaces;
 using System.Threading.Tasks;

-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces.Clients
 {
    /// <summary>
    /// Socket API client
@@ -27,6 +29,10 @@ namespace CryptoExchange.Net.Interfaces
        /// </summary>
        IWebsocketFactory SocketFactory { get; set; }
        /// <summary>
+        /// High performance websocket factory
+        /// </summary>
+        IHighPerfConnectionFactory? HighPerfConnectionFactory { get; set; }
+        /// <summary>
        /// Current client options
        /// </summary>
        SocketExchangeOptions ClientOptions { get; }
@@ -3,7 +3,7 @@ using System.Threading.Tasks;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;

-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces.Clients
 {
    /// <summary>
    /// Base class for socket API implementations
@@ -0,0 +1,13 @@
+namespace CryptoExchange.Net.Interfaces
+{
+    /// <summary>
+    /// Service for an exchange
+    /// </summary>
+    public interface IExchangeService
+    {
+        /// <summary>
+        /// The exchange the service is for
+        /// </summary>
+        public string ExchangeName { get; }
+    }
+}
@@ -1,7 +1,7 @@
 using CryptoExchange.Net.Converters.MessageParsing;
 using CryptoExchange.Net.Objects;
 using System;
-using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Threading.Tasks;

@@ -13,9 +13,9 @@ namespace CryptoExchange.Net.Interfaces
    public interface IMessageAccessor
    {
        /// <summary>
-        /// Is this a json message
+        /// Is this a valid message
        /// </summary>
-        bool IsJson { get; }
+        bool IsValid { get; }
        /// <summary>
        /// Is the original data available for retrieval
        /// </summary>
@@ -52,19 +52,27 @@ namespace CryptoExchange.Net.Interfaces
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <returns></returns>
-        List<T?>? GetValues<T>(MessagePath path);
+        T?[]? GetValues<T>(MessagePath path);
        /// <summary>
        /// Deserialize the message into this type
        /// </summary>
        /// <param name="type"></param>
        /// <param name="path"></param>
        /// <returns></returns>
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
        CallResult<object> Deserialize(Type type, MessagePath? path = null);
        /// <summary>
        /// Deserialize the message into this type
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2092:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2095:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
        CallResult<T> Deserialize<T>(MessagePath? path = null);

        /// <summary>
@@ -1,44 +0,0 @@
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Interfaces
-{
-    /// <summary>
-    /// Message processor
-    /// </summary>
-    public interface IMessageProcessor
-    {
-        /// <summary>
-        /// Id of the processor
-        /// </summary>
-        public int Id { get; }
-        /// <summary>
-        /// The identifiers for this processor
-        /// </summary>
-        public HashSet<string> ListenerIdentifiers { get; }
-        /// <summary>
-        /// Handle a message
-        /// </summary>
-        /// <param name="connection"></param>
-        /// <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>
-        /// <param name="accessor"></param>
-        /// <param name="type"></param>
-        /// <returns></returns>
-        CallResult<object> Deserialize(IMessageAccessor accessor, Type type);
-    }
-}
@@ -4,6 +4,26 @@
    /// Serializer interface
    /// </summary>
    public interface IMessageSerializer
+    {
+    }
+
+    /// <summary>
+    /// Serialize to byte array
+    /// </summary>
+    public interface IByteMessageSerializer: IMessageSerializer
+    {
+        /// <summary>
+        /// Serialize an object to a string
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        byte[] Serialize<T>(T message);
+    }
+
+    /// <summary>
+    /// Serialize to string
+    /// </summary>
+    public interface IStringMessageSerializer: IMessageSerializer
    {
        /// <summary>
        /// Serialize an object to a string
@@ -1,6 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Threading;
 using System.Threading.Tasks;

@@ -14,7 +14,7 @@ namespace CryptoExchange.Net.Interfaces
        /// <summary>
        /// Accept header
        /// </summary>
-        string Accept { set; }
+        MediaTypeWithQualityHeaderValue Accept { set; }
        /// <summary>
        /// Content
        /// </summary>
@@ -28,6 +28,10 @@ namespace CryptoExchange.Net.Interfaces
        /// </summary>
        Uri Uri { get; }
        /// <summary>
+        /// HTTP protocol version
+        /// </summary>
+        Version HttpVersion { get; }
+        /// <summary>
        /// internal request id for tracing
        /// </summary>
        int RequestId { get; }
@@ -54,7 +58,7 @@ namespace CryptoExchange.Net.Interfaces
        /// Get all headers
        /// </summary>
        /// <returns></returns>
-        KeyValuePair<string, string[]>[] GetHeaders();
+        HttpRequestHeaders GetHeaders();

        /// <summary>
        /// Get the response
@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 using System;
 using System.Net.Http;

@@ -12,25 +13,21 @@ namespace CryptoExchange.Net.Interfaces
        /// <summary>
        /// Create a request for an uri
        /// </summary>
-        /// <param name="method"></param>
-        /// <param name="uri"></param>
-        /// <param name="requestId"></param>
-        /// <returns></returns>
-        IRequest Create(HttpMethod method, Uri uri, int requestId);
+        IRequest Create(Version httpRequestVersion, HttpMethod method, Uri uri, int requestId);

        /// <summary>
        /// Configure the requests created by this factory
        /// </summary>
-        /// <param name="requestTimeout">Request timeout to use</param>
+        /// <param name="options">Rest client options</param>
        /// <param name="httpClient">Optional shared http client instance</param>
-        /// <param name="proxy">Optional proxy to use when no http client is provided</param>
-        void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? httpClient = null);
+        void Configure(RestExchangeOptions options, HttpClient? httpClient = null);

        /// <summary>
        /// Update settings
        /// </summary>
        /// <param name="proxy">Proxy to use</param>
        /// <param name="requestTimeout">Request timeout to use</param>
-        void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout);
+        /// <param name="httpKeepAliveInterval">Http client keep alive interval</param>
+        void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout, TimeSpan? httpKeepAliveInterval);
    }
 }
@@ -1,6 +1,8 @@
-using System.Collections.Generic;
+using System;
 using System.IO;
 using System.Net;
+using System.Net.Http.Headers;
+using System.Threading;
 using System.Threading.Tasks;

 namespace CryptoExchange.Net.Interfaces
@@ -15,6 +17,11 @@ namespace CryptoExchange.Net.Interfaces
        /// </summary>
        HttpStatusCode StatusCode { get; }

+        /// <summary>
+        /// Http protocol version
+        /// </summary>
+        Version HttpVersion { get; }
+
        /// <summary>
        /// Whether the status code indicates a success status
        /// </summary>
@@ -28,13 +35,13 @@ namespace CryptoExchange.Net.Interfaces
        /// <summary>
        /// The response headers
        /// </summary>
-        KeyValuePair<string, string[]>[] ResponseHeaders { get; }
+        HttpResponseHeaders ResponseHeaders { get; }

        /// <summary>
        /// Get the response stream
        /// </summary>
        /// <returns></returns>
-        Task<Stream> GetResponseStreamAsync();
+        Task<Stream> GetResponseStreamAsync(CancellationToken cancellationToken);

        /// <summary>
        /// Close the response
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Objects;
@@ -0,0 +1,45 @@
+using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.Trackers.Klines;
+using CryptoExchange.Net.Trackers.Trades;
+using System;
+
+namespace CryptoExchange.Net.Interfaces
+{
+    /// <summary>
+    /// Tracker factory
+    /// </summary>
+    public interface ITrackerFactory
+    {
+        /// <summary>
+        /// Whether the factory supports creating a KlineTracker instance for this symbol and interval
+        /// </summary>
+        /// <param name="symbol">The symbol</param>
+        /// <param name="interval">The kline interval</param>
+        bool CanCreateKlineTracker(SharedSymbol symbol, SharedKlineInterval interval);
+
+        /// <summary>
+        /// Create a new kline tracker
+        /// </summary>
+        /// <param name="symbol">The symbol</param>
+        /// <param name="interval">Kline interval</param>
+        /// <param name="limit">The max amount of klines to retain</param>
+        /// <param name="period">The max period the data should be retained</param>
+        /// <returns></returns>
+        IKlineTracker CreateKlineTracker(SharedSymbol symbol, SharedKlineInterval interval, int? limit = null, TimeSpan? period = null);
+
+        /// <summary>
+        /// Whether the factory supports creating a TradeTracker instance for this symbol
+        /// </summary>
+        /// <param name="symbol">The symbol</param>
+        bool CanCreateTradeTracker(SharedSymbol symbol);
+
+        /// <summary>
+        /// Create a new trade tracker for a symbol
+        /// </summary>
+        /// <param name="symbol">The symbol</param>
+        /// <param name="limit">The max amount of trades to retain</param>
+        /// <param name="period">The max period the data should be retained</param>
+        /// <returns></returns>
+        ITradeTracker CreateTradeTracker(SharedSymbol symbol, int? limit = null, TimeSpan? period = null);
+    }
+}
@@ -1,19 +0,0 @@
-using CryptoExchange.Net.Objects.Sockets;
-using Microsoft.Extensions.Logging;
-
-namespace CryptoExchange.Net.Interfaces
-{
-    /// <summary>
-    /// Websocket factory interface
-    /// </summary>
-    public interface IWebsocketFactory
-    {
-        /// <summary>
-        /// Create a websocket for an url
-        /// </summary>
-        /// <param name="logger">The logger</param>
-        /// <param name="parameters">The parameters to use for the connection</param>
-        /// <returns></returns>
-        IWebsocket CreateWebsocket(ILogger logger, WebSocketParameters parameters);
-    }
-}
@@ -1,6 +1,9 @@
-using System;
+using CryptoExchange.Net.Objects;
+using Microsoft.Extensions.Logging;
+using System;
 using System.Collections.Generic;
-using System.Text;
+using System.Net;
+using System.Net.Http;

 namespace CryptoExchange.Net
 {
@@ -9,11 +12,50 @@ namespace CryptoExchange.Net
    /// </summary>
    public static class LibraryHelpers
    {
+        private static ILogger? _staticLogger;
+        /// <summary>
+        /// Static logger
+        /// </summary>
+        public static ILogger? StaticLogger
+        {
+            get => _staticLogger;
+            internal set  
+            {
+                if (_staticLogger != null)
+                    return;
+
+                _staticLogger = value;
+            }
+        }
+
        /// <summary>
        /// Client order id separator
        /// </summary>
        public const string ClientOrderIdSeparator = "JK";

+        private static Dictionary<string, string> _defaultClientReferences = new Dictionary<string, string>()
+        {
+            { "Binance.Spot", "x-VICEW9VV" },
+            { "Binance.Futures", "x-d63tKbx3" },
+            { "BingX", "easytrading" },
+            { "Bitfinex", "kCCe-CNBO" },
+            { "Bitget", "6x21p" },
+            { "BitMart", "EASYTRADING0001" },
+            { "BitMEX", "Sent from JKorf" },
+            { "BloFin", "5c07cf695885c282" },
+            { "Bybit", "Zx000356" },
+            { "CoinEx", "x-147866029-" },
+            { "GateIo", "copytraderpw" },
+            { "HTX", "AA1ef14811" },
+            { "Kucoin.FuturesName", "Easytradingfutures" },
+            { "Kucoin.FuturesKey", "9e08c05f-454d-4580-82af-2f4c7027fd00" },
+            { "Kucoin.SpotName", "Easytrading" },
+            { "Kucoin.SpotKey", "f8ae62cb-2b3d-420c-8c98-e1c17dd4e30a" },
+            { "Mexc", "EASYT" },
+            { "OKX", "1425d83a94fbBCDE" },
+            { "XT", "4XWeqN10M1fcoI5L" },
+        };
+
        /// <summary>
        /// Apply broker id to a client order id
        /// </summary>
@@ -26,7 +68,7 @@ namespace CryptoExchange.Net
        {
            var reservedLength = brokerId.Length + ClientOrderIdSeparator.Length;

-            if ((clientOrderId?.Length + reservedLength) > maxLength)
+            if (clientOrderId?.Length + reservedLength > maxLength)
                return clientOrderId!;

            if (!string.IsNullOrEmpty(clientOrderId))
@@ -43,5 +85,74 @@ namespace CryptoExchange.Net

            return clientOrderId;
        }
+
+        /// <summary>
+        /// Get the client reference for an exchange if available
+        /// </summary>
+        public static string GetClientReference(Func<string?> optionsReference, string exchange, string? topic = null)
+        {
+            var optionsValue = optionsReference();
+            if (!string.IsNullOrEmpty(optionsValue))
+                return optionsValue!;
+
+            var key = exchange;
+            if (topic != null)
+                key += "." + topic;
+
+            return _defaultClientReferences.TryGetValue(key, out var id) ? id : throw new KeyNotFoundException($"{exchange} not found in configuration");
+        }
+
+        /// <summary>
+        /// Create a new HttpMessageHandler instance
+        /// </summary>  
+        public static HttpMessageHandler CreateHttpClientMessageHandler(ApiProxy? proxy, TimeSpan? keepAliveInterval)
+        {
+#if NET5_0_OR_GREATER
+            var socketHandler = new SocketsHttpHandler();
+            try
+            {
+                if (keepAliveInterval != null && keepAliveInterval != TimeSpan.Zero)
+                {
+                    socketHandler.KeepAlivePingPolicy = HttpKeepAlivePingPolicy.Always;
+                    socketHandler.KeepAlivePingDelay = keepAliveInterval.Value;
+                    socketHandler.KeepAlivePingTimeout = TimeSpan.FromSeconds(10);
+                }
+
+                socketHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                socketHandler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
+            }
+            catch (PlatformNotSupportedException) { }
+            catch (NotImplementedException) { } // Mono runtime throws NotImplementedException
+
+            if (proxy != null)
+            {
+                socketHandler.Proxy = new WebProxy
+                {
+                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
+                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
+                };
+            }
+            return socketHandler;
+#else
+            var httpHandler = new HttpClientHandler();
+            try
+            {
+                httpHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                httpHandler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
+            }
+            catch (PlatformNotSupportedException) { }
+            catch (NotImplementedException) { } // Mono runtime throws NotImplementedException
+
+            if (proxy != null)
+            {
+                httpHandler.Proxy = new WebProxy
+                {
+                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
+                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
+                };
+            }
+            return httpHandler;
+#endif
+        }
    }
 }
@@ -8,6 +8,7 @@ namespace CryptoExchange.Net.Logging.Extensions
    {
        private static readonly Action<ILogger, int, Exception?> _connecting;
        private static readonly Action<ILogger, int, string, Exception?> _connectionFailed;
+        private static readonly Action<ILogger, int, Exception?> _connectingCanceled;
        private static readonly Action<ILogger, int, Uri, Exception?> _connected;
        private static readonly Action<ILogger, int, Exception?> _startingProcessing;
        private static readonly Action<ILogger, int, Exception?> _finishedProcessing;
@@ -189,6 +190,12 @@ namespace CryptoExchange.Net.Logging.Extensions
                new EventId(1030, "SocketPingTimeout"),
                "[Sckt {Id}] ping frame timeout; reconnecting socket");

+            _connectingCanceled = LoggerMessage.Define<int>(
+                LogLevel.Debug,
+                new EventId(1031, "ConnectingCanceled"),
+                "[Sckt {SocketId}] connecting canceled");
+
+
        }

        public static void SocketConnecting(
@@ -370,5 +377,11 @@ namespace CryptoExchange.Net.Logging.Extensions
        {
            _socketPingTimeout(logger, socketId, null);
        }
+
+        public static void SocketConnectingCanceled(
+            this ILogger logger, int socketId)
+        {
+            _connectingCanceled(logger, socketId, null);
+        }
    }
 }
@@ -9,7 +9,7 @@ namespace CryptoExchange.Net.Logging.Extensions
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
    public static class RestApiClientLoggingExtensions
    {
-        private static readonly Action<ILogger, int?, int?, long, string?, Exception?> _restApiErrorReceived;
+        private static readonly Action<ILogger, int?, int?, long, string?, string?, Exception?> _restApiErrorReceived;
        private static readonly Action<ILogger, int?, int?, long, string?, Exception?> _restApiResponseReceived;
        private static readonly Action<ILogger, int, string, Exception?> _restApiFailedToSyncTime;
        private static readonly Action<ILogger, int, string, Exception?> _restApiNoApiCredentials;
@@ -22,13 +22,14 @@ namespace CryptoExchange.Net.Logging.Extensions
        private static readonly Action<ILogger, string, Exception?> _restApiCacheHit;
        private static readonly Action<ILogger, string, Exception?> _restApiCacheNotHit;
        private static readonly Action<ILogger, int?, Exception?> _restApiCancellationRequested;
+        private static readonly Action<ILogger, int?, string?, Exception?> _restApiReceivedResponse;

        static RestApiClientLoggingExtensions()
        {
-            _restApiErrorReceived = LoggerMessage.Define<int?, int?, long, string?>(
+            _restApiErrorReceived = LoggerMessage.Define<int?, int?, long, string?, string?>(
                LogLevel.Warning,
                new EventId(4000, "RestApiErrorReceived"),
-                "[Req {RequestId}] {ResponseStatusCode} - Error received in {ResponseTime}ms: {ErrorMessage}");
+                "[Req {RequestId}] {ResponseStatusCode} - Error received in {ResponseTime}ms: {ErrorMessage}, Data: {OriginalData}");

            _restApiResponseReceived = LoggerMessage.Define<int?, int?, long, string?>(
                LogLevel.Debug,
@@ -90,11 +91,16 @@ namespace CryptoExchange.Net.Logging.Extensions
                new EventId(4012, "RestApiCancellationRequested"),
                "[Req {RequestId}] Request cancelled by user");

+            _restApiReceivedResponse = LoggerMessage.Define<int?, string?>(
+                LogLevel.Trace,
+                new EventId(4013, "RestApiReceivedResponse"),
+                "[Req {RequestId}] Received response: {Data}");
+            
        }

-        public static void RestApiErrorReceived(this ILogger logger, int? requestId, HttpStatusCode? responseStatusCode, long responseTime, string? error)
+        public static void RestApiErrorReceived(this ILogger logger, int? requestId, HttpStatusCode? responseStatusCode, long responseTime, string? error, string? originalData, Exception? exception)
        {
-            _restApiErrorReceived(logger, requestId, (int?)responseStatusCode, responseTime, error, null);
+            _restApiErrorReceived(logger, requestId, (int?)responseStatusCode, responseTime, error, originalData, exception);
        }

        public static void RestApiResponseReceived(this ILogger logger, int? requestId, HttpStatusCode? responseStatusCode, long responseTime, string? originalData)
@@ -155,5 +161,10 @@ namespace CryptoExchange.Net.Logging.Extensions
        {
            _restApiCancellationRequested(logger, requestId, null);
        }
+
+        public static void RestApiReceivedResponse(this ILogger logger, int requestId, string? originalData)
+        {
+            _restApiReceivedResponse(logger, requestId, originalData, null);
+        }
    }
 }
@@ -23,6 +23,8 @@ namespace CryptoExchange.Net.Logging.Extensions
        private static readonly Action<ILogger, int, int, Exception?> _unsubscribingSubscription;
        private static readonly Action<ILogger, int, Exception?> _reconnectingAllConnections;
        private static readonly Action<ILogger, DateTime, Exception?> _addingRetryAfterGuard;
+        private static readonly Action<ILogger, Exception?> _timeoutWaitingForReconnectingSocket;
+        private static readonly Action<ILogger, long, Exception?> _waitedForReconnectingSocket;

        static SocketApiClientLoggingExtension()
        {
@@ -110,6 +112,16 @@ namespace CryptoExchange.Net.Logging.Extensions
                LogLevel.Warning,
                new EventId(3018, "AddRetryAfterGuard"),
                "Adding RetryAfterGuard ({RetryAfter}) because the connection attempt was rate limited");
+
+            _timeoutWaitingForReconnectingSocket = LoggerMessage.Define(
+                LogLevel.Debug,
+                new EventId(3019, "TimeoutWaitingForReconnectingSocket"),
+                "Timeout while waiting for existing socket reconnection, failing request");
+
+            _waitedForReconnectingSocket = LoggerMessage.Define<long>(
+                LogLevel.Trace,
+                new EventId(3020, "WaitedForReconnectingSocket"),
+                "Waited for reconnecting socket for {Timespan}ms");
        }

        public static void FailedToAddSubscriptionRetryOnDifferentConnection(this ILogger logger, int socketId)
@@ -196,5 +208,14 @@ namespace CryptoExchange.Net.Logging.Extensions
        {
            _addingRetryAfterGuard(logger, retryAfter, null);
        }
+
+        public static void TimeoutWaitingForReconnectingSocket(this ILogger logger)
+        {
+            _timeoutWaitingForReconnectingSocket(logger, null);
+        }
+        public static void WaitedForReconnectingSocket(this ILogger logger, long milliseconds)
+        {
+            _waitedForReconnectingSocket(logger, milliseconds, null);
+        }
    }
 }
@@ -1,5 +1,6 @@
 using System;
 using System.Net.WebSockets;
+using CryptoExchange.Net.Sockets.Default;
 using Microsoft.Extensions.Logging;

 namespace CryptoExchange.Net.Logging.Extensions
@@ -8,16 +9,16 @@ namespace CryptoExchange.Net.Logging.Extensions
    public static class SocketConnectionLoggingExtension
    {
        private static readonly Action<ILogger, int, bool, Exception?> _activityPaused;
-        private static readonly Action<ILogger, int, Sockets.SocketConnection.SocketStatus, Sockets.SocketConnection.SocketStatus, Exception?> _socketStatusChanged;
+        private static readonly Action<ILogger, int, SocketStatus, SocketStatus, Exception?> _socketStatusChanged;
        private static readonly Action<ILogger, int, string?, Exception?> _failedReconnectProcessing;
        private static readonly Action<ILogger, int, Exception?> _unknownExceptionWhileProcessingReconnection;
        private static readonly Action<ILogger, int, WebSocketError, string?, Exception?> _webSocketErrorCodeAndDetails;
        private static readonly Action<ILogger, int, string?, Exception?> _webSocketError;
-        private static readonly Action<ILogger, int, int, Exception?> _messageSentNotPending;
        private static readonly Action<ILogger, int, string, Exception?> _receivedData;
+        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;
@@ -37,6 +38,7 @@ namespace CryptoExchange.Net.Logging.Extensions
        private static readonly Action<ILogger, int, string, string, Exception?> _periodicSendFailed;
        private static readonly Action<ILogger, int, int, string, Exception?> _sendingData;
        private static readonly Action<ILogger, int, string, string, Exception?> _receivedMessageNotMatchedToAnyListener;
+        private static readonly Action<ILogger, int, int, int, Exception?> _sendingByteData;

        static SocketConnectionLoggingExtension()
        {
@@ -45,7 +47,7 @@ namespace CryptoExchange.Net.Logging.Extensions
                new EventId(2000, "ActivityPaused"),
                "[Sckt {SocketId}] paused activity: {Paused}");

-            _socketStatusChanged = LoggerMessage.Define<int, Sockets.SocketConnection.SocketStatus, Sockets.SocketConnection.SocketStatus>(
+            _socketStatusChanged = LoggerMessage.Define<int, SocketStatus, SocketStatus>(
                LogLevel.Debug,
                new EventId(2001, "SocketStatusChanged"),
                "[Sckt {SocketId}] status changed from {OldStatus} to {NewStatus}");
@@ -70,11 +72,6 @@ namespace CryptoExchange.Net.Logging.Extensions
                new EventId(2005, "WebSocketError"),
                "[Sckt {SocketId}] error: {ErrorMessage}");

-            _messageSentNotPending = LoggerMessage.Define<int, int>(
-                LogLevel.Debug,
-                new EventId(2006, "MessageSentNotPending"),
-                "[Sckt {SocketId}] [Req {RequestId}] message sent, but not pending");
-
            _receivedData = LoggerMessage.Define<int, string>(
                LogLevel.Trace,
                new EventId(2007, "ReceivedData"),
@@ -90,11 +87,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"),
@@ -188,7 +180,23 @@ 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,
+                new EventId(2030, "FailedToParse"),
+                "[Sckt {SocketId}] failed to parse data: {Error}");
+
+            _sendingByteData = LoggerMessage.Define<int, int, int>(
+                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)
@@ -196,7 +204,7 @@ namespace CryptoExchange.Net.Logging.Extensions
            _activityPaused(logger, socketId, paused, null);
        }

-        public static void SocketStatusChanged(this ILogger logger, int socketId, Sockets.SocketConnection.SocketStatus oldStatus, Sockets.SocketConnection.SocketStatus newStatus)
+        public static void SocketStatusChanged(this ILogger logger, int socketId, SocketStatus oldStatus, SocketStatus newStatus)
        {
            _socketStatusChanged(logger, socketId, oldStatus, newStatus, null);
        }
@@ -221,15 +229,16 @@ namespace CryptoExchange.Net.Logging.Extensions
            _webSocketError(logger, socketId, errorMessage, e);
        }

-        public static void MessageSentNotPending(this ILogger logger, int socketId, int requestId)
-        {
-            _messageSentNotPending(logger, socketId, requestId, null);
-        }
-
        public static void ReceivedData(this ILogger logger, int socketId, string originalData)
        {
            _receivedData(logger, socketId, originalData, null);
        }
+
+        public static void FailedToParse(this ILogger logger, int socketId, string error)
+        {
+            _failedToParse(logger, socketId, error, null);
+        }
+
        public static void FailedToEvaluateMessage(this ILogger logger, int socketId, string originalData)
        {
            _failedToEvaluateMessage(logger, socketId, originalData, null);
@@ -238,17 +247,17 @@ 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)
        {
            _receivedMessageNotRecognized(logger, socketId, id, null);
        }
-        public static void FailedToDeserializeMessage(this ILogger logger, int socketId, string? errorMessage)
+        public static void FailedToDeserializeMessage(this ILogger logger, int socketId, string? errorMessage, Exception? ex)
        {
-            _failedToDeserializeMessage(logger, socketId, errorMessage, null);
+            _failedToDeserializeMessage(logger, socketId, errorMessage, ex);
        }
        public static void UserMessageProcessingFailed(this ILogger logger, int socketId, string errorMessage, Exception e)
        {
@@ -321,5 +330,10 @@ namespace CryptoExchange.Net.Logging.Extensions
        {
            _receivedMessageNotMatchedToAnyListener(logger, socketId, listenId, listenIds, null);
        }
+
+        public static void SendingByteData(this ILogger logger, int socketId, int requestId, int length)
+        {
+            _sendingByteData(logger, socketId, requestId, length, null);
+        }
    }
 }
@@ -53,7 +53,7 @@ namespace CryptoExchange.Net.Logging.Extensions
                "{Api} order book {Symbol} connection lost");

            _orderBookDisconnected = LoggerMessage.Define<string, string>(
-                LogLevel.Warning,
+                LogLevel.Debug,
                new EventId(5004, "OrderBookDisconnected"),
                "{Api} order book {Symbol} disconnected");

@@ -173,9 +173,9 @@ namespace CryptoExchange.Net.Logging.Extensions
            _klineTrackerStarting(logger, symbol, null);
        }

-        public static void KlineTrackerStartFailed(this ILogger logger, string symbol, string error)
+        public static void KlineTrackerStartFailed(this ILogger logger, string symbol, string error, Exception? exception)
        {
-            _klineTrackerStartFailed(logger, symbol, error, null);
+            _klineTrackerStartFailed(logger, symbol, error, exception);
        }

        public static void KlineTrackerStarted(this ILogger logger, string symbol)
@@ -233,9 +233,9 @@ namespace CryptoExchange.Net.Logging.Extensions
            _tradeTrackerStarting(logger, symbol, null);
        }

-        public static void TradeTrackerStartFailed(this ILogger logger, string symbol, string error)
+        public static void TradeTrackerStartFailed(this ILogger logger, string symbol, string error, Exception? ex)
        {
-            _tradeTrackerStartFailed(logger, symbol, error, null);
+            _tradeTrackerStartFailed(logger, symbol, error, ex);
        }

        public static void TradeTrackerStarted(this ILogger logger, string symbol)
@@ -0,0 +1,46 @@
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// An alias used by the exchange for an asset commonly known by another name
+    /// </summary>
+    public class AssetAlias
+    {
+        /// <summary>
+        /// Alias type
+        /// </summary>
+        public AliasType Type { get; set; }
+        /// <summary>
+        /// The name of the asset on the exchange
+        /// </summary>
+        public string ExchangeAssetName { get; set; }
+        /// <summary>
+        /// The name of the asset as it's commonly known
+        /// </summary>
+        public string CommonAssetName { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public AssetAlias(string exchangeName, string commonName, AliasType type = AliasType.BothWays)
+        {
+            ExchangeAssetName = exchangeName;
+            CommonAssetName = commonName;
+            Type = type;
+        }
+    }
+
+    /// <summary>
+    /// Alias type
+    /// </summary>
+    public enum AliasType
+    {
+        /// <summary>
+        /// Translate both from and to exchange
+        /// </summary>
+        BothWays,
+        /// <summary>
+        /// Only translate when converting to exchange
+        /// </summary>
+        OnlyToExchange
+    }
+}
@@ -0,0 +1,43 @@
+using System;
+using System.Linq;
+
+namespace CryptoExchange.Net.Objects
+{
+    /// <summary>
+    /// Exchange configuration for asset aliases
+    /// </summary>
+    public class AssetAliasConfiguration
+    {
+        /// <summary>
+        /// Defined aliases
+        /// </summary>
+        public AssetAlias[] Aliases { get; set; } = [];
+
+        /// <summary>
+        /// Auto convert asset names when using the Shared interfaces. Defaults to true
+        /// </summary>
+        public bool AutoConvertEnabled { get; set; } = true;
+
+        /// <summary>
+        /// Map the common name to an exchange name for an asset. If there is no alias the input name is returned
+        /// </summary>
+        public string CommonToExchangeName(string commonName) => 
+            !AutoConvertEnabled ? commonName : Aliases.FirstOrDefault(x => x.CommonAssetName.Equals(commonName, StringComparison.InvariantCulture))?.ExchangeAssetName ?? commonName;
+
+        /// <summary>
+        /// Map the exchange name to a common name for an asset. If there is no alias the input name is returned
+        /// </summary>
+        public string ExchangeToCommonName(string exchangeName)
+        {
+            if (!AutoConvertEnabled)
+                return exchangeName;
+
+            var alias = Aliases.FirstOrDefault(x => x.ExchangeAssetName.Equals(exchangeName, StringComparison.InvariantCulture));
+            if (alias == null || alias.Type == AliasType.OnlyToExchange)
+                return exchangeName;
+
+            return alias.CommonAssetName;
+        }
+
+    }
+}
@@ -14,6 +14,11 @@ namespace CryptoExchange.Net.Objects
    {
        private static readonly Task<bool> _completed = Task.FromResult(true);
        private Queue<TaskCompletionSource<bool>> _waits = new Queue<TaskCompletionSource<bool>>();
+#if NET9_0_OR_GREATER
+        private readonly Lock _waitsLock = new Lock();
+#else
+        private readonly object _waitsLock = new object();
+#endif
        private bool _signaled;
        private readonly bool _reset;

@@ -38,7 +43,7 @@ namespace CryptoExchange.Net.Objects
            try
            {
                Task<bool> waiter = _completed;
-                lock (_waits)
+                lock (_waitsLock)
                {
                    if (_signaled)
                    {
@@ -57,7 +62,7 @@ namespace CryptoExchange.Net.Objects

                        registration = ct.Register(() =>
                        {
-                            lock (_waits)
+                            lock (_waitsLock)
                            {
                                tcs.TrySetResult(false);

@@ -85,7 +90,7 @@ namespace CryptoExchange.Net.Objects
        /// </summary>
        public void Set()
        {
-            lock (_waits)
+            lock (_waitsLock)
            {
                if (!_reset)
                {
@@ -106,7 +111,9 @@ namespace CryptoExchange.Net.Objects
                        toRelease.TrySetResult(true);
                    }
                    else if (!_signaled)
+                    {
                        _signaled = true;
+                    }
                }
            }
        }
@@ -1,9 +1,9 @@
 using CryptoExchange.Net.SharedApis;
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Text;

 namespace CryptoExchange.Net.Objects
@@ -166,6 +166,18 @@ namespace CryptoExchange.Net.Objects
            return new CallResult(error);
        }

+        /// <summary>
+        /// Copy the CallResult to a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="data">The data</param>
+        /// <param name="error">The error returned</param>
+        /// <returns></returns>
+        public CallResult<K> AsErrorWithData<K>(Error error, K data)
+        {
+            return new CallResult<K>(data, OriginalData, error);
+        }
+
        /// <summary>
        /// Copy the WebCallResult to a new data type
        /// </summary>
@@ -193,11 +205,16 @@ namespace CryptoExchange.Net.Objects
        /// The request http method
        /// </summary>
        public HttpMethod? RequestMethod { get; set; }
+        
+        /// <summary>
+        /// HTTP protocol version
+        /// </summary>
+        public Version? HttpVersion { get; set; }

        /// <summary>
        /// The headers sent with the request
        /// </summary>
-        public KeyValuePair<string, string[]>[]? RequestHeaders { get; set; }
+        public HttpRequestHeaders? RequestHeaders { get; set; }

        /// <summary>
        /// The request id
@@ -214,6 +231,11 @@ namespace CryptoExchange.Net.Objects
        /// </summary>
        public string? RequestBody { get; set; }

+        /// <summary>
+        /// The original data returned by the call, only available when `OutputOriginalData` is set to `true` in the client options
+        /// </summary>
+        public string? OriginalData { get; internal set; }
+
        /// <summary>
        /// The status code of the response. Note that a OK status does not always indicate success, check the Success parameter for this.
        /// </summary>
@@ -222,7 +244,7 @@ namespace CryptoExchange.Net.Objects
        /// <summary>
        /// The response headers
        /// </summary>
-        public KeyValuePair<string, string[]>[]? ResponseHeaders { get; set; }
+        public HttpResponseHeaders? ResponseHeaders { get; set; }

        /// <summary>
        /// The time between sending the request and receiving the response
@@ -232,30 +254,25 @@ namespace CryptoExchange.Net.Objects
        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="responseHeaders"></param>
-        /// <param name="responseTime"></param>
-        /// <param name="requestId"></param>
-        /// <param name="requestUrl"></param>
-        /// <param name="requestBody"></param>
-        /// <param name="requestMethod"></param>
-        /// <param name="requestHeaders"></param>
-        /// <param name="error"></param>
        public WebCallResult(
            HttpStatusCode? code,
-            KeyValuePair<string, string[]>[]? responseHeaders,
+            Version? httpVersion,
+            HttpResponseHeaders? responseHeaders,
            TimeSpan? responseTime,
+            string? originalData,
            int? requestId,
            string? requestUrl,
            string? requestBody,
            HttpMethod? requestMethod,
-            KeyValuePair<string, string[]>[]? requestHeaders,
+            HttpRequestHeaders? requestHeaders,
            Error? error) : base(error)
        {
            ResponseStatusCode = code;
+            HttpVersion = httpVersion;
            ResponseHeaders = responseHeaders;
            ResponseTime = responseTime;
            RequestId = requestId;
+            OriginalData = originalData;

            RequestUrl = requestUrl;
            RequestBody = requestBody;
@@ -276,7 +293,7 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public WebCallResult AsError(Error error)
        {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
+            return new WebCallResult(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
        }

        /// <summary>
@@ -287,7 +304,7 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public WebCallResult<K> As<K>([AllowNull] K data)
        {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, data, Error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, data, Error);
        }

        /// <summary>
@@ -324,7 +341,7 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public WebCallResult<K> AsError<K>(Error error)
        {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, default, error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, default, error);
        }

        /// <inheritdoc />
@@ -345,10 +362,15 @@ namespace CryptoExchange.Net.Objects
        /// </summary>
        public HttpMethod? RequestMethod { get; set; }

+        /// <summary>
+        /// HTTP protocol version
+        /// </summary>
+        public Version? HttpVersion { get; set; }
+
        /// <summary>
        /// The headers sent with the request
        /// </summary>
-        public KeyValuePair<string, string[]>[]? RequestHeaders { get; set; }
+        public HttpRequestHeaders? RequestHeaders { get; set; }

        /// <summary>
        /// The request id
@@ -378,7 +400,7 @@ namespace CryptoExchange.Net.Objects
        /// <summary>
        /// The response headers
        /// </summary>
-        public KeyValuePair<string, string[]>[]? ResponseHeaders { get; set; }
+        public HttpResponseHeaders? ResponseHeaders { get; set; }

        /// <summary>
        /// The time between sending the request and receiving the response
@@ -393,22 +415,10 @@ namespace CryptoExchange.Net.Objects
        /// <summary>
        /// Create a new result
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="responseHeaders"></param>
-        /// <param name="responseTime"></param>
-        /// <param name="responseLength"></param>
-        /// <param name="originalData"></param>
-        /// <param name="requestId"></param>
-        /// <param name="requestUrl"></param>
-        /// <param name="requestBody"></param>
-        /// <param name="requestMethod"></param>
-        /// <param name="requestHeaders"></param>
-        /// <param name="dataSource"></param>
-        /// <param name="data"></param>
-        /// <param name="error"></param>
        public WebCallResult(
            HttpStatusCode? code,
-            KeyValuePair<string, string[]>[]? responseHeaders,
+            Version? httpVersion,
+            HttpResponseHeaders? responseHeaders,
            TimeSpan? responseTime,
            long? responseLength,
            string? originalData,
@@ -416,11 +426,12 @@ namespace CryptoExchange.Net.Objects
            string? requestUrl,
            string? requestBody,
            HttpMethod? requestMethod,
-            KeyValuePair<string, string[]>[]? requestHeaders,
+            HttpRequestHeaders? requestHeaders,
            ResultDataSource dataSource,
            [AllowNull] T data,
            Error? error) : base(data, originalData, error)
        {
+            HttpVersion = httpVersion;
            ResponseStatusCode = code;
            ResponseHeaders = responseHeaders;
            ResponseTime = responseTime;
@@ -440,7 +451,7 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public new WebCallResult AsDataless()
        {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, Error);
+            return new WebCallResult(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, Error);
        }
        /// <summary>
        /// Copy as a dataless result
@@ -448,14 +459,14 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public new WebCallResult AsDatalessError(Error error)
        {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
+            return new WebCallResult(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
        }

        /// <summary>
        /// Create a new error result
        /// </summary>
        /// <param name="error">The error</param>
-        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, default, error) { }
+        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, default, error) { }

        /// <summary>
        /// Copy the WebCallResult to a new data type
@@ -465,7 +476,7 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public new WebCallResult<K> As<K>([AllowNull] K data)
        {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error);
        }

        /// <summary>
@@ -476,7 +487,19 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public new WebCallResult<K> AsError<K>(Error error)
        {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, default, error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, default, error);
+        }
+
+        /// <summary>
+        /// Copy the WebCallResult to a new data type
+        /// </summary>
+        /// <typeparam name="K">The new type</typeparam>
+        /// <param name="data">The data</param>
+        /// <param name="error">The error returned</param>
+        /// <returns></returns>
+        public new WebCallResult<K> AsErrorWithData<K>(Error error, K data)
+        {
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, error);
        }

        /// <summary>
@@ -547,7 +570,7 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        internal WebCallResult<T> Cached()
        {
-            return new WebCallResult<T>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Cache, Data, Error);
+            return new WebCallResult<T>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Cache, Data, Error);
        }

        /// <inheritdoc />
@@ -558,7 +581,7 @@ namespace CryptoExchange.Net.Objects
            if (ResponseLength != null)
                sb.Append($", {ResponseLength} bytes");
            if (ResponseTime != null)
-                sb.Append($" received in {Math.Round(ResponseTime?.TotalMilliseconds ?? 0)}ms");
+                sb.Append($", received in {Math.Round(ResponseTime?.TotalMilliseconds ?? 0)}ms");

            return sb.ToString();
        }
@@ -1,6 +1,4 @@
-using CryptoExchange.Net.Attributes;
-
-namespace CryptoExchange.Net.Objects
+namespace CryptoExchange.Net.Objects
 {
    /// <summary>
    /// What to do when a request would exceed the rate limit
@@ -251,4 +249,59 @@ 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
+    }
+
+    /// <summary>
+    /// Subscription status
+    /// </summary>
+    public enum SubscriptionStatus
+    {
+        /// <summary>
+        /// Pending, waiting before (re)subscription can be started
+        /// </summary>
+        Pending,
+        /// <summary>
+        /// Currently (re)subscribing, will start producing updates soon if subscription is successful
+        /// </summary>
+        Subscribing,
+        /// <summary>
+        /// Subscribed and listening to updates
+        /// </summary>
+        Subscribed,
+        /// <summary>
+        /// Subscription is being closed and will stop producing updates
+        /// </summary>
+        Closing,
+        /// <summary>
+        /// Subscription is closed and will no long produce updates
+        /// </summary>
+        Closed
+    }
+
+    /// <summary>
+    /// Queue full behavior
+    /// </summary>
+    public enum QueueFullBehavior
+    {
+        /// <summary>Remove and ignore the newest item in the queue in order to make room for the item being written.</summary>
+        DropNewest,
+        /// <summary>Remove and ignore the oldest item in the queue in order to make room for the item being written.</summary>
+        DropOldest,
+        /// <summary>Drop the item being written.</summary>
+        DropWrite
+    }
 }
@@ -1,4 +1,5 @@
-using System;
+using CryptoExchange.Net.Objects.Errors;
+using System;

 namespace CryptoExchange.Net.Objects
 {
@@ -7,32 +8,69 @@ 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>
-        /// The data which caused the error
+        /// Error type
        /// </summary>
-        public object? Data { get; set; }
+        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
+        /// </summary>
+        public Exception? Exception { get; set; }

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected Error(int? code, string message, object? data)
+        protected Error(string? errorCode, ErrorInfo errorInfo, Exception? exception)
        {
-            Code = code;
-            Message = message;
-            Data = data;
+            ErrorCode = errorCode;
+            ErrorType = errorInfo.ErrorType;
+            Message = errorInfo.Message;
+            ErrorDescription = errorInfo.ErrorDescription;
+            IsTransient = errorInfo.IsTransient;
+            Exception = exception;
        }

        /// <summary>
@@ -41,7 +79,20 @@ namespace CryptoExchange.Net.Objects
        /// <returns></returns>
        public override string ToString()
        {
-            return Code != null ? $"[{GetType().Name}] {Code}: {Message} {Data}" : $"[{GetType().Name}] {Message} {Data}";
+            return Code != null
+                ? $"[{GetType().Name}.{ErrorType}] {Code}: {GetErrorDescription()}" 
+                : $"[{GetType().Name}.{ErrorType}] {GetErrorDescription()}";
+        }
+
+        private string GetErrorDescription()
+        {
+            if (!string.IsNullOrEmpty(Message))
+                return Message!;
+
+            if (ErrorDescription != "Unknown error" || Exception == null)
+                return ErrorDescription!;
+
+            return Exception.Message;
        }
    }

@@ -51,17 +102,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>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected CantConnectError(int? code, string message, object? data) : base(code, message, data) { }
+        public CantConnectError() : base(null, _errorInfo, null) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CantConnectError(Exception? exception) : base(null, _errorInfo, exception) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected CantConnectError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
    }

    /// <summary>
@@ -70,17 +128,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>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected NoApiCredentialsError(int? code, string message, object? data) : base(code, message, data) { }
+        public NoApiCredentialsError() : base(null, _errorInfo, null) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected NoApiCredentialsError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
    }

    /// <summary>
@@ -91,25 +151,19 @@ namespace CryptoExchange.Net.Objects
        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        public ServerError(string message, object? data = null) : base(null, message, data) { }
+        public ServerError(ErrorInfo errorInfo, Exception? exception = null)
+             : base(null, errorInfo, exception) { }

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        public ServerError(int code, string message, object? data = null) : base(code, message, data) { }
+        public ServerError(int errorCode, ErrorInfo errorInfo, Exception? exception = null) 
+            : this(errorCode.ToString(), errorInfo, exception) { }

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ServerError(int? code, string message, object? data) : base(code, message, data) { }
+        public ServerError(string errorCode, ErrorInfo errorInfo, Exception? exception = null) : base(errorCode, errorInfo, exception) { }
    }

    /// <summary>
@@ -118,27 +172,30 @@ namespace CryptoExchange.Net.Objects
    public class WebError : Error
    {
        /// <summary>
-        /// ctor
+        /// Default error info
        /// </summary>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        public WebError(string message, object? data = null) : base(null, message, data) { }
+        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>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        public WebError(int code, string message, object? data = null) : base(code, message, data) { }
+        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>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected WebError(int? code, string message, object? data): base(code, message, data) { }
+        public TimeoutError(string? message = null, Exception? exception = null) : base(null, _errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
    }

    /// <summary>
@@ -147,40 +204,14 @@ namespace CryptoExchange.Net.Objects
    public class DeserializeError : Error
    {
        /// <summary>
-        /// ctor
+        /// Default error info
        /// </summary>
-        /// <param name="message">The error message</param>
-        /// <param name="data">The data which caused the error</param>
-        public DeserializeError(string message, object? data) : base(null, message, data) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.DeserializationFailed, false, "Failed to deserialize data");

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected DeserializeError(int? code, string message, object? data): base(code, message, data) { }
-    }
-
-    /// <summary>
-    /// Unknown error
-    /// </summary>
-    public class UnknownError : Error
-    {
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="message">Error message</param>
-        /// <param name="data">Error data</param>
-        public UnknownError(string message, object? data = null) : base(null, message, data) { }
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected UnknownError(int? code, string message, object? data): base(code, message, data) { }
+        public DeserializeError(string? message = null, Exception? exception = null) : base(null, _errorInfo with { Message = (message?.Length > 0 ? _errorInfo.Message + ": " + message : _errorInfo.Message) }, exception) { }
    }

    /// <summary>
@@ -189,18 +220,28 @@ namespace CryptoExchange.Net.Objects
    public class ArgumentError : Error
    {
        /// <summary>
-        /// ctor
+        /// Default error info for missing parameter
        /// </summary>
-        /// <param name="message"></param>
-        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>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ArgumentError(int? code, string message, object? data): base(code, message, data) { }
+        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>
@@ -216,10 +257,7 @@ namespace CryptoExchange.Net.Objects
        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected BaseRateLimitError(int? code, string message, object? data) : base(code, message, data) { }
+        protected BaseRateLimitError(ErrorInfo errorInfo, Exception? exception) : base(null, errorInfo, exception) { }
    }

    /// <summary>
@@ -228,18 +266,19 @@ namespace CryptoExchange.Net.Objects
    public class ClientRateLimitError : BaseRateLimitError
    {
        /// <summary>
-        /// ctor
+        /// Default error info
        /// </summary>
-        /// <param name="message"></param>
-        public ClientRateLimitError(string message) : base(null, "Client rate limit exceeded: " + message, null) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.RateLimitRequest, false, "Client rate limit exceeded");

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ClientRateLimitError(int? code, string message, object? data): base(code, message, data) { }
+        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>
@@ -248,18 +287,19 @@ namespace CryptoExchange.Net.Objects
    public class ServerRateLimitError : BaseRateLimitError
    {
        /// <summary>
-        /// ctor
+        /// Default error info
        /// </summary>
-        /// <param name="message"></param>
-        public ServerRateLimitError(string message) : base(null, "Server rate limit exceeded: " + message, null) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.RateLimitRequest, false, "Server rate limit exceeded");

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected ServerRateLimitError(int? code, string message, object? data) : base(code, message, data) { }
+        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>
@@ -268,17 +308,19 @@ namespace CryptoExchange.Net.Objects
    public class CancellationRequestedError : Error
    {
        /// <summary>
-        /// ctor
+        /// Default error info
        /// </summary>
-        public CancellationRequestedError() : base(null, "Cancellation requested", null) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.CancellationRequested, false, "Cancellation requested");

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        public CancellationRequestedError(int? code, string message, object? data): base(code, message, data) { }
+        public CancellationRequestedError(Exception? exception = null) : base(null, _errorInfo, null) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected CancellationRequestedError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
    }

    /// <summary>
@@ -287,17 +329,18 @@ namespace CryptoExchange.Net.Objects
    public class InvalidOperationError : Error
    {
        /// <summary>
-        /// ctor
+        /// Default error info
        /// </summary>
-        /// <param name="message"></param>
-        public InvalidOperationError(string message) : base(null, message, null) { }
+        protected static readonly ErrorInfo _errorInfo = new ErrorInfo(ErrorType.InvalidOperation, false, "Operation invalid");

        /// <summary>
        /// ctor
        /// </summary>
-        /// <param name="code"></param>
-        /// <param name="message"></param>
-        /// <param name="data"></param>
-        protected InvalidOperationError(int? code, string message, object? data): base(code, message, data) { }
+        public InvalidOperationError(string message) : base(null, _errorInfo with { Message = message }, null) { }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        protected InvalidOperationError(ErrorInfo info, Exception? exception) : base(null, info, exception) { }
    }
 }
@@ -0,0 +1,38 @@
+using System;
+
+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;
+        }
+    }
+}
@@ -0,0 +1,56 @@
+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;
+        }
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jkorf	451d38d5e7	Updated to version 10.0.1	2025-12-16 11:54:37 +01:00
Jkorf	e11e437bbb	Fixed CryptoExchange.Net reference	2025-12-16 11:54:08 +01:00
Jkorf	b8a1ad798d	Updated to version 10.0.0	2025-12-16 11:49:45 +01:00
Jkorf	4a851c44f2	Updated to version 10.0.0	2025-12-16 11:31:42 +01:00
Jan Korf	d079796020	Websocket performance update (#261 ) Performance update: Authentication Added Ed25519 signing support for NET8.0 and newer Added static methods on ApiCredentials to create credentials of a specific type Added static ApiCredentials.ReadFromFile method to read a key from file Added required abstract SupportedCredentialTypes property on AuthenticationProvider base class General Performance Added checks before logging statements to prevent overhead of building the log string if logging is not needed Added ExchangeHelpers.ProcessQueuedAsync method to process updates async Replaced locking object types from object to Lock in NET9.0 and newer Replaced some Task response types with ValueTask to prevent allocation overhead on hot paths Updated Json ArrayConverter to reduce some allocation overhead Updated Json BoolConverter to prevent boxing Updated Json DateTimeConverter to prevent boxing Updated Json EnumConverter caching to reduce lookup overhead Updated ExtensionMethods.CreateParamString to reduce allocations Updated ExtensionMethods.AppendPath to reduce overhead REST Refactored REST message processing to separate IRestMessageHandler instance Split RestApiClient.PrepareAsync into CheckTimeSync and RateLimitAsync Updated IRequest.Accept type from string to MediaTypeWithQualityHeaderValue to prevent creation on each request Updated IRequest.GetHeaders response type from KeyValuePair<string, string[]>[] to HttpRequestHeaders to prevent additional mapping Updated IResponse.ResponseHeaders type from KeyValuePair<string, string[]>[] to HttpResponseHeaders to prevent additional mapping Updated WebCallResult RequestHeaders and ResponseHeaders types to HttpRequestHeaders and HttpResponseHeaders Removed unnecessary empty dictionary initializations for each request Removed CallResult creation in internal methods to prevent having to create multiple versions for different result types Socket Added HighPerformance websocket client implementation which significantly reduces memory overhead and improves speed but with certain limitations Added MaxIndividualSubscriptionsPerConnection setting in SocketApiClient to limit the number of individual stream subscriptions on a connection Added SocketIndividualSubscriptionCombineTarget option to set the target number of individual stream subscriptions per connection Added new websocket message handling logic which is faster and reduces memory allocation Added UseUpdatedDeserialization option to toggle between updated deserialization and old deserialization Added Exchange property to DataEvent to prevent additional mapping overhead for Shared apis Refactored message callback to be sync instead of async to prevent async overhead Refactored CryptoExchangeWebSocketClient.IncomingKbps calculation to significantly reduce overhead Moved websocket client creation from SocketApiClient to SocketConnection Removed DataEvent.As and DataEvent.ToCallResult methods in favor of single ToType method Removed DataEvent creation on lower levels to prevent having to create multiple versions for different result types Removed Subscription<TSubResponse, TUnsubResponse> as its no longer used Other Added null check to ParameterCollection for required parameters Added Net10.0 target framework Updated dependency versions Updated Shared asset aliases check to be culture invariant Updated Error string representation Updated some namespaces Updated SymbolOrderBook processing of buffered updates to prevent additional allocation Removed ExchangeEvent type which is no longer needed Removed unused usings	2025-12-16 11:27:49 +01:00
Jonnern	f125bc88b0	Pass CancellationToken to Content.ReadAsStreamAsync (#262 )	2025-12-15 16:33:06 +01:00
Jkorf	f3d535f286	Fixed incorrect check for TimeFilterSupport in combination with StartTime parameter for some Shared endpoints	2025-11-20 14:03:59 +01:00
Jkorf	6e8c6feec2	Added dotnet 10 target framework, updated package reference versions	2025-11-13 10:10:55 +01:00
Jkorf	84b0444caf	Added implementation for async processing of (websocket) updates	2025-11-12 11:19:40 +01:00
Jkorf	4be986ebe7	Added resolver name to datetime/bool parser warnings	2025-11-11 08:57:57 +01:00
Jkorf	21872f818a	Updated to version 9.13.0	2025-11-10 13:30:33 +01:00
Jkorf	4e7c45d758	Updated CryptoExchange.Net to version 9.13.0	2025-11-10 13:27:44 +01:00
Jkorf	0e55e5f065	Updated to version 9.13.0	2025-11-10 13:15:48 +01:00
Jkorf	b1c5cf318a	Cleanup	2025-11-10 13:12:16 +01:00
Jkorf	9d94a24862	Added IExchangeService interface	2025-11-10 09:15:29 +01:00
Jkorf	6cf9684f55	Added SharedTickerType for defining time used for ticker calculations by the API	2025-11-10 09:15:20 +01:00
Jkorf	8043a48c49	Fixed incorrect exchange name in static logger when using multiple libraries	2025-11-10 09:14:14 +01:00
Jkorf	7d657dd533	Updated examples	2025-11-03 15:29:19 +01:00
Jkorf	1bfdec1484	Added SharedSymbolModel base class to SharedFuturesKline, SharedKline, SharedTrade models	2025-11-03 11:25:10 +01:00
Jkorf	8d5b6a53f3	Updated to version 9.12.0	2025-11-03 10:39:05 +01:00
Jkorf	ad97102e7c	Updated CryptoExchange.Net version	2025-11-03 10:38:53 +01:00
Jkorf	d8dc121386	Updated to version 9.12.0	2025-11-03 09:48:29 +01:00
Jkorf	10c3868c00	Revert "Updated to version 9.11.0" This reverts commit `411ba00a82`.	2025-11-03 09:46:55 +01:00
Jkorf	411ba00a82	Updated to version 9.11.0	2025-11-03 09:45:41 +01:00
JKorf	c1b2b62dbc	Added AliasType to specify only one way conversion for AssetAliases	2025-11-02 15:17:44 +01:00
JKorf	3960cab7a7	Merge branch 'master' of https://github.com/JKorf/CryptoExchange.Net	2025-11-02 11:41:30 +01:00
JKorf	34e9447e55	Added constant for selecting a USD asset for use in a Shared API/SharedSymbol	2025-11-02 11:41:26 +01:00
Jkorf	9d3295acc7	Removed some unhelpful verbose logs	2025-10-31 15:08:14 +01:00
Jkorf	995cd3d84c	Updated to version 9.11.1	2025-10-30 14:33:26 +01:00
Jkorf	919cdf0075	Updated CryptoExchange.Net version	2025-10-30 14:32:41 +01:00
Jkorf	d181c9cfc1	Updated to version 9.11.0	2025-10-30 14:21:30 +01:00
Jkorf	5943142c44	Updated to version 9.11.0	2025-10-30 13:47:48 +01:00
Jkorf	dbc430e838	Added StaticLogger to LibraryHelpers, updated warning logging for converters to use StaticLogger	2025-10-30 12:52:05 +01:00
Jkorf	7413d03d31	Added client reference helper to LibraryHelpers	2025-10-30 11:25:27 +01:00
Jkorf	dd60067684	Updated examples	2025-10-27 12:00:51 +01:00
Jkorf	04e4ddf525	Fixed exception when initial trade snapshot has no items in TradeTracker	2025-10-27 11:59:54 +01:00
Jkorf	99bf6d7c75	Added Upbit reference	2025-10-27 11:44:12 +01:00
Jkorf	99a203933c	Added missing release notes	2025-10-15 13:59:10 +02:00
Jkorf	b43d2a2040	Updated to version 9.10.0	2025-10-15 13:36:33 +02:00
Jkorf	ba9c406def	Updated CryptoExchange.Net version	2025-10-15 13:34:50 +02:00
Jkorf	f5f4d50cc9	Updated to version 9.10.0	2025-10-15 13:24:25 +02:00
Jkorf	f87506b490	Added ITransferRestClient, updated Shared IBalanceRestClient to use SharedAccountType	2025-10-15 13:21:00 +02:00
Jkorf	f6f9a53ce5	Added ClientOrderId property to SharedUserTrade model	2025-10-13 15:42:27 +02:00
Jkorf	61130ef54e	Added long overloads for parse methods in DateTimeConverter	2025-10-13 11:15:58 +02:00
Jkorf	e8bcbd59be	Updated DateTimeConverter to work primarily with decimal values instead of doubles to fix some floating point parsing issues	2025-10-13 09:06:14 +02:00
Jkorf	d433ff7475	Updated to version 9.9.0	2025-10-06 13:47:21 +02:00
Jkorf	71957037d0	Updated CryptoExchange.Net version to 9.8.0	2025-10-06 13:45:47 +02:00
Jkorf	bcdcdbbd4e	Updated to version 9.9.0	2025-10-06 13:26:23 +02:00
Jkorf	1ece13f5bc	Updated socket Subscription status handling, fixing timing issue for connection events and adding SubscriptionStatusChanged event	2025-10-06 13:22:40 +02:00
Jkorf	da70ba6ec7	Added Aster reference	2025-10-06 10:37:28 +02:00
Jkorf	a832f0e4d4	Updated to version 9.8.0	2025-09-30 12:06:14 +02:00
Jkorf	6ab4d005a0	Updated CryptoExchange.Net version to 9.8.0	2025-09-30 12:04:28 +02:00
Jkorf	18dc935038	Updated to version 9.8.0	2025-09-30 11:56:00 +02:00
Jkorf	bb3a534f75	Merge branch 'master' of https://github.com/JKorf/CryptoExchange.Net	2025-09-30 11:50:16 +02:00
nils2525	649ba370c6	Fixed EnumConverter to allow mapping empty string values (#253 )	2025-09-30 11:49:58 +02:00
Jkorf	51732c5ce6	Fixed issue increasing the number of websocket connections increasing when sending a query when a previous connection was attempting to reconnect	2025-09-29 14:43:39 +02:00
Jkorf	0ba7b46680	Added ContractAddress to SharedAsset model	2025-09-29 13:51:59 +02:00
Jkorf	94dfbb7b9e	Fixed ExchangeHelpers.AdjustValueStep high precision calculation	2025-09-29 13:51:46 +02:00
Jkorf	b8b7512b35	Fixed UpdateSubscription still propagating connection events even though the specific listener is unsubscribed	2025-09-29 10:07:28 +02:00
Jkorf	aba6b773ce	Added ITrackerFactory interface	2025-09-17 10:55:48 +02:00
Jkorf	d88fb0d356	Added BloFin to ReadMe and examples	2025-09-17 10:01:17 +02:00
Jkorf	b8c6d55156	CryptoManager.Net reference	2025-09-02 11:43:44 +02:00
Jkorf	d9a5481db2	Updated to version 9.7.0	2025-09-01 13:37:16 +02:00
Jkorf	6a8bb42c0e	Updated CryptoExchange.Net for CryptoExchange.Net.Protobuf version to 9.7.0	2025-09-01 13:35:24 +02:00
Jkorf	2445f001ab	Updated to version 9.7.0	2025-09-01 13:18:16 +02:00
Jkorf	c84fa9ac32	Fixed test	2025-09-01 13:16:20 +02:00
Jkorf	d44a11c44e	HttpVersion update Added LibraryHelpers.CreateHttpClientMessageHandle to standardize HttpMessageHandler creation Added REST client option for selecting HTTP protocol version Added REST client option for HTTP client keep alive interval Added HttpVersion to WebCallResult responses Updated request logic to default to using HTTP version 2.0 for dotnet core	2025-09-01 10:12:59 +02:00
Jkorf	b215cccda4	Updated to version 9.6.0	2025-08-25 10:17:35 +02:00
Jkorf	3eda488361	Updated CryptoExchange.Net.Protobuf to CryptoExchange.Net version 9.5.0	2025-08-25 10:15:14 +02:00
Jkorf	993a44de35	Updated to version 9.6.0	2025-08-25 10:03:17 +02:00
Jkorf	99465f99a1	Fixed test	2025-08-25 10:00:42 +02:00
Jkorf	d42de1fe90	Added support for parsing REST response even though status indicates error	2025-08-25 09:58:03 +02:00
Jkorf	d0284c62c0	Removed obsolete attribute on Error.Code property, updated the description	2025-08-22 16:12:01 +02:00
Jkorf	d92f3b7904	Added better support for subscriptions without subscribe confirmation	2025-08-22 10:17:16 +02:00
Jkorf	3e1b5ada69	Added check in websocket for receiving 401 unauthorized http response status when 101 was expected	2025-08-21 13:39:07 +02:00
Jkorf	6156fb8154	Fixed test	2025-08-19 14:42:03 +02:00
Jkorf	f2753aed1e	Updated to version 9.5.0	2025-08-19 10:21:24 +02:00
Jkorf	e33d826381	Updated CryptoExchange.Net version to 9.5.0	2025-08-19 10:20:11 +02:00
Jkorf	364aa4d324	Updated to version 9.5.0	2025-08-19 10:07:07 +02:00
Jkorf	455b332757	Updated test methods	2025-08-19 10:05:14 +02:00
Jkorf	876b895645	Fixed warning	2025-08-19 10:01:49 +02:00
Jkorf	daf7ed9fe6	Refactored RestApiClient authentication to prevent duplicate query string / body serialization	2025-08-19 09:50:10 +02:00
Jan Korf	3e365f83c9	Error handling update	2025-08-18 11:03:26 +02:00
Jkorf	40977ebdbe	Fixed timing issue in query response processing	2025-08-07 14:15:18 +02:00
Jkorf	4a9058fc1c	Fix response type in websocket queries not interested in the response	2025-08-07 14:15:00 +02:00
JKorf	dab9a21608	Fixed IOrderBookSocketClient Shared interface not getting registered in DI	2025-08-04 17:12:34 +02:00
Jkorf	a89c222399	Updated to version 9.4.0	2025-08-04 09:56:45 +02:00
Jkorf	1e356d2a45	Updated CryptoExchange.Net and protobuf-net package versions for CryptoExchange.Net.Protobuf	2025-08-04 09:54:15 +02:00
Jkorf	eed794c2cf	Updated to version 9.4.0	2025-08-04 09:47:36 +02:00
Jkorf	2f82e2015b	Updated Shared symbol requests/subscriptions to allow multiple symbols in one call if supported	2025-08-04 09:39:30 +02:00
Jkorf	ad599badb2	Added CryptoExchange.Net tag	2025-07-29 16:02:38 +02:00
Jkorf	1e45c73f1d	Added CoinW to examples	2025-07-29 15:57:02 +02:00
Jkorf	49c1fda2c1	Added CoinW reference	2025-07-29 11:44:22 +02:00
Jkorf	32a31e464b	Updated to version 9.3.1	2025-07-29 09:42:53 +02:00
Jkorf	cddb4167e4	Added Id property to SharedPosition model	2025-07-28 15:58:36 +02:00
Jkorf	65457d8df2	Added BaseAndQuoteAssetAndContracts value to SharedQuantityType enum	2025-07-28 15:58:19 +02:00
Jkorf	122a6cad43	Updated to version 9.3.0	2025-07-23 10:52:40 +02:00
Jkorf	4c0e841425	Updated CryptoExchange.Net version	2025-07-23 10:51:17 +02:00
Jkorf	92f5839aec	Updated to version 9.3.0	2025-07-23 10:37:52 +02:00
Jan Korf	30475dae67	Feature/websocket listener update (#244 ) Updated websocket message to listener matching logic to be more flexible	2025-07-23 10:31:03 +02:00
Jkorf	3d942bd503	Updated decimal parser to support "NaN" and "-Infinity" strings, added check for negative overflow value, improved performance in most cases	2025-07-21 09:42:52 +02:00
Jkorf	f739520e52	Updated to version 9.2.1	2025-07-16 10:51:41 +02:00
Jkorf	0152603ddb	Added setting for whether or not to process unparsable websocket messages	2025-07-16 10:42:38 +02:00
Jkorf	aa06e0eead	Fixed issue causing duplicate subscriptions and data in the TradeTracker and KlineTracker when websocket connection was reconnected	2025-07-16 09:27:42 +02:00
Jkorf	2fde9a285e	Update README.md	2025-07-14 13:31:47 +02:00
Jkorf	b9f6eb6abb	Update README.md	2025-07-14 13:25:01 +02:00
Jkorf	d77c4354a6	Updated to version 9.2.0	2025-07-14 11:42:40 +02:00
Jkorf	21860ddf85	Updated CryptoExchange.Net reference for CryptoExchange.Protobuf.Net	2025-07-14 11:33:30 +02:00
Jkorf	2cffa22cc2	Updated to version 9.2.0	2025-07-14 11:06:30 +02:00
EricGarnier	985ba9bb29	Simplify ArrayConverter (#241 ) Co-authored-by: Eric GARNIER <ega@softfluent.com>	2025-07-14 10:57:48 +02:00
Jan Korf	96f23f163d	Feature/protobuf (#243 ) Protobuf implementation	2025-07-14 10:56:18 +02:00
Jkorf	0e7d49991a	Updated examples, added Toobit reference	2025-06-11 14:33:05 +02:00
Jkorf	3e635cf0fe	Updated to version 9.1.0	2025-05-28 15:03:32 +02:00
Jkorf	1425c66c69	Dependencies update * Updated dotnet package versions from 9.0.0 to 9.0.5 * Replaced Microsoft.Extensions.Logging.Abstractions with icrosoft.Extensions.Logging * Replaced Microsoft.Extensions.Options.ConfigurationExtensions with Microsoft.Extensions.Configuration.Binder, which includes a source generator for AOT publishing * Removed redundant Microsoft.Extensions.DependencyInjection.Abstractions package reference	2025-05-28 14:50:23 +02:00
Jkorf	fc3b7cc75b	Added JsonConverter implementation for SharedQuantity and SharedSymbol types	2025-05-28 14:26:55 +02:00
Jkorf	2cc2dc6ceb	Updated to version 9.0.1	2025-05-20 14:51:19 +02:00
Jkorf	7da8cedf66	Improved response time on CancellationToken cancel during subscribing	2025-05-20 14:49:43 +02:00
Jkorf	2cf10668dd	Added support for sending query without expecting a response	2025-05-19 16:06:45 +02:00
Jkorf	f1342b5ff2	Examples	2025-05-14 14:30:05 +02:00
JKorf	a04b636a11	Disable AOT warnings in testing code	2025-05-13 20:03:34 +02:00
Jkorf	e4637ad295	Disable warning for AOT in testing helpers	2025-05-13 15:53:13 +02:00
Jkorf	3a1e43dabe	Fixed framework check for setting IsAotCompatible project flag	2025-05-13 15:36:16 +02:00
Jkorf	10da1a7bfe	Fix documentation link	2025-05-13 15:10:15 +02:00
Jkorf	37320ca862	Docs	2025-05-13 15:08:30 +02:00
Jkorf	2074a5e26f	Updated to version 9.0.0	2025-05-13 10:28:12 +02:00
Jan Korf	6b14cdbf06	Feature/9.0.0 (#236 ) * Added support for Native AOT compilation * Updated all IEnumerable response types to array response types * Added Pass support for ApiCredentials, removing the need for most implementations to add their own ApiCredentials type * Added KeepAliveTimeout setting setting ping frame timeouts for SocketApiClient * Added IBookTickerRestClient Shared interface for requesting book tickers * Added ISpotTriggerOrderRestClient Shared interface for managing spot trigger orders * Added ISpotOrderClientIdClient Shared interface for managing spot orders by client order id * Added IFuturesTriggerOrderRestClient Shared interface for managing futures trigger orders * Added IFuturesOrderClientIdClient Shared interface for managing futures orders by client order id * Added IFuturesTpSlRestClient Shared interface for setting TP/SL on open futures positions * Added GenerateClientOrderId to ISpotOrderRestClient and IFuturesOrderRestClient interface * Added OptionalExchangeParameters and Supported properties to EndpointOptions * Refactor Shared interfaces quantity parameters and properties to use SharedQuantity * Added SharedSymbol property to Shared interface models returning a symbol * Added TriggerPrice, IsTriggerOrder, TakeProfitPrice, StopLossPrice and IsCloseOrder to SharedFuturesOrder response model * Added MaxShortLeverage and MaxLongLeverage to SharedFuturesSymbol response model * Added StopLossPrice and TakeProfitPrice to SharedPosition response model * Added TriggerPrice and IsTriggerOrder to SharedSpotOrder response model * Added QuoteVolume property to SharedSpotTicker response model * Added AssetAlias configuration models * Added static ExchangeSymbolCache for tracking symbol information from exchanges * Added static CallResult.SuccessResult to be used instead of constructing success CallResult instance * Added static ApplyRules, RandomHexString and RandomLong helper methods to ExchangeHelpers class * Added AsErrorWithData To CallResult * Added OriginalData property to CallResult * Added support for adjusting the rate limit key per call, allowing for ratelimiting depending on request parameters * Added implementation for integration testing ISymbolOrderBook instances * Added implementation for integration testing socket subscriptions * Added implementation for testing socket queries * Updated request cancellation logging to Debug level * Updated logging SourceContext to include the client type * Updated some logging logic, errors no longer contain any data, exception are not logged as string but instead forwarded to structured logging * Fixed warning for Enum parsing throwing exception and output warnings for each object in a response to only once to prevent slowing down execution * Fixed memory leak in AsyncAutoRestEvent * Fixed logging for ping frame timeout * Fixed warning getting logged when user stops SymbolOrderBook instance * Fixed socket client `UnsubscribeAll` not unsubscribing dedicated connections * Fixed memory leak in Rest client cache * Fixed integers bigger than int16 not getting correctly parsed to enums * Fixed issue where the default options were overridden when using SetApiCredentials * Removed Newtonsoft.Json dependency * Removed legacy Rest client code * Removed legacy ISpotClient and IFuturesClient support	2025-05-13 10:15:30 +02:00