.

Updated websocket message to listener matching logic to be more flexible

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

@@ -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;
+        }
+    }
+}

CryptoExchange.Net.Protobuf/Converters/Protobuf/ProtobufMessageSerializer.cs

@@ -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();
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0</TargetFrameworks>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PackageId>CryptoExchange.Net.Protobuf</PackageId>
+    <Authors>JKorf</Authors>
+    <Description>Protobuf support for CryptoExchange.Net</Description>
+    <PackageVersion>9.6.0</PackageVersion>
+    <AssemblyVersion>9.6.0</AssemblyVersion>
+    <FileVersion>9.6.0</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="9.6.0" />
+    <PackageReference Include="protobuf-net" Version="3.2.56" />
+  </ItemGroup>
+</Project>

CryptoExchange.Net.Protobuf/CryptoExchange.Net.Protobuf.xml

@@ -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>

CryptoExchange.Net.Protobuf/README.md

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

CryptoExchange.Net.UnitTests/CallResultTests.cs

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

CryptoExchange.Net.UnitTests/CryptoExchange.Net.UnitTests.csproj

@@ -6,10 +6,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0"></PackageReference>
+    <None Include="..\CryptoExchange.Net\.editorconfig" Link=".editorconfig" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1"></PackageReference>
     <PackageReference Include="Moq" Version="4.20.72" />
-    <PackageReference Include="NUnit" Version="4.2.2"></PackageReference>
+    <PackageReference Include="NUnit" Version="4.3.2"></PackageReference>
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0"></PackageReference>
+    <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"></PackageReference>
   </ItemGroup>
 
   <ItemGroup>

CryptoExchange.Net.UnitTests/RestClientTests.cs

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

CryptoExchange.Net.UnitTests/SystemTextJsonConverterTests.cs

@@ -7,6 +7,7 @@ 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 +224,17 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(null, null)]
         [TestCase("", null)]
         [TestCase("null", null)]
+        [TestCase("nan", null)]
         [TestCase("1E+2", 100)]
         [TestCase("1E-2", 0.01)]
-        [TestCase("80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        [TestCase("Infinity", 999)] // 999 is workaround for not being able to specify decimal.MinValue
+        [TestCase("-Infinity", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
+        [TestCase("80228162514264337593543950335", 999)] // 999 is workaround for not being able to specify decimal.MaxValue
+        [TestCase("-80228162514264337593543950335", -999)] // -999 is workaround for not being able to specify decimal.MaxValue
         public void TestDecimalConverterString(string value, decimal? expected)
         {
             var result = JsonSerializer.Deserialize<STJDecimalObject>("{ \"test\": \""+ value + "\"}");
-            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MaxValue : expected));
+            Assert.That(result.Test, Is.EqualTo(expected == -999 ? decimal.MinValue : expected == 999 ? decimal.MaxValue: expected));
         }
 
         [TestCase("1", 1)]
@@ -298,6 +303,40 @@ namespace CryptoExchange.Net.UnitTests
             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));
+        }
     }
 
     public class STJDecimalObject

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

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

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

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

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

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

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

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

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -10,6 +10,7 @@ using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using CryptoExchange.Net.UnitTests.TestImplementations;
@@ -55,7 +56,7 @@ namespace CryptoExchange.Net.UnitTests
             var accessor = CreateAccessor();
             var valid = accessor.Read(stream, true).Result;
             if (!valid)
-                return new CallResult<T>(new ServerError(data));
+                return new CallResult<T>(new ServerError(ErrorInfo.Unknown with { Message = data }));
             
             var deserializeResult = accessor.Deserialize<T>();
             return deserializeResult;
@@ -77,7 +78,7 @@ namespace CryptoExchange.Net.UnitTests
         {
         }
 
-        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, ref IDictionary<string, object> uriParams, ref IDictionary<string, object> bodyParams, ref Dictionary<string, string> headers, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, RequestBodyFormat bodyFormat)
+        public override void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig)
         {
         }
         

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

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

CryptoExchange.Net.UnitTests/TestImplementations/TestSocket.cs

@@ -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;
-//    }
-//}

CryptoExchange.Net.UnitTests/TestImplementations/TestSocketClient.cs

@@ -17,6 +17,7 @@ using CryptoExchange.Net.Testing.Implementations;
 using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Options;
 using CryptoExchange.Net.Converters.SystemTextJson;
+using System.Net.WebSockets;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
@@ -98,7 +99,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
         }
 
-        protected internal override IByteMessageAccessor CreateAccessor() => new SystemTextJsonByteMessageAccessor(new System.Text.Json.JsonSerializerOptions());
+        protected internal override IByteMessageAccessor CreateAccessor(WebSocketMessageType type) => new SystemTextJsonByteMessageAccessor(new System.Text.Json.JsonSerializerOptions());
         protected internal override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(new System.Text.Json.JsonSerializerOptions());
 
         /// <inheritdoc />
@@ -114,12 +115,12 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
         public CallResult ConnectSocketSub(SocketConnection sub)
         {
-            return ConnectSocketAsync(sub).Result;
+            return ConnectSocketAsync(sub, default).Result;
         }
 
         public override string GetListenerIdentifier(IMessageAccessor message)
         {
-            if (!message.IsJson)
+            if (!message.IsValid)
             {
                 return "topic";
             }

CryptoExchange.Net.sln

@@ -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

CryptoExchange.Net/.editorconfig

@@ -0,0 +1,183 @@
+root = true
+
+[*]
+
+# Indentation and spacing
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+charset = utf-8
+max_line_length = 140
+insert_final_newline = true
+
+# ReSharper code style properties
+resharper_csharp_keep_existing_embedded_arrangement = false
+resharper_csharp_place_accessorholder_attribute_on_same_line = false
+resharper_csharp_wrap_after_declaration_lpar = true
+resharper_csharp_wrap_parameters_style = chop_if_long
+resharper_csharp_blank_lines_around_single_line_auto_property = 1
+resharper_csharp_keep_blank_lines_in_declarations = 1
+resharper_trailing_comma_in_multiline_lists = true
+
+[*.cs]
+
+indent_size = 4
+
+# Code style conventions
+dotnet_style_predefined_type_for_member_access = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_object_initializer = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+csharp_style_expression_bodied_methods = true:suggestion
+csharp_style_namespace_declarations = file_scoped:warning
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
+dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
+csharp_prefer_braces = when_multiline:warning
+
+# Analyzer preferences
+dotnet_diagnostic.CA2007.severity = warning # Call ConfigureAwait on the awaited Task.
+dotnet_code_quality.CA2007.exclude_async_void_methods = true
+dotnet_code_quality.CA2007.output_kind = DynamicallyLinkedLibrary
+
+dotnet_diagnostic.CA1000.severity = none # Do not declare static members on generic types
+dotnet_diagnostic.CA1051.severity = none # Do not declare visible instance fields
+dotnet_diagnostic.CA1510.severity = none # Use ArgumentNullException throw helper
+dotnet_diagnostic.CA1720.severity = none # Identifiers should not contain type names
+dotnet_diagnostic.CA1716.severity = none # Identifiers should not match keywords
+dotnet_diagnostic.CA1835.severity = none # Use ArgumentNullException throw helper
+dotnet_diagnostic.CA1846.severity = none # Prefer AsSpan over Substring
+dotnet_diagnostic.CA1848.severity = none # Use the LoggerMessage delegates
+dotnet_diagnostic.CA1850.severity = none # Prefer static HashData method over ComputeHash
+dotnet_diagnostic.CA1866.severity = none # Use 'string.Method(char)' instead of 'string.Method(string)' for string with single char
+dotnet_diagnostic.CA2201.severity = none # Do not raise reserved exception types
+dotnet_diagnostic.CA2208.severity = none # Do not raise reserved exception types
+dotnet_diagnostic.IDE0005.severity = warning # Using directive is unnecessary
+
+[*.xml]
+ij_xml_space_inside_empty_tag = true
+[*.cs]
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = warning
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = warning
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.private_or_internal_field_should_be_fields_start_with__.severity = warning
+dotnet_naming_rule.private_or_internal_field_should_be_fields_start_with__.symbols = private_or_internal_field
+dotnet_naming_rule.private_or_internal_field_should_be_fields_start_with__.style = fields_start_with__
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+dotnet_naming_symbols.private_or_internal_field.applicable_kinds = field
+dotnet_naming_symbols.private_or_internal_field.applicable_accessibilities = internal, private, private_protected
+dotnet_naming_symbols.private_or_internal_field.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.fields_start_with__.required_prefix = _
+dotnet_naming_style.fields_start_with__.required_suffix = 
+dotnet_naming_style.fields_start_with__.word_separator = 
+dotnet_naming_style.fields_start_with__.capitalization = camel_case
+csharp_indent_labels = one_less_than_current
+csharp_using_directive_placement = outside_namespace:suggestion
+csharp_prefer_simple_using_statement = true:suggestion
+csharp_style_prefer_method_group_conversion = true:silent
+csharp_style_prefer_top_level_statements = true:silent
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_prefer_system_threading_lock = true:suggestion
+csharp_style_expression_bodied_constructors = false:silent
+csharp_style_expression_bodied_operators = false:silent
+csharp_style_expression_bodied_properties = true:suggestion
+csharp_style_expression_bodied_indexers = true:suggestion
+csharp_style_expression_bodied_accessors = true:suggestion
+csharp_style_expression_bodied_lambdas = true:silent
+csharp_style_expression_bodied_local_functions = true:silent
+
+[*.vb]
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, friend, private, protected, protected_friend, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, friend, private, protected, protected_friend, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+[*.{cs,vb}]
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4
+end_of_line = crlf
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion

CryptoExchange.Net/AssemblyInfo.cs

@@ -1,6 +1,5 @@
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("CryptoExchange.Net.UnitTests")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("CryptoExchange.Net.UnitTests")]
+
+namespace System.Runtime.CompilerServices;
 
-namespace System.Runtime.CompilerServices
-{
 internal static class IsExternalInit { }
-}

CryptoExchange.Net/Attributes/JsonConversionAttribute.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
+
+namespace CryptoExchange.Net.Attributes;
 
-namespace CryptoExchange.Net.Attributes
-{
 /// <summary>
 /// Used for conversion in ArrayConverter
 /// </summary>
@@ -9,4 +9,3 @@ namespace CryptoExchange.Net.Attributes
 public class JsonConversionAttribute: Attribute
 {
 }
-}

CryptoExchange.Net/Attributes/MapAttribute.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
+
+namespace CryptoExchange.Net.Attributes;
 
-namespace CryptoExchange.Net.Attributes
-{
 /// <summary>
 /// Map a enum entry to string values
 /// </summary>
@@ -22,4 +22,3 @@ namespace CryptoExchange.Net.Attributes
         Values = maps;
     }
 }
-}

CryptoExchange.Net/Authentication/ApiCredentials.cs

@@ -1,10 +1,7 @@
-using System;
+using System;
-using System.IO;
+
-using CryptoExchange.Net.Converters.SystemTextJson;
+namespace CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Converters.MessageParsing;
 
-namespace CryptoExchange.Net.Authentication
-{
 /// <summary>
 /// Api credentials, used to sign requests accessing private endpoints
 /// </summary>
@@ -57,4 +54,3 @@ namespace CryptoExchange.Net.Authentication
         return new ApiCredentials(Key, Secret, Pass, CredentialType);
     }
 }
-}

CryptoExchange.Net/Authentication/ApiCredentialsType.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Authentication
+namespace CryptoExchange.Net.Authentication;
-{
+
 /// <summary>
 /// Credentials type
 /// </summary>
@@ -18,4 +18,3 @@
     /// </summary>
     RsaPem
 }
-}

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -1,16 +1,15 @@
-using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.Net.Http;
 using System.Security.Cryptography;
 using System.Text;
 
-namespace CryptoExchange.Net.Authentication
+namespace CryptoExchange.Net.Authentication;
-{
+
 /// <summary>
 /// Base class for authentication providers
 /// </summary>
@@ -51,30 +50,11 @@ namespace CryptoExchange.Net.Authentication
     }
 
     /// <summary>
-        /// Authenticate a request. Output parameters should include the providedParameters input
+    /// Authenticate a request
     /// </summary>
     /// <param name="apiClient">The Api client sending the request</param>
-        /// <param name="uri">The uri for the request</param>
+    /// <param name="requestConfig">The request configuration</param>
-        /// <param name="method">The method of the request</param>
+    public abstract void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig);
-        /// <param name="auth">If the requests should be authenticated</param>
-        /// <param name="arraySerialization">Array serialization type</param>
-        /// <param name="requestBodyFormat">The formatting of the request body</param>
-        /// <param name="uriParameters">Parameters that need to be in the Uri of the request. Should include the provided parameters if they should go in the uri</param>
-        /// <param name="bodyParameters">Parameters that need to be in the body of the request. Should include the provided parameters if they should go in the body</param>
-        /// <param name="headers">The headers that should be send with the request</param>
-        /// <param name="parameterPosition">The position where the providedParameters should go</param>
-        public abstract void AuthenticateRequest(
-            RestApiClient apiClient,
-            Uri uri,
-            HttpMethod method,
-            ref IDictionary<string, object>? uriParameters,
-            ref IDictionary<string, object>? bodyParameters,
-            ref Dictionary<string, string>? headers,
-            bool auth,
-            ArrayParametersSerialization arraySerialization,
-            HttpMethodParameterPosition parameterPosition,
-            RequestBodyFormat requestBodyFormat
-            );
 
     /// <summary>
     /// SHA256 sign the data and return the bytes
@@ -228,7 +208,9 @@ namespace CryptoExchange.Net.Authentication
     /// <returns></returns>
     protected static string SignMD5(string data, SignOutputType? outputType = null)
     {
+#pragma warning disable CA5351
         using var encryptor = MD5.Create();
+#pragma warning restore CA5351
         var resultBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
         return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
     }
@@ -241,7 +223,9 @@ namespace CryptoExchange.Net.Authentication
     /// <returns></returns>
     protected static string SignMD5(byte[] data, SignOutputType? outputType = null)
     {
+#pragma warning disable CA5351
         using var encryptor = MD5.Create();
+#pragma warning restore CA5351
         var resultBytes = encryptor.ComputeHash(data);
         return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
     }
@@ -253,7 +237,9 @@ namespace CryptoExchange.Net.Authentication
     /// <returns></returns>
     protected static byte[] SignMD5Bytes(string data)
     {
+#pragma warning disable CA5351
         using var encryptor = MD5.Create();
+#pragma warning restore CA5351
         return encryptor.ComputeHash(Encoding.UTF8.GetBytes(data));
     }
 
@@ -465,10 +451,13 @@ namespace CryptoExchange.Net.Authentication
     /// <returns></returns>
     protected static string GetSerializedBody(IMessageSerializer serializer, IDictionary<string, object> parameters)
     {
+        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 serializer.Serialize(value);
+            return stringSerializer.Serialize(value);
         else
-                return serializer.Serialize(parameters);
+            return stringSerializer.Serialize(parameters);
     }
 }
 
@@ -476,7 +465,11 @@ namespace CryptoExchange.Net.Authentication
 public abstract class AuthenticationProvider<TApiCredentials> : AuthenticationProvider where TApiCredentials : ApiCredentials
 {
     /// <inheritdoc />
+#pragma warning disable IDE1006 // Naming Styles
+#pragma warning disable CA1707 // Naming Styles
     protected new TApiCredentials _credentials => (TApiCredentials)base._credentials;
+#pragma warning restore IDE1006 // Naming Styles
+#pragma warning restore CA1707 // Naming Styles
 
     /// <summary>
     /// ctor
@@ -486,4 +479,3 @@ namespace CryptoExchange.Net.Authentication
     {
     }
 }
-}

CryptoExchange.Net/Authentication/SignOutputType.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Authentication
+namespace CryptoExchange.Net.Authentication;
-{
+
 /// <summary>
 /// Output string type
 /// </summary>
@@ -14,4 +14,3 @@
     /// </summary>
     Base64
 }
-}

CryptoExchange.Net/Caching/MemoryCache.cs

@@ -1,9 +1,9 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Linq;
 
-namespace CryptoExchange.Net.Caching
+namespace CryptoExchange.Net.Caching;
-{
+
 internal class MemoryCache
 {
     private readonly ConcurrentDictionary<string, CacheItem> _cache = new ConcurrentDictionary<string, CacheItem>();
@@ -50,4 +50,3 @@ namespace CryptoExchange.Net.Caching
         }
     }
 }
-}

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -1,13 +1,13 @@
 using System;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Logging;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <summary>
 /// Base API for all API clients
 /// </summary>
@@ -54,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>
@@ -87,6 +92,16 @@ namespace CryptoExchange.Net.Clients
     /// <inheritdoc />
     public abstract string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
 
+    /// <summary>
+    /// Get error info for a response code
+    /// </summary>
+    public ErrorInfo GetErrorInfo(int code, string? message = null) => GetErrorInfo(code.ToString(), message);
+
+    /// <summary>
+    /// Get error info for a response code
+    /// </summary>
+    public ErrorInfo GetErrorInfo(string code, string? message = null) => ErrorMapping.GetErrorInfo(code.ToString(), message);
+
     /// <inheritdoc />
     public void SetApiCredentials<T>(T credentials) where T : ApiCredentials
     {
@@ -109,9 +124,17 @@ namespace CryptoExchange.Net.Clients
     /// <summary>
     /// Dispose
     /// </summary>
-        public virtual void Dispose()
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Dispose
+    /// </summary>
+    public virtual void Dispose(bool disposing)
     {
         _disposing = true;
     }
 }
-}

CryptoExchange.Net/Clients/BaseClient.cs

@@ -1,12 +1,11 @@
-using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
 using System;
 using System.Collections.Generic;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <summary>
 /// The base for all clients, websocket client and rest client
 /// </summary>
@@ -80,7 +79,7 @@ namespace CryptoExchange.Net.Clients
             throw new ArgumentNullException(nameof(options));
 
         ClientOptions = options;
-            _logger.Log(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{CryptoExchangeLibVersion}, {Exchange}.Net: v{ExchangeLibVersion}");
+        _logger.Log(LogLevel.Trace, "Client configuration: {Options}, CryptoExchange.Net: v{CryptoExchangeVersion}, {Exchange}.Net: v{ExchangeVersion}", options, CryptoExchangeLibVersion, Exchange, ExchangeLibVersion);
     }
 
     /// <summary>
@@ -102,7 +101,7 @@ 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}");
+        _logger.Log(LogLevel.Trace, "  {ApiClient}, base address: {BaseAddress}", apiClient.GetType().Name, apiClient.BaseAddress);
         ApiClients.Add(apiClient);
         return apiClient;
     }
@@ -120,11 +119,24 @@ namespace CryptoExchange.Net.Clients
     /// <summary>
     /// Dispose
     /// </summary>
-        public virtual void Dispose()
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Dispose
+    /// </summary>
+    public virtual void Dispose(bool disposing)
+    {
+        if (disposing)
         {
             _logger.Log(LogLevel.Debug, "Disposing client");
             foreach (var client in ApiClients)
                 client.Dispose();
         }
     }
+
+
 }

CryptoExchange.Net/Clients/BaseRestClient.cs

@@ -3,8 +3,8 @@ using CryptoExchange.Net.Interfaces;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <summary>
 /// Base rest client
 /// </summary>
@@ -23,4 +23,3 @@ namespace CryptoExchange.Net.Clients
         _logger = loggerFactory?.CreateLogger(name + ".RestClient") ?? NullLoggerFactory.Instance.CreateLogger(name);
     }
 }
-}

CryptoExchange.Net/Clients/BaseSocketClient.cs

@@ -1,17 +1,16 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using System.Xml.Linq;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects.Sockets;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <summary>
 /// Base for socket client implementations
 /// </summary>
@@ -129,4 +128,3 @@ namespace CryptoExchange.Net.Clients
         return result;
     }
 }
-}

CryptoExchange.Net/Clients/CryptoBaseClient.cs

@@ -1,9 +1,9 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <summary>
 /// Base crypto client
 /// </summary>
@@ -59,9 +59,20 @@ namespace CryptoExchange.Net.Clients
     /// <summary>
     /// Dispose
     /// </summary>
-        public void Dispose()
+    public void Dispose(bool disposing)
+    {
+        if (disposing)
         {
             _serviceCache.Clear();
         }
     }
+
+    /// <summary>
+    /// Dispose
+    /// </summary>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
 }

CryptoExchange.Net/Clients/CryptoRestClient.cs

@@ -1,11 +1,8 @@
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces;
-using Microsoft.Extensions.DependencyInjection;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <inheritdoc />
 public class CryptoRestClient : CryptoBaseClient, ICryptoRestClient
 {
@@ -24,4 +21,3 @@ namespace CryptoExchange.Net.Clients
     {
     }
 }
-}

CryptoExchange.Net/Clients/CryptoSocketClient.cs

@@ -1,8 +1,8 @@
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces;
 using System;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <inheritdoc />
 public class CryptoSocketClient : CryptoBaseClient, ICryptoSocketClient
 {
@@ -21,4 +21,3 @@ namespace CryptoExchange.Net.Clients
     {
     }
 }
-}

CryptoExchange.Net/Clients/RestApiClient.cs

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

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.RateLimiting;
@@ -16,8 +17,8 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Clients
+namespace CryptoExchange.Net.Clients;
-{
+
 /// <summary>
 /// Base socket API client for interaction with a websocket API
 /// </summary>
@@ -82,6 +83,11 @@ namespace CryptoExchange.Net.Clients
     /// </summary>
     protected bool AllowTopicsOnTheSameConnection { get; set; } = true;
 
+    /// <summary>
+    /// Whether to continue processing and forward unparsable messages to handlers
+    /// </summary>
+    protected internal bool ProcessUnparsableMessages { get; set; }
+
     /// <inheritdoc />
     public double IncomingKbps
     {
@@ -138,7 +144,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
@@ -244,7 +250,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!);
 
@@ -260,15 +266,15 @@ namespace CryptoExchange.Net.Clients
         if (socketConnection.PausedActivity)
         {
             _logger.HasBeenPausedCantSubscribeAtThisMoment(socketConnection.SocketId);
-                return new CallResult<UpdateSubscription>(new ServerError("Socket is paused"));
+            return new CallResult<UpdateSubscription>(new ServerError(new ErrorInfo(ErrorType.WebsocketPaused, "Socket is paused")));
         }
 
         var waitEvent = new AsyncResetEvent(false);
-            var subQuery = subscription.GetSubQuery(socketConnection);
+        var subQuery = subscription.CreateSubscriptionQuery(socketConnection);
         if (subQuery != null)
         {
             // Send the request and wait for answer
-                var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, waitEvent).ConfigureAwait(false);
+            var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, waitEvent, ct).ConfigureAwait(false);
             if (!subResult)
             {
                 waitEvent?.Set();
@@ -308,11 +314,10 @@ namespace CryptoExchange.Net.Clients
     /// Send a query on a socket connection to the BaseAddress and wait for the response
     /// </summary>
     /// <typeparam name="THandlerResponse">Expected result type</typeparam>
-        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
     /// <param name="query">The query</param>
     /// <param name="ct">Cancellation token</param>
     /// <returns></returns>
-        protected virtual Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(Query<TServerResponse, THandlerResponse> query, CancellationToken ct = default)
+    protected virtual Task<CallResult<THandlerResponse>> QueryAsync<THandlerResponse>(Query<THandlerResponse> query, CancellationToken ct = default)
     {
         return QueryAsync(BaseAddress, query, ct);
     }
@@ -321,12 +326,11 @@ namespace CryptoExchange.Net.Clients
     /// Send a query on a socket connection and wait for the response
     /// </summary>
     /// <typeparam name="THandlerResponse">Expected result type</typeparam>
-        /// <typeparam name="TServerResponse">The type returned to the caller</typeparam>
     /// <param name="url">The url for the request</param>
     /// <param name="query">The query</param>
     /// <param name="ct">Cancellation token</param>
     /// <returns></returns>
-        protected virtual async Task<CallResult<THandlerResponse>> QueryAsync<TServerResponse, THandlerResponse>(string url, Query<TServerResponse, THandlerResponse> query, CancellationToken ct = default)
+    protected virtual async Task<CallResult<THandlerResponse>> QueryAsync<THandlerResponse>(string url, Query<THandlerResponse> query, CancellationToken ct = default)
     {
         if (_disposing)
             return new CallResult<THandlerResponse>(new InvalidOperationError("Client disposed, can't query"));
@@ -336,7 +340,13 @@ namespace CryptoExchange.Net.Clients
 
         SocketConnection socketConnection;
         var released = false;
-            await semaphoreSlim.WaitAsync().ConfigureAwait(false);
+
+        try
+        {
+            await semaphoreSlim.WaitAsync(ct).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { }
+
         try
         {
             var socketResult = await GetSocketConnection(url, query.Authenticated, true).ConfigureAwait(false);
@@ -352,7 +362,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!);
         }
@@ -365,7 +375,7 @@ namespace CryptoExchange.Net.Clients
         if (socketConnection.PausedActivity)
         {
             _logger.HasBeenPausedCantSendQueryAtThisMoment(socketConnection.SocketId);
-                return new CallResult<THandlerResponse>(new ServerError("Socket is paused"));
+            return new CallResult<THandlerResponse>(new ServerError(new ErrorInfo(ErrorType.WebsocketPaused, "Socket is paused")));
         }
 
         if (ct.IsCancellationRequested)
@@ -379,18 +389,25 @@ 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(SocketConnection 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;
 
         if (ClientOptions.DelayAfterConnect != TimeSpan.Zero)
-                await Task.Delay(ClientOptions.DelayAfterConnect).ConfigureAwait(false);
+        {
+            try
+            {
+                await Task.Delay(ClientOptions.DelayAfterConnect, ct).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException) { }
+        }
 
         if (!authenticated || socket.Authenticated)
             return CallResult.SuccessResult;
@@ -579,10 +596,11 @@ 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(SocketConnection 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);
@@ -714,7 +732,7 @@ namespace CryptoExchange.Net.Clients
             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!);
         }
@@ -809,7 +827,7 @@ namespace CryptoExchange.Net.Clients
                         sb.AppendLine($"\t\t\tId: {subState.Id}");
                         sb.AppendLine($"\t\t\tConfirmed: {subState.Confirmed}");
                         sb.AppendLine($"\t\t\tInvocations: {subState.Invocations}");
-                            sb.AppendLine($"\t\t\tIdentifiers: [{string.Join(",", subState.Identifiers)}]");
+                        sb.AppendLine($"\t\t\tIdentifiers: [{subState.ListenMatcher.ToString()}]");
                     });
                 }
             });
@@ -821,8 +839,11 @@ namespace CryptoExchange.Net.Clients
     /// <summary>
     /// Dispose the client
     /// </summary>
-        public override void Dispose()
+    public override void Dispose(bool disposing)
     {
+        if (disposing)
+            return;
+
         _disposing = true;
         var tasks = new List<Task>();
         {
@@ -837,7 +858,7 @@ namespace CryptoExchange.Net.Clients
         }
 
         semaphoreSlim?.Dispose();
-            base.Dispose();
+        base.Dispose(disposing);
     }
 
     /// <summary>
@@ -856,4 +877,3 @@ namespace CryptoExchange.Net.Clients
     /// <returns></returns>
     public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
 }
-}

CryptoExchange.Net/Converters/ArrayPropertyAttribute.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
+
+namespace CryptoExchange.Net.Converters;
 
-namespace CryptoExchange.Net.Converters
-{
 /// <summary>
 /// Mark property as an index in the array
 /// </summary>
@@ -22,4 +22,3 @@ namespace CryptoExchange.Net.Converters
         Index = index;
     }
 }
-}

CryptoExchange.Net/Converters/JsonSerializerContextCache.cs

@@ -1,11 +1,9 @@
-using System;
+using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Text;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters
+namespace CryptoExchange.Net.Converters;
-{
+
 /// <summary>
 /// Caching for JsonSerializerContext instances
 /// </summary>
@@ -28,4 +26,3 @@ namespace CryptoExchange.Net.Converters
         return instance;
     }
 }
-}

CryptoExchange.Net/Converters/MessageParsing/MessageNode.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Converters.MessageParsing
+namespace CryptoExchange.Net.Converters.MessageParsing;
-{
+
 /// <summary>
 /// Node accessor
 /// </summary>
@@ -46,4 +46,3 @@
     /// <returns></returns>
     public static NodeAccessor PropertyName() { return new NodeAccessor(null, null, 2); }
 }
-}

CryptoExchange.Net/Converters/MessageParsing/MessagePath.cs

@@ -1,8 +1,8 @@
-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 
-namespace CryptoExchange.Net.Converters.MessageParsing
+namespace CryptoExchange.Net.Converters.MessageParsing;
-{
+
 /// <summary>
 /// Message access definition
 /// </summary>
@@ -47,4 +47,3 @@ namespace CryptoExchange.Net.Converters.MessageParsing
         return GetEnumerator();
     }
 }
-}

CryptoExchange.Net/Converters/MessageParsing/MessagePathExtension.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Converters.MessageParsing
+namespace CryptoExchange.Net.Converters.MessageParsing;
-{
+
 /// <summary>
 /// Message path extension methods
 /// </summary>
@@ -40,4 +40,3 @@
         return path;
     }
 }
-}

CryptoExchange.Net/Converters/MessageParsing/NodeType.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Converters.MessageParsing
+namespace CryptoExchange.Net.Converters.MessageParsing;
-{
+
 /// <summary>
 /// Message node type
 /// </summary>
@@ -18,4 +18,3 @@
     /// </summary>
     Value
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/ArrayConverter.cs

@@ -1,18 +1,17 @@
-using System;
+using System;
-using System.Collections.Concurrent;
 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;
+#if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
+#endif
 using System.Threading;
-using System.Diagnostics;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Converter for arrays to objects. Can deserialize data like [0.1, 0.2, "test"] to an object. Mapping is done by marking the class with [JsonConverter(typeof(ArrayConverter))] and the properties
 /// with [ArrayProperty(x)] where x is the index of the property in the array
@@ -25,8 +24,6 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 {
     private static readonly Lazy<List<ArrayPropertyInfo>> _typePropertyInfo = new Lazy<List<ArrayPropertyInfo>>(CacheTypeAttributes, LazyThreadSafetyMode.PublicationOnly);
     
-        private static readonly ConcurrentDictionary<JsonConverter, JsonSerializerOptions> _converterOptionsCache = new ConcurrentDictionary<JsonConverter, JsonSerializerOptions>();
-
     /// <inheritdoc />
 #if NET5_0_OR_GREATER
     [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
@@ -100,17 +97,17 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         if (reader.TokenType == JsonTokenType.Null)
             return default;
 
-            var result = Activator.CreateInstance(typeof(T))!;
+        var result = new T();
-            return (T)ParseObject(ref reader, result, typeof(T), options);
+        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 object ParseObject(ref Utf8JsonReader reader, object result, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type objectType, JsonSerializerOptions options)
+    private static T ParseObject(ref Utf8JsonReader reader, T result, JsonSerializerOptions options)
 #else
-        private static object ParseObject(ref Utf8JsonReader reader, object result, Type objectType, JsonSerializerOptions options)
+    private static T ParseObject(ref Utf8JsonReader reader, T result, JsonSerializerOptions options)
 #endif
     {
         if (reader.TokenType != JsonTokenType.StartArray)
@@ -135,20 +132,19 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                 object? value = null;
                 if (attribute.JsonConverter != null)
                 {
-                        if (!_converterOptionsCache.TryGetValue(attribute.JsonConverter, out var newOptions))
+                    if (attribute.JsonSerializerOptions == null)
                     {
-                            newOptions = new JsonSerializerOptions
+                        attribute.JsonSerializerOptions = 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);
+                    value = doc.Deserialize(attribute.PropertyInfo.PropertyType, attribute.JsonSerializerOptions);
                 }
                 else if (attribute.DefaultDeserialization)
                 {
@@ -231,6 +227,6 @@ 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; }
     }
 }

CryptoExchange.Net/Converters/SystemTextJson/BigDecimalConverter.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Decimal converter that handles overflowing decimal values (by setting it to decimal.MaxValue)
 /// </summary>
@@ -43,4 +43,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         writer.WriteNumberValue(value);
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/BoolConverter.cs

@@ -1,11 +1,11 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Bool converter
 /// </summary>
@@ -28,7 +28,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
             => (T)((object?)ReadBool(ref reader, typeToConvert, options) ?? default(T))!;
         
-            public bool? ReadBool(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        public static bool? ReadBool(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             if (reader.TokenType == JsonTokenType.True)
                 return true;
@@ -81,4 +81,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
     }
 
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/CommaSplitEnumConverter.cs

@@ -1,13 +1,13 @@
-using System;
+using System;
-using System.Collections.Generic;
+#if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
+#endif
 using System.Linq;
-using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Converter for comma separated enum values
 /// </summary>
@@ -34,4 +34,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         writer.WriteStringValue(string.Join(",", value.Select(x => EnumConverter.GetString(x))));
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/DateTimeConverter.cs

@@ -1,12 +1,12 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Date time converter
 /// </summary>
@@ -34,7 +34,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
             => (T)((object?)ReadDateTime(ref reader, typeToConvert, options) ?? default(T))!;
 
-            private DateTime? ReadDateTime(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        private static DateTime? ReadDateTime(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             if (reader.TokenType == JsonTokenType.Null)
             {
@@ -239,4 +239,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
     [return: NotNullIfNotNull("time")]
     public static long? ConvertToNanoseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).Ticks / _ticksPerNanosecond);
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/DecimalConverter.cs

@@ -1,10 +1,9 @@
-using System;
+using System;
-using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Decimal converter
 /// </summary>
@@ -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 ExchangeHelpers.ParseDecimal(value);
-                    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;
-                }
         }
 
         try
@@ -57,4 +41,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             writer.WriteNumberValue(value.Value);
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/DecimalStringWriterConverter.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Converter for serializing decimal values as string
 /// </summary>
@@ -20,4 +20,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
     public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
         => writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture) ?? null);
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/EnumConverter.cs

@@ -1,4 +1,4 @@
-using CryptoExchange.Net.Attributes;
+using CryptoExchange.Net.Attributes;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -9,8 +9,8 @@ using System.Reflection;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Static EnumConverter methods
 /// </summary>
@@ -64,8 +64,8 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #endif
      : JsonConverter<T>, INullableConverterFactory where T : struct, Enum
 {
-        private static List<KeyValuePair<T, string>>? _mapping = null;
+    private static List<KeyValuePair<T, string>>? _mapping;
-        private NullableEnumConverter? _nullableEnumConverter = null;
+    private NullableEnumConverter? _nullableEnumConverter;
 
     private static ConcurrentBag<string> _unknownValuesWarned = new ConcurrentBag<string>();
 
@@ -79,7 +79,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         }
         public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-                return _enumConverter.ReadNullable(ref reader, typeToConvert, options, out var isEmptyString, out var warn);
+            return EnumConverter<T>.ReadNullable(ref reader, typeToConvert, options, out var isEmptyString, out var warn);
         }
 
         public override void Write(Utf8JsonWriter writer, T? value, JsonSerializerOptions options)
@@ -122,7 +122,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         }
     }
 
-        private T? ReadNullable(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, out bool isEmptyString, out bool warn)
+    private static T? ReadNullable(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, out bool isEmptyString, out bool warn)
     {
         isEmptyString = false;
         warn = false;
@@ -286,4 +286,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         return _nullableEnumConverter;
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/EnumIntWriterConverter.cs

@@ -1,10 +1,9 @@
-using System;
+using System;
-using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Converter for serializing enum values as int
 /// </summary>
@@ -20,4 +19,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
     public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
         => writer.WriteNumberValue((int)(object)value);
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/INullableConverterFactory.cs

@@ -1,9 +1,8 @@
-using System.Text.Json.Serialization;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
-{
 internal interface INullableConverterFactory
 {
     JsonConverter CreateNullableConverter();
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/IntConverter.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Int converter
 /// </summary>
@@ -37,4 +37,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             writer.WriteNumberValue(value.Value);
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/LongConverter.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Int converter
 /// </summary>
@@ -37,4 +37,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             writer.WriteNumberValue(value.Value);
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/NullableEnumConverterFactory.cs

@@ -1,12 +1,10 @@
-using System;
+using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Text.Json.Serialization.Metadata;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 internal class NullableEnumConverterFactory : JsonConverterFactory
 {
     private readonly IJsonTypeInfoResolver _jsonTypeInfoResolver;
@@ -40,4 +38,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         return nullConverterFactory.CreateNullableConverter();
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/NumberStringConverter.cs

@@ -1,9 +1,9 @@
-using System;
+using System;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Read string or number as string
 /// </summary>
@@ -39,4 +39,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         writer.WriteStringValue(value);
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/ObjectStringConverter.cs

@@ -1,10 +1,12 @@
-using System;
+using System;
 using System.Text.Json.Serialization;
 using System.Text.Json;
+#if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace CryptoExchange.Net.Converters.SystemTextJson;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
-{
 /// <summary>
 /// Converter for values which contain a nested json value
 /// </summary>
@@ -24,7 +26,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         if (string.IsNullOrEmpty(value))
             return default;
 
-            return (T?)JsonDocument.Parse(value!).Deserialize(typeof(T), options);
+        return JsonDocument.Parse(value!).Deserialize<T>(options);
     }
 
     /// <inheritdoc />
@@ -40,4 +42,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         writer.WriteStringValue(JsonSerializer.Serialize(value, options));
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/ReplaceConverter.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Linq;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Replace a value on a string property
 /// </summary>
@@ -19,7 +19,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
     {
         _replacementSets = replaceSets.Select(x =>
         {
-                var split = x.Split(new string[] { "->" }, StringSplitOptions.None);
+            var split = x.Split(["->"], StringSplitOptions.None);
             if (split.Length != 2)
                 throw new ArgumentException("Invalid replacement config");
             return (split[0], split[1]);
@@ -38,4 +38,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
     /// <inheritdoc />
     public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) => writer.WriteStringValue(value);
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/SerializationModel.cs

@@ -1,9 +1,7 @@
-using System;
+using System;
-using System.Collections.Generic;
+
-using System.Text;
+namespace CryptoExchange.Net.Converters.SystemTextJson;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
-{
 /// <summary>
 /// Attribute to mark a model as json serializable. Used for AOT compilation.
 /// </summary>
@@ -20,4 +18,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
     /// <param name="type"></param>
     public SerializationModelAttribute(Type type) { }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/SerializerOptions.cs

@@ -1,9 +1,9 @@
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// Serializer options
 /// </summary>
@@ -44,4 +44,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         return options;
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/SharedQuantityConverter.cs

@@ -0,0 +1,57 @@
+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();
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/SharedSymbolConverter.cs

@@ -0,0 +1,43 @@
+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();
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

@@ -1,16 +1,17 @@
-using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Converters.MessageParsing;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using System;
-using System.Collections.Generic;
+#if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
+#endif
 using System.IO;
 using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <summary>
 /// System.Text.Json message accessor
 /// </summary>
@@ -24,7 +25,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 +48,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 +61,12 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         }
         catch (JsonException ex)
         {
-                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+            var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
             return new CallResult<object>(new DeserializeError(info, ex));
         }
         catch (Exception ex)
         {
-                var info = $"Deserialize unknown Exception: {ex.Message}";
+            return new CallResult<object>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-                return new CallResult<object>(new DeserializeError(info, ex));
         }
     }
 
@@ -87,20 +87,19 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         }
         catch (JsonException ex)
         {
-                var info = $"Deserialize JsonException: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+            var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
             return new CallResult<T>(new DeserializeError(info, ex));
         }
         catch (Exception ex)
         {
-                var info = $"Unknown exception: {ex.Message}";
+            return new CallResult<T>(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
-                return new CallResult<T>(new DeserializeError(info, ex));
         }
     }
 
     /// <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 +116,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 +138,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);
@@ -173,7 +172,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #endif
     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);
@@ -188,7 +187,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
     private JsonElement? GetPathNode(MessagePath path)
     {
-            if (!IsJson)
+        if (!IsValid)
             throw new InvalidOperationException("Can't access json data on non-json message");
 
         if (_document == null)
@@ -242,7 +241,9 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 /// <summary>
 /// System.Text.Json stream message accessor
 /// </summary>
+#pragma warning disable CA1001 // Types that own disposable fields should be disposable
 public class SystemTextJsonStreamMessageAccessor : SystemTextJsonMessageAccessor, IStreamMessageAccessor
+#pragma warning restore CA1001 // Types that own disposable fields should be disposable
 {
     private Stream? _stream;
 
@@ -279,14 +280,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;
+            IsValid = false;
-                return new CallResult(new DeserializeError("JsonError: " + ex.Message, ex));
+            return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
         }
     }
 
@@ -337,19 +338,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;
+                IsValid = false;
-                    return new CallResult(new ServerError("Not a json value"));
+                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;
+            IsValid = false;
-                return new CallResult(new DeserializeError("JsonError: " + ex.Message, ex));
+            return new CallResult(new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
         }
     }
 
@@ -373,4 +374,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         _document = null;
     }
 }
-}

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageSerializer.cs

@@ -1,13 +1,13 @@
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces;
+#if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
+#endif
 using System.Text.Json;
-using System.Text.Json.Serialization;
-using System.Text.Json.Serialization.Metadata;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson
+namespace CryptoExchange.Net.Converters.SystemTextJson;
-{
+
 /// <inheritdoc />
-    public class SystemTextJsonMessageSerializer : IMessageSerializer
+public class SystemTextJsonMessageSerializer : IStringMessageSerializer
 {
     private readonly JsonSerializerOptions _options;
 
@@ -26,4 +26,3 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 #endif
     public string Serialize<T>(T message) => JsonSerializer.Serialize(message, _options);
 }
-}

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -6,11 +6,11 @@
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
     <Description>CryptoExchange.Net is a base library which is used to implement different cryptocurrency (exchange) API's. It provides a standardized way of implementing different API's, which results in a very similar experience for users of the API implementations.</Description>
-    <PackageVersion>9.0.0</PackageVersion>
+    <PackageVersion>9.6.0</PackageVersion>
-    <AssemblyVersion>9.0.0</AssemblyVersion>
+    <AssemblyVersion>9.6.0</AssemblyVersion>
-    <FileVersion>9.0.0</FileVersion>
+    <FileVersion>9.6.0</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange</PackageTags>
+    <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/JKorf/CryptoExchange.Net.git</RepositoryUrl>
     <PackageProjectUrl>https://github.com/JKorf/CryptoExchange.Net</PackageProjectUrl>
@@ -24,10 +24,11 @@
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
   <ItemGroup>
+    <None Include="C:\Projects\CryptoExchange.Net\CryptoExchange.Net\.editorconfig" />
     <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' ">
+  <PropertyGroup Label="AOT" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
     <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
   <PropertyGroup Label="Deterministic Build" Condition="'$(Configuration)' == 'Release'">
@@ -37,15 +38,15 @@
     <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>
+  <PropertyGroup>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <AnalysisMode>Recommended</AnalysisMode>
+    <AnalysisModeGlobalization>None</AnalysisModeGlobalization>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+  </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="ConfigureAwaitChecker.Analyzer" Version="5.0.0.1">
       <PrivateAssets>all</PrivateAssets>
@@ -57,10 +58,14 @@
     </PackageReference>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.6" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.0" />
+    <PackageReference Include="System.Text.Json" Version="9.0.6" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0" />
+  </ItemGroup>
-    <PackageReference Include="System.Text.Json" Version="9.0.0" />
+  <ItemGroup Label="Transitive Client Packages">
-    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="9.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.6" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.6" />
+  </ItemGroup>
+  <ItemGroup>
+    <EditorConfigFiles Remove="C:\Projects\CryptoExchange.Net\CryptoExchange.Net\.editorconfig" />
   </ItemGroup>
 </Project>

CryptoExchange.Net/ExchangeHelpers.cs

@@ -1,14 +1,17 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Runtime.CompilerServices;
+#if NETSTANDARD2_1_OR_GREATER || NET9_0_OR_GREATER
 using System.Security.Cryptography;
+#endif
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net
+namespace CryptoExchange.Net;
-{
+
 /// <summary>
 /// General helpers functions
 /// </summary>
@@ -286,16 +289,16 @@ namespace CryptoExchange.Net
     /// <summary>
     /// Execute multiple requests to retrieve multiple pages of the result set
     /// </summary>
-        /// <typeparam name="T">Type of the client</typeparam>
+    /// <typeparam name="TResult">Type of the client</typeparam>
-        /// <typeparam name="U">Type of the request</typeparam>
+    /// <typeparam name="TRequest">Type of the request</typeparam>
     /// <param name="paginatedFunc">The func to execute with each request</param>
     /// <param name="request">The request parameters</param>
     /// <param name="ct">Cancellation token</param>
     /// <returns></returns>
-        public static async IAsyncEnumerable<ExchangeWebResult<T[]>> ExecutePages<T, U>(Func<U, INextPageToken?, CancellationToken, Task<ExchangeWebResult<T[]>>> paginatedFunc, U request, [EnumeratorCancellation]CancellationToken ct = default)
+    public static async IAsyncEnumerable<ExchangeWebResult<TResult[]>> ExecutePages<TResult, TRequest>(Func<TRequest, INextPageToken?, CancellationToken, Task<ExchangeWebResult<TResult[]>>> paginatedFunc, TRequest request, [EnumeratorCancellation]CancellationToken ct = default)
     {
-            var result = new List<T>();
+        var result = new List<TResult>();
-            ExchangeWebResult<T[]> batch;
+        ExchangeWebResult<TResult[]> batch;
         INextPageToken? nextPageToken = null;
         while (true)
         {
@@ -341,5 +344,47 @@ namespace CryptoExchange.Net
         adjustedQuantity = symbol.QuantityDecimals.HasValue ? (minNotionalAdjust ? RoundUp(adjustedQuantity, symbol.QuantityDecimals.Value) : RoundDown(adjustedQuantity, symbol.QuantityDecimals.Value)) : adjustedQuantity;
 
     }
+
+    /// <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;
     }
 }

CryptoExchange.Net/ExchangeSymbolCache.cs

@@ -1,12 +1,11 @@
-using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 
-namespace CryptoExchange.Net
+namespace CryptoExchange.Net;
-{
+
 /// <summary>
 /// Cache for symbol parsing
 /// </summary>
@@ -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.ToUpperInvariant(), x.QuoteAsset.ToUpperInvariant(), (x as SharedFuturesSymbol)?.DeliveryTime) { SymbolName = x.Name }));                
+            exchangeInfo = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x.SharedSymbol));                
             _symbolInfos.TryAdd(topicId, exchangeInfo);
         }
 
         if (DateTime.UtcNow - exchangeInfo.UpdateTime < TimeSpan.FromMinutes(60))
             return;
 
-            _symbolInfos[topicId] = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => new SharedSymbol(x.TradingMode, x.BaseAsset.ToUpperInvariant(), x.QuoteAsset.ToUpperInvariant(), (x as SharedFuturesSymbol)?.DeliveryTime) { SymbolName = x.Name }));
+        _symbolInfos[topicId] = new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x.SharedSymbol));
     }
 
     /// <summary>
@@ -67,4 +66,3 @@ namespace CryptoExchange.Net
         }
     }
 }
-}

CryptoExchange.Net/ExtensionMethods.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO.Compression;
 using System.IO;
@@ -10,12 +10,9 @@ 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
+namespace CryptoExchange.Net;
-{
+
 /// <summary>
 /// Helper methods
 /// </summary>
@@ -498,8 +495,8 @@ namespace CryptoExchange.Net
             services.AddTransient(x => (IBookTickerSocketClient)client(x)!);
         if (typeof(IKlineSocketClient).IsAssignableFrom(typeof(T)))
             services.AddTransient(x => (IKlineSocketClient)client(x)!);
-            if (typeof(IOrderBookRestClient).IsAssignableFrom(typeof(T)))
+        if (typeof(IOrderBookSocketClient).IsAssignableFrom(typeof(T)))
-                services.AddTransient(x => (IOrderBookRestClient)client(x)!);
+            services.AddTransient(x => (IOrderBookSocketClient)client(x)!);
         if (typeof(ITickerSocketClient).IsAssignableFrom(typeof(T)))
             services.AddTransient(x => (ITickerSocketClient)client(x)!);
         if (typeof(ITickersSocketClient).IsAssignableFrom(typeof(T)))
@@ -520,5 +517,4 @@ namespace CryptoExchange.Net
         return services;
     }
 }
-}
 

CryptoExchange.Net/Interfaces/IAuthTimeProvider.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
+
+namespace CryptoExchange.Net.Interfaces;
 
-namespace CryptoExchange.Net.Interfaces
-{
 /// <summary>
 /// Time provider
 /// </summary>
@@ -13,4 +13,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     DateTime GetTime();
 }
-}

CryptoExchange.Net/Interfaces/IBaseApiClient.cs

@@ -1,11 +1,10 @@
-using CryptoExchange.Net.Authentication;
+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;
-{
+
 /// <summary>
 /// Base api client
 /// </summary>
@@ -45,4 +44,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <param name="options">Options to set</param>
     void SetOptions<T>(UpdateOptions<T> options) where T : ApiCredentials;
 }
-}

CryptoExchange.Net/Interfaces/ICryptoRestClient.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
+
+namespace CryptoExchange.Net.Interfaces;
 
-namespace CryptoExchange.Net.Interfaces
-{
 /// <summary>
 /// Client for accessing REST API's for different exchanges
 /// </summary>
@@ -14,4 +14,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     T TryGet<T>(Func<T> createFunc);
 }
-}

CryptoExchange.Net/Interfaces/ICryptoSocketClient.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
+
+namespace CryptoExchange.Net.Interfaces;
 
-namespace CryptoExchange.Net.Interfaces
-{
 /// <summary>
 /// Client for accessing Websocket API's for different exchanges
 /// </summary>
@@ -14,4 +14,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     T TryGet<T>(Func<T> createFunc);
 }
-}

CryptoExchange.Net/Interfaces/IMessageAccessor.cs

@@ -1,21 +1,23 @@
-using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Converters.MessageParsing;
 using CryptoExchange.Net.Objects;
 using System;
-using System.Collections.Generic;
+#if NET5_0_OR_GREATER
+using System.Diagnostics.CodeAnalysis;
+#endif
 using System.IO;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Message accessor
 /// </summary>
 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>
@@ -59,12 +61,20 @@ namespace CryptoExchange.Net.Interfaces
     /// <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>
@@ -98,4 +108,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <param name="data"></param>
     CallResult Read(ReadOnlyMemory<byte> data);
 }
-}

CryptoExchange.Net/Interfaces/IMessageProcessor.cs

@@ -1,12 +1,11 @@
-using CryptoExchange.Net.Objects;
+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
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Message processor
 /// </summary>
@@ -17,22 +16,13 @@ namespace CryptoExchange.Net.Interfaces
     /// </summary>
     public int Id { get; }
     /// <summary>
-        /// The identifiers for this processor
+    /// The matcher for this listener
     /// </summary>
-        public HashSet<string> ListenerIdentifiers { get; }
+    public MessageMatcher MessageMatcher { get; }
     /// <summary>
     /// Handle a message
     /// </summary>
-        /// <param name="connection"></param>
+    Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message, MessageHandlerLink matchedHandler);
-        /// <param name="message"></param>
-        /// <returns></returns>
-        Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message);
-        /// <summary>
-        /// Get the type the message should be deserialized to
-        /// </summary>
-        /// <param name="messageAccessor"></param>
-        /// <returns></returns>
-        Type? GetMessageType(IMessageAccessor messageAccessor);
     /// <summary>
     /// Deserialize a message into object of type
     /// </summary>
@@ -41,4 +31,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     CallResult<object> Deserialize(IMessageAccessor accessor, Type type);
 }
-}

CryptoExchange.Net/Interfaces/IMessageSerializer.cs

@@ -1,9 +1,29 @@
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// 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
@@ -12,4 +32,3 @@
     /// <returns></returns>
     string Serialize<T>(T message);
 }
-}

CryptoExchange.Net/Interfaces/INonceProvider.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// A provider for a nonce value used when signing requests
 /// </summary>
@@ -11,4 +11,3 @@
     /// <returns>Nonce value</returns>
     long GetNonce();
 }
-}

CryptoExchange.Net/Interfaces/IOrderBookFactory.cs

@@ -1,9 +1,9 @@
-using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
 using System;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Factory for ISymbolOrderBook instances
 /// </summary>
@@ -32,4 +32,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     public ISymbolOrderBook Create(SharedSymbol symbol, Action<TOptions>? options = null);
 }
-}

CryptoExchange.Net/Interfaces/IRateLimiter.cs

@@ -4,8 +4,8 @@ using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Rate limiter interface
 /// </summary>
@@ -25,4 +25,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns>The time in milliseconds spend waiting</returns>
     Task<CallResult<int>> LimitRequestAsync(ILogger log, string endpoint, HttpMethod method, bool signed, string? apiKey, RateLimitingBehaviour limitBehaviour, int requestWeight, CancellationToken ct);
 }
-}

CryptoExchange.Net/Interfaces/IRequest.cs

@@ -1,11 +1,11 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Request interface
 /// </summary>
@@ -63,4 +63,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     Task<IResponse> GetResponseAsync(CancellationToken cancellationToken);
 }
-}

CryptoExchange.Net/Interfaces/IRequestFactory.cs

@@ -1,9 +1,9 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects;
 using System;
 using System.Net.Http;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Request factory interface
 /// </summary>
@@ -33,4 +33,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <param name="requestTimeout">Request timeout to use</param>
     void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout);
 }
-}

CryptoExchange.Net/Interfaces/IResponse.cs

@@ -1,10 +1,10 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Net;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Response object interface
 /// </summary>
@@ -41,4 +41,3 @@ namespace CryptoExchange.Net.Interfaces
     /// </summary>
     void Close();
 }
-}

CryptoExchange.Net/Interfaces/IRestApiClient.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Base rest API client
 /// </summary>
@@ -15,4 +15,3 @@
     /// </summary>
     int TotalRequestsMade { get; set; }
 }
-}

CryptoExchange.Net/Interfaces/IRestClient.cs

@@ -1,8 +1,8 @@
-using System;
+using System;
 using CryptoExchange.Net.Objects.Options;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Base class for rest API implementations
 /// </summary>
@@ -23,4 +23,3 @@ namespace CryptoExchange.Net.Interfaces
     /// </summary>
     string Exchange { get; }
 }
-}

CryptoExchange.Net/Interfaces/ISocketApiClient.cs

@@ -1,10 +1,10 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Socket API client
 /// </summary>
@@ -67,4 +67,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     Task<CallResult> PrepareConnectionsAsync();
 }
-}

CryptoExchange.Net/Interfaces/ISocketClient.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.Objects.Sockets;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Base class for socket API implementations
 /// </summary>
@@ -55,4 +55,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     Task UnsubscribeAllAsync();
 }
-}

CryptoExchange.Net/Interfaces/ISymbolOrderBook.cs

@@ -1,11 +1,10 @@
-using System;
+using System;
-using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Objects;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Interface for order book
 /// </summary>
@@ -128,4 +127,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     string ToString(int rows);
 }
-}

CryptoExchange.Net/Interfaces/ISymbolOrderBookEntry.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Interface for order book entries
 /// </summary>
@@ -25,4 +25,3 @@
     /// </summary>
     long Sequence { get; set; }
 }
-}

CryptoExchange.Net/Interfaces/IWebsocket.cs

@@ -1,10 +1,11 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects;
 using System;
 using System.Net.WebSockets;
+using System.Threading;
 using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Websocket connection interface
 /// </summary>
@@ -75,15 +76,22 @@ namespace CryptoExchange.Net.Interfaces
     /// Connect the socket
     /// </summary>
     /// <returns></returns>
-        Task<CallResult> ConnectAsync();
+    Task<CallResult> ConnectAsync(CancellationToken ct);
     /// <summary>
-        /// Send data
+    /// Send string data
     /// </summary>
     /// <param name="id"></param>
     /// <param name="data"></param>
     /// <param name="weight"></param>
     bool Send(int id, string data, int weight);
     /// <summary>
+    /// Send byte data
+    /// </summary>
+    /// <param name="id"></param>
+    /// <param name="data"></param>
+    /// <param name="weight"></param>
+    bool Send(int id, byte[] data, int weight);
+    /// <summary>
     /// Reconnect the socket
     /// </summary>
     /// <returns></returns>
@@ -99,4 +107,3 @@ namespace CryptoExchange.Net.Interfaces
     /// </summary>
     void UpdateProxy(ApiProxy? proxy);
 }
-}

CryptoExchange.Net/Interfaces/IWebsocketFactory.cs

@@ -1,8 +1,8 @@
-using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Objects.Sockets;
 using Microsoft.Extensions.Logging;
 
-namespace CryptoExchange.Net.Interfaces
+namespace CryptoExchange.Net.Interfaces;
-{
+
 /// <summary>
 /// Websocket factory interface
 /// </summary>
@@ -16,4 +16,3 @@ namespace CryptoExchange.Net.Interfaces
     /// <returns></returns>
     IWebsocket CreateWebsocket(ILogger logger, WebSocketParameters parameters);
 }
-}

CryptoExchange.Net/LibraryHelpers.cs

@@ -1,9 +1,5 @@
-using System;
+namespace CryptoExchange.Net;
-using System.Collections.Generic;
-using System.Text;
 
-namespace CryptoExchange.Net
-{
 /// <summary>
 /// Helpers for client libraries
 /// </summary>
@@ -44,4 +40,3 @@ namespace CryptoExchange.Net
         return clientOrderId;
     }
 }
-}

CryptoExchange.Net/Logging/Extensions/CryptoExchangeWebSocketClientLoggingExtension.cs

@@ -1,13 +1,14 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using System;
 
-namespace CryptoExchange.Net.Logging.Extensions
+namespace CryptoExchange.Net.Logging.Extensions;
-{
+
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 public static class CryptoExchangeWebSocketClientLoggingExtension
 {
     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,10 @@ namespace CryptoExchange.Net.Logging.Extensions
     {
         _socketPingTimeout(logger, socketId, null);
     }
+
+    public static void SocketConnectingCanceled(
+        this ILogger logger, int socketId)
+    {
+        _connectingCanceled(logger, socketId, null);
     }
 }

CryptoExchange.Net/Logging/Extensions/RateLimitGateLoggingExtensions.cs

@@ -1,8 +1,8 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using System;
 
-namespace CryptoExchange.Net.Logging.Extensions
+namespace CryptoExchange.Net.Logging.Extensions;
-{
+
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 public static class RateLimitGateLoggingExtensions
 {
@@ -76,4 +76,3 @@ namespace CryptoExchange.Net.Logging.Extensions
         _rateLimitAppliedRequest(logger, requestIdId, path, guard, limit, current, null);
     }
 }
-}

CryptoExchange.Net/Logging/Extensions/RestApiClientLoggingExtensions.cs

@@ -1,11 +1,11 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Net;
 using System.Net.Http;
 
-namespace CryptoExchange.Net.Logging.Extensions
+namespace CryptoExchange.Net.Logging.Extensions;
-{
+
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 public static class RestApiClientLoggingExtensions
 {
@@ -156,4 +156,3 @@ namespace CryptoExchange.Net.Logging.Extensions
         _restApiCancellationRequested(logger, requestId, null);
     }
 }
-}

CryptoExchange.Net/Logging/Extensions/SocketApiClientLoggingExtension.cs

@@ -1,8 +1,8 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using System;
 
-namespace CryptoExchange.Net.Logging.Extensions
+namespace CryptoExchange.Net.Logging.Extensions;
-{
+
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 public static class SocketApiClientLoggingExtension
 {
@@ -197,4 +197,3 @@ namespace CryptoExchange.Net.Logging.Extensions
         _addingRetryAfterGuard(logger, retryAfter, null);
     }
 }
-}

CryptoExchange.Net/Logging/Extensions/SocketConnectionLoggingExtension.cs

@@ -1,9 +1,9 @@
-using System;
+using System;
 using System.Net.WebSockets;
 using Microsoft.Extensions.Logging;
 
-namespace CryptoExchange.Net.Logging.Extensions
+namespace CryptoExchange.Net.Logging.Extensions;
-{
+
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 public static class SocketConnectionLoggingExtension
 {
@@ -15,9 +15,10 @@ namespace CryptoExchange.Net.Logging.Extensions
     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()
     {
@@ -90,11 +92,6 @@ namespace CryptoExchange.Net.Logging.Extensions
             new EventId(2009, "ErrorProcessingMessage"),
             "[Sckt {SocketId}] error processing message");
 
-            _processorMatched = LoggerMessage.Define<int, int, string>(
-                LogLevel.Trace,
-                new EventId(2010, "ProcessorMatched"),
-                "[Sckt {SocketId}] {Count} processor(s) matched to message with listener identifier {ListenerId}");
-
         _receivedMessageNotRecognized = LoggerMessage.Define<int, int>(
             LogLevel.Warning,
             new EventId(2011, "ReceivedMessageNotRecognized"),
@@ -188,7 +185,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)
@@ -230,6 +243,12 @@ namespace CryptoExchange.Net.Logging.Extensions
     {
         _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,9 +257,9 @@ namespace CryptoExchange.Net.Logging.Extensions
     {
         _errorProcessingMessage(logger, socketId, e);
     }
-        public static void ProcessorMatched(this ILogger logger, int socketId, int count, string listenerId)
+    public static void ProcessorMatched(this ILogger logger, int socketId, string listener, string listenerId)
     {
-            _processorMatched(logger, socketId, count, listenerId, null);
+        _processorMatched(logger, socketId, listener, listenerId, null);
     }
     public static void ReceivedMessageNotRecognized(this ILogger logger, int socketId, int id)
     {
@@ -321,5 +340,9 @@ 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);
     }
 }

CryptoExchange.Net/Logging/Extensions/SymbolOrderBookLoggingExtensions.cs

@@ -1,9 +1,9 @@
-using System;
+using System;
 using CryptoExchange.Net.Objects;
 using Microsoft.Extensions.Logging;
 
-namespace CryptoExchange.Net.Logging.Extensions
+namespace CryptoExchange.Net.Logging.Extensions;
-{
+
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
 public static class SymbolOrderBookLoggingExtensions
@@ -234,4 +234,3 @@ namespace CryptoExchange.Net.Logging.Extensions
         _orderBookOutOfSyncChecksum(logger, api, symbol, null);
     }
 }
-}

CryptoExchange.Net/Logging/Extensions/TrackerLoggingExtensions.cs

@@ -1,9 +1,9 @@
-using System;
+using System;
 using CryptoExchange.Net.Objects;
 using Microsoft.Extensions.Logging;
 
-namespace CryptoExchange.Net.Logging.Extensions
+namespace CryptoExchange.Net.Logging.Extensions;
-{
+
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
 public static class TrackerLoggingExtensions
@@ -288,4 +288,3 @@ namespace CryptoExchange.Net.Logging.Extensions
         _tradeTrackerConnectionRestored(logger, symbol, null);
     }
 }
-}

CryptoExchange.Net/Objects/ApiProxy.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Objects
+namespace CryptoExchange.Net.Objects;
-{
+
 /// <summary>
 /// Proxy info
 /// </summary>
@@ -39,4 +39,3 @@
         Password = password;
     }
 }
-}

CryptoExchange.Net/Objects/AssetAlias.cs

@@ -1,9 +1,5 @@
-using System;
+namespace CryptoExchange.Net.Objects;
-using System.Collections.Generic;
-using System.Text;
 
-namespace CryptoExchange.Net.Objects
-{
 /// <summary>
 /// An alias used by the exchange for an asset commonly known by another name
 /// </summary>
@@ -27,4 +23,3 @@ namespace CryptoExchange.Net.Objects
         CommonAssetName = commonName;
     }
 }
-}

CryptoExchange.Net/Objects/AssetAliasConfiguration.cs

@@ -1,10 +1,7 @@
-using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 
-namespace CryptoExchange.Net.Objects
+namespace CryptoExchange.Net.Objects;
-{
+
 /// <summary>
 /// Exchange configuration for asset aliases
 /// </summary>
@@ -31,4 +28,3 @@ namespace CryptoExchange.Net.Objects
     public string ExchangeToCommonName(string exchangeName) => !AutoConvertEnabled ? exchangeName : Aliases.SingleOrDefault(x => x.ExchangeAssetName == exchangeName)?.CommonAssetName ?? exchangeName;
 
 }
-}