Updated to version 10.2.0

Added EnforceSequenceNumbers property on SocketApiClient to configure whether websocket message contain sequence numbers and if these should be checked to be sequential
Added fallback to existing websocket connection if no dedicated request connection was found
Added IntBoolConverter base class for arbitrary int value to bool mapping
Added SequenceNumber property to DataEvent object
Added _skipSequenceCheckFirstUpdateAfterSnapshotSet property for SymbolOrderBook implementations
Updated SymbolOrderBook sequenceNumber validation
Updated SymbolOrderBook log verbosities
Renamed SetInitialOrderBook to SetSnapshot in SymbolOrderBook
Renamed updateId references to sequenceNumber in SymbolOrderBook

.github/workflows/dotnet.yml

@@ -16,7 +16,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: 9.0.x
+        dotnet-version: 10.0.x
     - name: Restore dependencies
       run: dotnet restore
     - name: Build

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

@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0;net10.0</TargetFrameworks>
   </PropertyGroup>
   <PropertyGroup>
     <PackageId>CryptoExchange.Net.Protobuf</PackageId>
     <Authors>JKorf</Authors>
     <Description>Protobuf support for CryptoExchange.Net</Description>
-    <PackageVersion>9.6.0</PackageVersion>
+    <PackageVersion>10.0.1</PackageVersion>
-    <AssemblyVersion>9.6.0</AssemblyVersion>
+    <AssemblyVersion>10.0.1</AssemblyVersion>
-    <FileVersion>9.6.0</FileVersion>
+    <FileVersion>10.0.1</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>CryptoExchange;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>
@@ -41,7 +41,7 @@
     <DocumentationFile>CryptoExchange.Net.Protobuf.xml</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="CryptoExchange.Net" Version="9.6.0" />
+    <PackageReference Include="CryptoExchange.Net" Version="10.0.2" />
     <PackageReference Include="protobuf-net" Version="3.2.56" />
   </ItemGroup>
 </Project>

CryptoExchange.Net.Protobuf/README.md

@@ -5,6 +5,36 @@
 Protobuf support for CryptoExchange.Net.
 
 ## Release notes
+* Version 10.0.1 - 16 Dec 2025
+    * Updated CryptoExchange.Net version to 10.0.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 10.0.0 - 16 Dec 2025
+    * Updated CryptoExchange.Net version to 10.0.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.13.0 - 10 Nov 2025
+    * Updated CryptoExchange.Net version to 9.13.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.12.0 - 03 Nov 2025
+    * Updated CryptoExchange.Net version to 9.12.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.11.1 - 30 Oct 2025
+    * Updated CryptoExchange.Net version to 9.11.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.11.0 - 30 Oct 2025
+    * Updated CryptoExchange.Net version to 9.11.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.10.0 - 15 Oct 2025
+    * Updated CryptoExchange.Net version to 9.10.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.9.0 - 06 Oct 2025
+    * Updated CryptoExchange.Net version to 9.9.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.8.0 - 30 Sep 2025
+    * Updated CryptoExchange.Net version to 9.8.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.7.0 - 01 Sep 2025
+    * Updated CryptoExchange.Net version to 9.7.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
 * Version 9.6.0 - 25 Aug 2025
     * Updated CryptoExchange.Net version to 9.6.0
 

CryptoExchange.Net.UnitTests/AsyncResetEventTests.cs

@@ -4,7 +4,6 @@ using NUnit.Framework.Legacy;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.UnitTests

CryptoExchange.Net.UnitTests/BaseClientTests.cs

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

CryptoExchange.Net.UnitTests/CallResultTests.cs

@@ -4,10 +4,8 @@ using NUnit.Framework;
 using NUnit.Framework.Legacy;
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Net;
 using System.Net.Http;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.UnitTests
 {
@@ -113,7 +111,8 @@ namespace CryptoExchange.Net.UnitTests
         {
             var result = new WebCallResult<TestObjectResult>(
                 System.Net.HttpStatusCode.OK,
-                new KeyValuePair<string, string[]>[0],
+                HttpVersion.Version11,
+                new HttpResponseMessage().Headers,
                 TimeSpan.FromSeconds(1),
                 null,
                 "{}",
@@ -121,7 +120,7 @@ namespace CryptoExchange.Net.UnitTests
                 "https://test.com/api",
                 null,
                 HttpMethod.Get,
-                new KeyValuePair<string, string[]>[0],
+                new HttpRequestMessage().Headers,
                 ResultDataSource.Server,
                 new TestObjectResult(),
                 null);
@@ -143,7 +142,8 @@ namespace CryptoExchange.Net.UnitTests
         {
             var result = new WebCallResult<TestObjectResult>(
                 System.Net.HttpStatusCode.OK,
-                new KeyValuePair<string, string[]>[0],
+                HttpVersion.Version11,
+                new HttpResponseMessage().Headers,
                 TimeSpan.FromSeconds(1),
                 null,
                 "{}",
@@ -151,7 +151,7 @@ namespace CryptoExchange.Net.UnitTests
                 "https://test.com/api",
                 null,
                 HttpMethod.Get,
-                new KeyValuePair<string, string[]>[0],
+                new HttpRequestMessage().Headers,
                 ResultDataSource.Server,
                 new TestObjectResult(),
                 null);

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

@@ -1,19 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <None Include="..\CryptoExchange.Net\.editorconfig" Link=".editorconfig" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1"></PackageReference>
-  </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.3.2"></PackageReference>
+    <PackageReference Include="NUnit" Version="4.4.0"></PackageReference>
-    <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"></PackageReference>
+    <PackageReference Include="NUnit3TestAdapter" Version="6.0.1"></PackageReference>
   </ItemGroup>
 
   <ItemGroup>

CryptoExchange.Net.UnitTests/ExchangeHelpersTests.cs

@@ -1,7 +1,5 @@
 using CryptoExchange.Net.Objects;
 using NUnit.Framework;
-using NUnit.Framework.Legacy;
-using System.Diagnostics;
 using System.Globalization;
 
 namespace CryptoExchange.Net.UnitTests
@@ -32,6 +30,7 @@ namespace CryptoExchange.Net.UnitTests
         [TestCase(0.1, 1, 0.0001, RoundingType.Closest, 0.532, 0.532)]
         [TestCase(0.1, 1, 0.0001, RoundingType.Down, 0.5516592, 0.5516)]
         [TestCase(0.1, 1, 0.0001, RoundingType.Closest, 0.5516592, 0.5517)]
+        [TestCase(0, 1, 0.000000001, RoundingType.Closest, 0.0000097232, 0.000009723)]
         public void AdjustValueStepTests(decimal min, decimal max, decimal? step, RoundingType roundingType, decimal input, decimal expected)
         {
             var result = ExchangeHelpers.AdjustValueStep(min, max, step, roundingType, input);

CryptoExchange.Net.UnitTests/OptionsTests.cs

@@ -1,15 +1,8 @@
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.UnitTests.TestImplementations;
-using Microsoft.Extensions.Logging;
 using NUnit.Framework;
-using NUnit.Framework.Legacy;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.UnitTests
 {

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -9,7 +9,6 @@ using System.Threading.Tasks;
 using System.Threading;
 using NUnit.Framework.Legacy;
 using CryptoExchange.Net.RateLimiting;
-using System.Net;
 using CryptoExchange.Net.RateLimiting.Guards;
 using CryptoExchange.Net.RateLimiting.Filters;
 using CryptoExchange.Net.RateLimiting.Interfaces;

CryptoExchange.Net.UnitTests/SocketClientTests.cs

@@ -1,231 +1,234 @@
-using System;
+//using CryptoExchange.Net.Objects;
-using System.Collections.Generic;
+//using CryptoExchange.Net.Objects.Sockets;
-using System.Text.Json;
+//using CryptoExchange.Net.Sockets;
-using System.Threading;
+//using CryptoExchange.Net.Testing.Implementations;
-using System.Threading.Tasks;
+//using CryptoExchange.Net.UnitTests.TestImplementations;
-using CryptoExchange.Net.Objects;
+//using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
-using CryptoExchange.Net.Objects.Sockets;
+//using Microsoft.Extensions.Logging;
-using CryptoExchange.Net.Sockets;
+//using Moq;
-using CryptoExchange.Net.UnitTests.TestImplementations;
+//using NUnit.Framework;
-using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
+//using NUnit.Framework.Legacy;
-using Microsoft.Extensions.Logging;
+//using System;
-using Moq;
+//using System.Collections.Generic;
-using NUnit.Framework;
+//using System.Net.Sockets;
-using NUnit.Framework.Legacy;
+//using System.Text.Json;
+//using System.Threading;
+//using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.UnitTests
+//namespace CryptoExchange.Net.UnitTests
-{
+//{
-    [TestFixture]
+//    [TestFixture]
-    public class SocketClientTests
+//    public class SocketClientTests
-    {
+//    {
-        [TestCase]
+//        [TestCase]
-        public void SettingOptions_Should_ResultInOptionsSet()
+//        public void SettingOptions_Should_ResultInOptionsSet()
-        {
+//        {
-            //arrange
+//            //arrange
-            //act
+//            //act
-            var client = new TestSocketClient(options =>
+//            var client = new TestSocketClient(options =>
-            {
+//            {
-                options.SubOptions.ApiCredentials = new Authentication.ApiCredentials("1", "2");
+//                options.SubOptions.ApiCredentials = new Authentication.ApiCredentials("1", "2");
-                options.SubOptions.MaxSocketConnections = 1;
+//                options.SubOptions.MaxSocketConnections = 1;
-            });
+//            });
 
-            //assert
+//            //assert
-            ClassicAssert.NotNull(client.SubClient.ApiOptions.ApiCredentials);
+//            ClassicAssert.NotNull(client.SubClient.ApiOptions.ApiCredentials);
-            Assert.That(1 == client.SubClient.ApiOptions.MaxSocketConnections);
+//            Assert.That(1 == client.SubClient.ApiOptions.MaxSocketConnections);
-        }
+//        }
 
-        [TestCase(true)]
+//        [TestCase(true)]
-        [TestCase(false)]
+//        [TestCase(false)]
-        public void ConnectSocket_Should_ReturnConnectionResult(bool canConnect)
+//        public void ConnectSocket_Should_ReturnConnectionResult(bool canConnect)
-        {
+//        {
-            //arrange
+//            //arrange
-            var client = new TestSocketClient();
+//            var client = new TestSocketClient();
-            var socket = client.CreateSocket();
+//            var socket = client.CreateSocket();
-            socket.CanConnect = canConnect;
+//            socket.CanConnect = canConnect;
 
-            //act
+//            //act
-            var connectResult = client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, null));
+//            var connectResult = client.SubClient.ConnectSocketSub(
+//                new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));
 
-            //assert
+//            //assert
-            Assert.That(connectResult.Success == canConnect);
+//            Assert.That(connectResult.Success == canConnect);
-        }
+//        }
 
-        [TestCase]
+//        [TestCase]
-        public void SocketMessages_Should_BeProcessedInDataHandlers()
+//        public void SocketMessages_Should_BeProcessedInDataHandlers()
-        {
+//        {
-            // arrange
+//            // arrange
-            var client = new TestSocketClient(options => {
+//            var client = new TestSocketClient(options => {
-                options.ReconnectInterval = TimeSpan.Zero;
+//                options.ReconnectInterval = TimeSpan.Zero;
-            });
+//            });
-            var socket = client.CreateSocket();
+//            var socket = client.CreateSocket();
-            socket.CanConnect = true;
+//            socket.CanConnect = true;
-            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
+//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-            var rstEvent = new ManualResetEvent(false);
+//            var rstEvent = new ManualResetEvent(false);
-            Dictionary<string, string> result = null;
+//            Dictionary<string, string> result = null;
 
-            client.SubClient.ConnectSocketSub(sub);
+//            client.SubClient.ConnectSocketSub(sub);
 
-            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
+//            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
-            {
+//            {
-                result = messageEvent.Data;
+//                result = messageEvent.Data;
-                rstEvent.Set();
+//                rstEvent.Set();
-            });
+//            });
-            sub.AddSubscription(subObj);
+//            sub.AddSubscription(subObj);
 
-            // act
+//            // act
-            socket.InvokeMessage("{\"property\": \"123\", \"action\": \"update\", \"topic\": \"topic\"}");
+//            socket.InvokeMessage("{\"property\": \"123\", \"action\": \"update\", \"topic\": \"topic\"}");
-            rstEvent.WaitOne(1000);
+//            rstEvent.WaitOne(1000);
 
-            // assert
+//            // assert
-            Assert.That(result["property"] == "123");
+//            Assert.That(result["property"] == "123");
-        }
+//        }
 
-        [TestCase(false)]
+//        [TestCase(false)]
-        [TestCase(true)]
+//        [TestCase(true)]
-        public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
+//        public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
-        {
+//        {
-            // arrange
+//            // arrange
-            var client = new TestSocketClient(options =>
+//            var client = new TestSocketClient(options =>
-            {
+//            {
-                options.ReconnectInterval = TimeSpan.Zero;
+//                options.ReconnectInterval = TimeSpan.Zero;
-                options.SubOptions.OutputOriginalData = enabled;
+//                options.SubOptions.OutputOriginalData = enabled;
-            });
+//            });
-            var socket = client.CreateSocket();
+//            var socket = client.CreateSocket();
-            socket.CanConnect = true;
+//            socket.CanConnect = true;
-            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
+//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-            var rstEvent = new ManualResetEvent(false);
+//            var rstEvent = new ManualResetEvent(false);
-            string original = null;
+//            string original = null;
 
-            client.SubClient.ConnectSocketSub(sub);
+//            client.SubClient.ConnectSocketSub(sub);
-            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
+//            var subObj = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) =>
-            {
+//            {
-                original = messageEvent.OriginalData;
+//                original = messageEvent.OriginalData;
-                rstEvent.Set();
+//                rstEvent.Set();
-            });
+//            });
-            sub.AddSubscription(subObj);
+//            sub.AddSubscription(subObj);
-            var msgToSend = JsonSerializer.Serialize(new { topic = "topic", action = "update", property = "123" });
+//            var msgToSend = JsonSerializer.Serialize(new { topic = "topic", action = "update", property = "123" });
 
-            // act
+//            // act
-            socket.InvokeMessage(msgToSend);
+//            socket.InvokeMessage(msgToSend);
-            rstEvent.WaitOne(1000);
+//            rstEvent.WaitOne(1000);
 
-            // assert
+//            // assert
-            Assert.That(original == (enabled ? msgToSend : null));
+//            Assert.That(original == (enabled ? msgToSend : null));
-        }
+//        }
 
-        [TestCase()]
+//        [TestCase()]
-        public void UnsubscribingStream_Should_CloseTheSocket()
+//        public void UnsubscribingStream_Should_CloseTheSocket()
-        {
+//        {
-            // arrange
+//            // arrange
-            var client = new TestSocketClient(options =>
+//            var client = new TestSocketClient(options =>
-            {
+//            {
-                options.ReconnectInterval = TimeSpan.Zero;
+//                options.ReconnectInterval = TimeSpan.Zero;
-            });
+//            });
-            var socket = client.CreateSocket();
+//            var socket = client.CreateSocket();
-            socket.CanConnect = true;
+//            socket.CanConnect = true;
-            var sub = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
+//            var sub = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-            client.SubClient.ConnectSocketSub(sub);
+//            client.SubClient.ConnectSocketSub(sub);
 
-            var subscription = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+//            var subscription = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
-            var ups = new UpdateSubscription(sub, subscription);
+//            var ups = new UpdateSubscription(sub, subscription);
-            sub.AddSubscription(subscription);
+//            sub.AddSubscription(subscription);
 
-            // act
+//            // act
-            client.UnsubscribeAsync(ups).Wait();
+//            client.UnsubscribeAsync(ups).Wait();
 
-            // assert
+//            // assert
-            Assert.That(socket.Connected == false);
+//            Assert.That(socket.Connected == false);
-        }
+//        }
 
-        [TestCase()]
+//        [TestCase()]
-        public void UnsubscribingAll_Should_CloseAllSockets()
+//        public void UnsubscribingAll_Should_CloseAllSockets()
-        {
+//        {
-            // arrange
+//            // arrange
-            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
+//            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
-            var socket1 = client.CreateSocket();
+//            var socket1 = client.CreateSocket();
-            var socket2 = client.CreateSocket();
+//            var socket2 = client.CreateSocket();
-            socket1.CanConnect = true;
+//            socket1.CanConnect = true;
-            socket2.CanConnect = true;
+//            socket2.CanConnect = true;
-            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket1, null);
+//            var sub1 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket1), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-            var sub2 = new SocketConnection(new TraceLogger(), client.SubClient, socket2, null);
+//            var sub2 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket2), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
-            client.SubClient.ConnectSocketSub(sub1);
+//            client.SubClient.ConnectSocketSub(sub1);
-            client.SubClient.ConnectSocketSub(sub2);
+//            client.SubClient.ConnectSocketSub(sub2);
-            var subscription1 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+//            var subscription1 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
-            var subscription2 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
+//            var subscription2 = new TestSubscription<Dictionary<string, string>>(Mock.Of<ILogger>(), (messageEvent) => { });
 
-            sub1.AddSubscription(subscription1);
+//            sub1.AddSubscription(subscription1);
-            sub2.AddSubscription(subscription2);
+//            sub2.AddSubscription(subscription2);
-            var ups1 = new UpdateSubscription(sub1, subscription1);
+//            var ups1 = new UpdateSubscription(sub1, subscription1);
-            var ups2 = new UpdateSubscription(sub2, subscription2);
+//            var ups2 = new UpdateSubscription(sub2, subscription2);
 
-            // act
+//            // act
-            client.UnsubscribeAllAsync().Wait();
+//            client.UnsubscribeAllAsync().Wait();
 
-            // assert
+//            // assert
-            Assert.That(socket1.Connected == false);
+//            Assert.That(socket1.Connected == false);
-            Assert.That(socket2.Connected == false);
+//            Assert.That(socket2.Connected == false);
-        }
+//        }
 
-        [TestCase()]
+//        [TestCase()]
-        public void FailingToConnectSocket_Should_ReturnError()
+//        public void FailingToConnectSocket_Should_ReturnError()
-        {
+//        {
-            // arrange
+//            // arrange
-            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
+//            var client = new TestSocketClient(options => { options.ReconnectInterval = TimeSpan.Zero; });
-            var socket = client.CreateSocket();
+//            var socket = client.CreateSocket();
-            socket.CanConnect = false;
+//            socket.CanConnect = false;
-            var sub1 = new SocketConnection(new TraceLogger(), client.SubClient, socket, null);
+//            var sub1 = new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, "");
 
-            // act
+//            // act
-            var connectResult = client.SubClient.ConnectSocketSub(sub1);
+//            var connectResult = client.SubClient.ConnectSocketSub(sub1);
 
-            // assert
+//            // assert
-            ClassicAssert.IsFalse(connectResult.Success);
+//            ClassicAssert.IsFalse(connectResult.Success);
-        }
+//        }
 
-        [TestCase()]
+//        [TestCase()]
-        public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
+//        public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
-        {
+//        {
-            // arrange
+//            // arrange
-            var channel = "trade_btcusd";
+//            var channel = "trade_btcusd";
-            var client = new TestSocketClient(opt =>
+//            var client = new TestSocketClient(opt =>
-            {
+//            {
-                opt.OutputOriginalData = true;
+//                opt.OutputOriginalData = true;
-                opt.SocketSubscriptionsCombineTarget = 1;
+//                opt.SocketSubscriptionsCombineTarget = 1;
-            });
+//            });
-            var socket = client.CreateSocket();
+//            var socket = client.CreateSocket();
-            socket.CanConnect = true;
+//            socket.CanConnect = true;
-            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, "https://test.test"));
+//            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));
 
-            // act
+//            // act
-            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
+//            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "error" }));
+//            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "error" }));
-            await sub;
+//            await sub;
 
-            // assert
+//            // assert
-            ClassicAssert.IsFalse(client.SubClient.TestSubscription.Confirmed);
+//            ClassicAssert.IsTrue(client.SubClient.TestSubscription.Status != SubscriptionStatus.Subscribed);
-        }
+//        }
 
-        [TestCase()]
+//        [TestCase()]
-        public async Task SuccessResponse_Should_ConfirmSubscription()
+//        public async Task SuccessResponse_Should_ConfirmSubscription()
-        {
+//        {
-            // arrange
+//            // arrange
-            var channel = "trade_btcusd";
+//            var channel = "trade_btcusd";
-            var client = new TestSocketClient(opt =>
+//            var client = new TestSocketClient(opt =>
-            {
+//            {
-                opt.OutputOriginalData = true;
+//                opt.OutputOriginalData = true;
-                opt.SocketSubscriptionsCombineTarget = 1;
+//                opt.SocketSubscriptionsCombineTarget = 1;
-            });
+//            });
-            var socket = client.CreateSocket();
+//            var socket = client.CreateSocket();
-            socket.CanConnect = true;
+//            socket.CanConnect = true;
-            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), client.SubClient, socket, "https://test.test"));
+//            client.SubClient.ConnectSocketSub(new SocketConnection(new TraceLogger(), new TestWebsocketFactory(socket), new WebSocketParameters(new Uri("https://localhost/"), ReconnectPolicy.Disabled), client.SubClient, ""));
 
-            // act
+//            // act
-            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
+//            var sub = client.SubClient.SubscribeToSomethingAsync(channel, onUpdate => {}, ct: default);
-            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "confirmed" }));
+//            socket.InvokeMessage(JsonSerializer.Serialize(new { channel, action = "subscribe", status = "confirmed" }));
-            await sub;
+//            await sub;
 
-            // assert
+//            // assert
-            Assert.That(client.SubClient.TestSubscription.Confirmed);
+//            Assert.That(client.SubClient.TestSubscription.Status == SubscriptionStatus.Subscribed);
-        }
+//        }
-    }
+//    }
-}
+//}

CryptoExchange.Net.UnitTests/SystemTextJsonConverterTests.cs

@@ -4,9 +4,7 @@ using System.Text.Json;
 using NUnit.Framework;
 using System;
 using System.Text.Json.Serialization;
-using NUnit.Framework.Legacy;
 using CryptoExchange.Net.Converters;
-using CryptoExchange.Net.Testing.Comparers;
 using CryptoExchange.Net.SharedApis;
 
 namespace CryptoExchange.Net.UnitTests

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

@@ -1,50 +0,0 @@
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Errors;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Collections.Generic;
-using System.Text.Json.Serialization;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
-{
-    internal class SubResponse
-    {
-
-        [JsonPropertyName("action")]
-        public string Action { get; set; } = null!;
-
-        [JsonPropertyName("channel")]
-        public string Channel { get; set; } = null!;
-
-        [JsonPropertyName("status")]
-        public string Status { get; set; } = null!;
-    }
-
-    internal class UnsubResponse
-    {
-        [JsonPropertyName("action")]
-        public string Action { get; set; } = null!;
-
-        [JsonPropertyName("status")]
-        public string Status { get; set; } = null!;
-    }
-
-    internal class TestChannelQuery : Query<SubResponse>
-    {
-        public TestChannelQuery(string channel, string request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
-        {
-            MessageMatcher = MessageMatcher.Create<SubResponse>(request + "-" + channel, HandleMessage);
-        }
-
-        public CallResult<SubResponse> HandleMessage(SocketConnection connection, DataEvent<SubResponse> message)
-        {
-            if (!message.Data.Status.Equals("confirmed", StringComparison.OrdinalIgnoreCase))
-            {
-                return new CallResult<SubResponse>(new ServerError(ErrorInfo.Unknown with { Message = message.Data.Status }));
-            }
-
-            return message.ToCallResult();
-        }
-    }
-}

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

@@ -1,17 +0,0 @@
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
-{
-    internal class TestQuery : Query<object>
-    {
-        public TestQuery(string identifier, object request, bool authenticated, int weight = 1) : base(request, authenticated, weight)
-        {
-            MessageMatcher = MessageMatcher.Create<object>(identifier);
-        }
-    }
-}

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

@@ -1,34 +0,0 @@
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using Microsoft.Extensions.Logging;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
-{
-    internal class TestSubscription<T> : Subscription<object, object>
-    {
-        private readonly Action<DataEvent<T>> _handler;
-
-        public TestSubscription(ILogger logger, Action<DataEvent<T>> handler) : base(logger, false)
-        {
-            _handler = handler;
-
-            MessageMatcher = MessageMatcher.Create<T>("update-topic", DoHandleMessage);
-        }
-
-        public CallResult DoHandleMessage(SocketConnection connection, DataEvent<T> message)
-        {
-            _handler.Invoke(message);
-            return new CallResult(null);
-        }
-
-        protected 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);
-    }
-}

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

@@ -1,34 +0,0 @@
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using Microsoft.Extensions.Logging;
-using Moq;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
-{
-    internal class TestSubscriptionWithResponseCheck<T> : Subscription<SubResponse, UnsubResponse>
-    {
-        private readonly Action<DataEvent<T>> _handler;
-        private readonly string _channel;
-
-        public TestSubscriptionWithResponseCheck(string channel, Action<DataEvent<T>> handler) : base(Mock.Of<ILogger>(), false)
-        {
-            MessageMatcher = MessageMatcher.Create<T>(channel, DoHandleMessage);
-            _handler = handler;
-            _channel = channel;
-        }
-
-        public CallResult DoHandleMessage(SocketConnection connection, DataEvent<T> message)
-        {
-            _handler.Invoke(message);
-            return new CallResult(null);
-        }
-
-        protected override Query GetSubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "subscribe", false, 1);
-        protected override Query GetUnsubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "unsubscribe", false, 1);
-    }
-}

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -1,19 +1,16 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Net.Http;
 using System.Text;
-using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Options;
 using CryptoExchange.Net.SharedApis;
-using CryptoExchange.Net.UnitTests.TestImplementations;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 
@@ -46,6 +43,8 @@ namespace CryptoExchange.Net.UnitTests
 
     public class TestSubClient : RestApiClient
     {
+        protected override IRestMessageHandler MessageHandler => throw new NotImplementedException();
+
         public TestSubClient(RestExchangeOptions<TestEnvironment> options, RestApiOptions apiOptions) : base(new TraceLogger(), null, "https://localhost:123", options, apiOptions)
         {
         }
@@ -64,8 +63,6 @@ namespace CryptoExchange.Net.UnitTests
 
         /// <inheritdoc />
         public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
-        public override TimeSpan? GetTimeOffset() => null;
-        public override TimeSyncInfo GetTimeSyncInfo() => null;
         protected override IStreamMessageAccessor CreateAccessor() => new SystemTextJsonStreamMessageAccessor(new System.Text.Json.JsonSerializerOptions());
         protected override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(new System.Text.Json.JsonSerializerOptions());
         protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials) => throw new NotImplementedException();
@@ -74,6 +71,8 @@ namespace CryptoExchange.Net.UnitTests
 
     public class TestAuthProvider : AuthenticationProvider
     {
+        public override ApiCredentialsType[] SupportedCredentialTypes => [ApiCredentialsType.Hmac];
+
         public TestAuthProvider(ApiCredentials credentials) : base(credentials)
         {
         }
@@ -85,4 +84,14 @@ namespace CryptoExchange.Net.UnitTests
         public string GetKey() => _credentials.Key;
         public string GetSecret() => _credentials.Secret;
     }
+
+    public class TestEnvironment : TradeEnvironment
+    {
+        public string TestAddress { get; }
+
+        public TestEnvironment(string name, string url) : base(name)
+        {
+            TestAddress = url;
+        }
+    }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -13,12 +13,13 @@ using CryptoExchange.Net.Authentication;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 using CryptoExchange.Net.Clients;
-using CryptoExchange.Net.SharedApis;
 using Microsoft.Extensions.Options;
 using System.Linq;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using System.Text.Json.Serialization;
-using CryptoExchange.Net.Objects.Errors;
+using System.Net.Http.Headers;
+using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 
 namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
@@ -49,19 +50,19 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
             var response = new Mock<IResponse>();
             response.Setup(c => c.IsSuccessStatusCode).Returns(true);
-            response.Setup(c => c.GetResponseStreamAsync()).Returns(Task.FromResult((Stream)responseStream));
+            response.Setup(c => c.GetResponseStreamAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult((Stream)responseStream));
             
-            var headers = new Dictionary<string, string[]>();
+            var headers = new HttpRequestMessage().Headers;
             var request = new Mock<IRequest>();
             request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
             request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response.Object));
             request.Setup(c => c.SetContent(It.IsAny<string>(), It.IsAny<string>())).Callback(new Action<string, string>((content, type) => { request.Setup(r => r.Content).Returns(content); }));
             request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(key, new string[] { val }));
-            request.Setup(c => c.GetHeaders()).Returns(() => headers.ToArray());
+            request.Setup(c => c.GetHeaders()).Returns(() => headers);
 
             var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => 
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => 
                 { 
                     request.Setup(a => a.Uri).Returns(uri);
                     request.Setup(a => a.Method).Returns(method); 
@@ -69,8 +70,8 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
                 .Returns(request.Object);
 
             factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) =>
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) =>
                 {
                     request.Setup(a => a.Uri).Returns(uri);
                     request.Setup(a => a.Method).Returns(method);
@@ -86,16 +87,16 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
            
             var request = new Mock<IRequest>();
             request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
-            request.Setup(c => c.GetHeaders()).Returns(new KeyValuePair<string, string[]>[0]);
+            request.Setup(c => c.GetHeaders()).Returns(new HttpRequestMessage().Headers);
             request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Throws(we);
 
             var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                 .Returns(request.Object);
 
 
             factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                 .Returns(request.Object);
         }
 
@@ -108,29 +109,31 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
             var response = new Mock<IResponse>();
             response.Setup(c => c.IsSuccessStatusCode).Returns(false);
-            response.Setup(c => c.GetResponseStreamAsync()).Returns(Task.FromResult((Stream)responseStream));
+            response.Setup(c => c.GetResponseStreamAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult((Stream)responseStream));
 
             var headers = new List<KeyValuePair<string, string[]>>();
             var request = new Mock<IRequest>();
             request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
             request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response.Object));
             request.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((key, val) => headers.Add(new KeyValuePair<string, string[]>(key, new string[] { val })));
-            request.Setup(c => c.GetHeaders()).Returns(headers.ToArray());
+            request.Setup(c => c.GetHeaders()).Returns(new HttpRequestMessage().Headers);
 
             var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
                 .Returns(request.Object);
 
             factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
                 .Returns(request.Object);
         }
     }
 
     public class TestRestApi1Client : RestApiClient
     {
+        protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
+
         public TestRestApi1Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api1Options)
         {
             RequestFactory = new Mock<IRequestFactory>().Object;
@@ -157,11 +160,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             ParameterPositions[method] = position;
         }
 
-        public override TimeSpan? GetTimeOffset()
-        {
-            throw new NotImplementedException();
-        }
-
         protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
             => new TestAuthProvider(credentials);
 
@@ -169,15 +167,12 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         {
             throw new NotImplementedException();
         }
-
-        public override TimeSyncInfo GetTimeSyncInfo()
-        {
-            throw new NotImplementedException();
-        }
     }
 
     public class TestRestApi2Client : RestApiClient
     {
+        protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
+
         public TestRestApi2Client(TestClientOptions options) : base(new TraceLogger(), null, "https://localhost:123", options, options.Api2Options)
         {
             RequestFactory = new Mock<IRequestFactory>().Object;
@@ -194,18 +189,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             return await SendAsync<T>("http://www.test.com", new RequestDefinition("/", HttpMethod.Get) { Weight = 0 }, null, ct);
         }
         
-        protected override Error ParseErrorResponse(int httpStatusCode, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor, Exception exception)
-        {
-            var errorData = accessor.Deserialize<TestError>();
-
-            return new ServerError(errorData.Data.ErrorCode, GetErrorInfo(errorData.Data.ErrorCode, errorData.Data.ErrorMessage));
-        }
-
-        public override TimeSpan? GetTimeOffset()
-        {
-            throw new NotImplementedException();
-        }
-
         protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
             => new TestAuthProvider(credentials);
 
@@ -214,10 +197,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             throw new NotImplementedException();
         }
 
-        public override TimeSyncInfo GetTimeSyncInfo()
-        {
-            throw new NotImplementedException();
-        }
     }
 
     public class TestError

CryptoExchange.Net.UnitTests/TestImplementations/TestRestMessageHandler.cs

@@ -0,0 +1,29 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests.TestImplementations
+{
+    internal class TestRestMessageHandler : JsonRestMessageHandler
+    {
+        private ErrorMapping _errorMapping = new ErrorMapping([]);
+        public override JsonSerializerOptions Options => new JsonSerializerOptions();
+
+        public override ValueTask<Error> ParseErrorResponse(int httpStatusCode, HttpResponseHeaders responseHeaders, Stream responseStream)
+        {
+            var errorData = JsonSerializer.Deserialize<TestError>(responseStream);
+
+            return new ValueTask<Error>(new ServerError(errorData.ErrorCode, _errorMapping.GetErrorInfo(errorData.ErrorCode.ToString(), errorData.ErrorMessage)));
+        }
+    }
+}

CryptoExchange.Net.UnitTests/TestImplementations/TestSocketClient.cs

@@ -1,140 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Clients;
-using CryptoExchange.Net.Converters.MessageParsing;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using CryptoExchange.Net.UnitTests.TestImplementations.Sockets;
-using Microsoft.Extensions.Logging;
-using Moq;
-using CryptoExchange.Net.Testing.Implementations;
-using CryptoExchange.Net.SharedApis;
-using Microsoft.Extensions.Options;
-using CryptoExchange.Net.Converters.SystemTextJson;
-using System.Net.WebSockets;
-
-namespace CryptoExchange.Net.UnitTests.TestImplementations
-{
-    internal class TestSocketClient: BaseSocketClient
-    {
-        public TestSubSocketClient SubClient { get; }
-
-        /// <summary>
-        /// Create a new instance of KucoinSocketClient
-        /// </summary>
-        /// <param name="optionsFunc">Configure the options to use for this client</param>
-        public TestSocketClient(Action<TestSocketOptions> optionsDelegate = null)
-            : this(Options.Create(ApplyOptionsDelegate(optionsDelegate)), null)
-        {
-        }
-
-        public TestSocketClient(IOptions<TestSocketOptions> options, ILoggerFactory loggerFactory = null) : base(loggerFactory, "Test")
-        {
-            Initialize(options.Value);
-
-            SubClient = AddApiClient(new TestSubSocketClient(options.Value, options.Value.SubOptions));
-            SubClient.SocketFactory = new Mock<IWebsocketFactory>().Object;
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket("https://test.com"));
-        }
-
-        public TestSocket CreateSocket()
-        {
-            Mock.Get(SubClient.SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<ILogger>(), It.IsAny<WebSocketParameters>())).Returns(new TestSocket("https://test.com"));
-            return (TestSocket)SubClient.CreateSocketInternal("https://localhost:123/");
-        }
-                
-    }
-
-    public class TestEnvironment : TradeEnvironment
-    {
-        public string TestAddress { get; }
-
-        public TestEnvironment(string name, string url) : base(name)
-        {
-            TestAddress = url;
-        }
-    }
-
-    public class TestSocketOptions: SocketExchangeOptions<TestEnvironment>
-    {
-        public static TestSocketOptions Default = new TestSocketOptions
-        {
-            Environment = new TestEnvironment("Live", "https://test.test")
-        };
-
-        /// <summary>
-        /// ctor
-        /// </summary>
-        public TestSocketOptions()
-        {
-            Default?.Set(this);
-        }
-
-        public SocketApiOptions SubOptions { get; set; } = new SocketApiOptions();
-
-        internal TestSocketOptions Set(TestSocketOptions targetOptions)
-        {
-            targetOptions = base.Set<TestSocketOptions>(targetOptions);
-            targetOptions.SubOptions = SubOptions.Set(targetOptions.SubOptions);
-            return targetOptions;
-        }
-    }
-
-    public class TestSubSocketClient : SocketApiClient
-    {
-        private MessagePath _channelPath = MessagePath.Get().Property("channel");
-        private MessagePath _actionPath = MessagePath.Get().Property("action");
-        private MessagePath _topicPath = MessagePath.Get().Property("topic");
-
-        public Subscription TestSubscription { get; private set; } = null;
-
-        public TestSubSocketClient(TestSocketOptions options, SocketApiOptions apiOptions) : base(new TraceLogger(), options.Environment.TestAddress, options, apiOptions)
-        {
-
-        }
-
-        protected internal override IByteMessageAccessor CreateAccessor(WebSocketMessageType type) => new SystemTextJsonByteMessageAccessor(new System.Text.Json.JsonSerializerOptions());
-        protected internal override IMessageSerializer CreateSerializer() => new SystemTextJsonMessageSerializer(new System.Text.Json.JsonSerializerOptions());
-
-        /// <inheritdoc />
-        public override string FormatSymbol(string baseAsset, string quoteAsset, TradingMode futuresType, DateTime? deliverDate = null) => $"{baseAsset.ToUpperInvariant()}{quoteAsset.ToUpperInvariant()}";
-
-        internal IWebsocket CreateSocketInternal(string address)
-        {
-            return CreateSocket(address);
-        }
-
-        protected override AuthenticationProvider CreateAuthenticationProvider(ApiCredentials credentials)
-            => new TestAuthProvider(credentials);
-
-        public CallResult ConnectSocketSub(SocketConnection sub)
-        {
-            return ConnectSocketAsync(sub, default).Result;
-        }
-
-        public override string GetListenerIdentifier(IMessageAccessor message)
-        {
-            if (!message.IsValid)
-            {
-                return "topic";
-            }
-
-            var id = message.GetValue<string>(_channelPath);
-            id ??= message.GetValue<string>(_topicPath);
-
-            return message.GetValue<string>(_actionPath) + "-" + id;
-        }
-
-        public Task<CallResult<UpdateSubscription>> SubscribeToSomethingAsync(string channel, Action<DataEvent<string>> onUpdate, CancellationToken ct)
-        {
-            TestSubscription = new TestSubscriptionWithResponseCheck<string>(channel, onUpdate);
-            return SubscribeAsync(TestSubscription, ct);
-        }        
-    }
-}

CryptoExchange.Net.UnitTests/TestSerializerContext.cs

@@ -1,10 +1,6 @@
 using CryptoExchange.Net.UnitTests.TestImplementations;
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Text.Json.Serialization;
-using System.Threading.Tasks;
 
 namespace CryptoExchange.Net.UnitTests
 {

CryptoExchange.Net/.editorconfig

@@ -1,183 +0,0 @@
-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,5 +1,6 @@
-[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,3 +9,4 @@ 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,3 +22,4 @@ public class MapAttribute : Attribute
             Values = maps;
         }
     }
+}

CryptoExchange.Net/Authentication/ApiCredentials.cs

@@ -1,7 +1,9 @@
-using System;
+using System;
-
+using System.IO;
-namespace CryptoExchange.Net.Authentication;
+using System.Threading.Tasks;
 
+namespace CryptoExchange.Net.Authentication
+{
     /// <summary>
     /// Api credentials, used to sign requests accessing private endpoints
     /// </summary>
@@ -45,6 +47,48 @@ public class ApiCredentials
             Pass = pass;
         }
 
+        /// <summary>
+        /// Create API credentials using an API key and secret generated by the server
+        /// </summary>
+        public static ApiCredentials HmacCredentials(string apiKey, string apiSecret, string? pass)
+        {
+            return new ApiCredentials(apiKey, apiSecret, pass, ApiCredentialsType.Hmac);
+        }
+
+        /// <summary>
+        /// Create API credentials using an API key and an RSA private key in PEM format
+        /// </summary>
+        public static ApiCredentials RsaPemCredentials(string apiKey, string privateKey)
+        {
+            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.RsaPem);
+        }
+
+        /// <summary>
+        /// Create API credentials using an API key and an RSA private key in XML format
+        /// </summary>
+        public static ApiCredentials RsaXmlCredentials(string apiKey, string privateKey)
+        {
+            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.RsaXml);
+        }
+
+        /// <summary>
+        /// Create API credentials using an API key and an Ed25519 private key
+        /// </summary>
+        public static ApiCredentials Ed25519Credentials(string apiKey, string privateKey)
+        {
+            return new ApiCredentials(apiKey, privateKey, credentialType: ApiCredentialsType.Ed25519);
+        }
+
+        /// <summary>
+        /// Load a key from a file
+        /// </summary>
+        public static string ReadFromFile(string path)
+        {
+            using var fileStream = File.OpenRead(path);
+            using var streamReader = new StreamReader(fileStream);
+            return streamReader.ReadToEnd();
+        }
+
         /// <summary>
         /// Copy the credentials
         /// </summary>
@@ -54,3 +98,4 @@ public class ApiCredentials
             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>
@@ -16,5 +16,10 @@ public enum ApiCredentialsType
         /// <summary>
         /// Rsa keys credentials in pem/base64 format. Only available for .NetStandard 2.1 and up, use xml format for lower.
         /// </summary>
-    RsaPem
+        RsaPem,
+        /// <summary>
+        /// Ed25519 keys credentials
+        /// </summary>
+        Ed25519
+    }
 }

CryptoExchange.Net/Authentication/AuthenticationProvider.cs

@@ -1,15 +1,21 @@
-using CryptoExchange.Net.Clients;
+using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Converters.SystemTextJson;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+#if NET8_0_OR_GREATER
+using NSec.Cryptography;
+#endif
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Globalization;
 using System.Security.Cryptography;
 using System.Text;
+using CryptoExchange.Net.Sockets;
+using CryptoExchange.Net.Sockets.Default;
 
-namespace CryptoExchange.Net.Authentication;
+namespace CryptoExchange.Net.Authentication
-
+{
     /// <summary>
     /// Base class for authentication providers
     /// </summary>
@@ -17,6 +23,11 @@ public abstract class AuthenticationProvider
     {
         internal IAuthTimeProvider TimeProvider { get; set; } = new AuthTimeProvider();
 
+        /// <summary>
+        /// The supported credential types
+        /// </summary>
+        public abstract ApiCredentialsType[] SupportedCredentialTypes { get; }
+
         /// <summary>
         /// Provided credentials
         /// </summary>
@@ -27,6 +38,13 @@ public abstract class AuthenticationProvider
         /// </summary>
         protected byte[] _sBytes;
 
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// The Ed25519 private key
+        /// </summary>
+        protected Key? Ed25519Key;
+#endif
+
         /// <summary>
         /// Get the API key of the current credentials
         /// </summary>
@@ -45,17 +63,35 @@ public abstract class AuthenticationProvider
             if (credentials.Key == null || credentials.Secret == null)
                 throw new ArgumentException("ApiKey/Secret needed");
 
+            if (!SupportedCredentialTypes.Any(x => x == credentials.CredentialType))
+                throw new ArgumentException($"Credential type {credentials.CredentialType} not supported");
+
+            if (credentials.CredentialType == ApiCredentialsType.Ed25519)
+            {
+#if !NET8_0_OR_GREATER
+                throw new ArgumentException($"Credential type Ed25519 only supported on Net8.0 or newer");
+#endif
+            }
+
             _credentials = credentials;
             _sBytes = Encoding.UTF8.GetBytes(credentials.Secret);
         }
 
         /// <summary>
-    /// Authenticate a request
+        /// Authenticate a REST request
         /// </summary>
-    /// <param name="apiClient">The Api client sending the request</param>
+        /// <param name="apiClient">The API client sending the request</param>
         /// <param name="requestConfig">The request configuration</param>
         public abstract void ProcessRequest(RestApiClient apiClient, RestRequestConfiguration requestConfig);
 
+        /// <summary>
+        /// Get an authentication query for a websocket
+        /// </summary>
+        /// <param name="apiClient">The API client sending the request</param>
+        /// <param name="connection">The connection to authenticate</param>
+        /// <param name="context">Optional context required for creating the authentication query</param>
+        public virtual Query? GetAuthenticationQuery(SocketApiClient apiClient, SocketConnection connection, Dictionary<string, object?>? context = null) => null;
+
         /// <summary>
         /// SHA256 sign the data and return the bytes
         /// </summary>
@@ -208,9 +244,7 @@ public abstract class AuthenticationProvider
         /// <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);
         }
@@ -223,9 +257,7 @@ public abstract class AuthenticationProvider
         /// <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);
         }
@@ -237,9 +269,7 @@ public abstract class AuthenticationProvider
         /// <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));
         }
 
@@ -354,6 +384,36 @@ public abstract class AuthenticationProvider
             return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
         }
 
+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(string data, SignOutputType? outputType = null)
+            => SignEd25519(Encoding.ASCII.GetBytes(data), outputType);
+
+        /// <summary>
+        /// Ed25519 sign the data 
+        /// </summary>
+        public string SignEd25519(byte[] data, SignOutputType? outputType = null)
+        {
+#if NET8_0_OR_GREATER
+            if (Ed25519Key == null)
+            {
+                var key = _credentials.Secret!
+                        .Replace("\n", "")
+                        .Replace("-----BEGIN PRIVATE KEY-----", "")
+                        .Replace("-----END PRIVATE KEY-----", "")
+                        .Trim();
+                var keyBytes = Convert.FromBase64String(key);
+                Ed25519Key = Key.Import(SignatureAlgorithm.Ed25519, keyBytes, KeyBlobFormat.PkixPrivateKey);
+            }
+
+            var resultBytes = SignatureAlgorithm.Ed25519.Sign(Ed25519Key, data);
+            return outputType == SignOutputType.Base64 ? BytesToBase64String(resultBytes) : BytesToHexString(resultBytes);
+#else
+            throw new InvalidOperationException();
+#endif
+        }
+
         private RSA CreateRSA()
         {
             var rsa = RSA.Create();
@@ -392,6 +452,14 @@ public abstract class AuthenticationProvider
         /// <param name="buff"></param>
         /// <returns></returns>
         protected static string BytesToHexString(byte[] buff)
+            => BytesToHexString(new ArraySegment<byte>(buff));
+
+        /// <summary>
+        /// Convert byte array to hex string
+        /// </summary>
+        /// <param name="buff"></param>
+        /// <returns></returns>
+        protected static string BytesToHexString(ArraySegment<byte> buff)
         {
 #if NET9_0_OR_GREATER
             return Convert.ToHexString(buff);
@@ -403,6 +471,26 @@ public abstract class AuthenticationProvider
 #endif
         }
 
+        /// <summary>
+        /// Convert a hex encoded string to byte array
+        /// </summary>
+        /// <param name="hexString"></param>
+        /// <returns></returns>
+        protected static byte[] HexToBytesString(string hexString)
+        {
+            if (hexString.StartsWith("0x"))
+                hexString = hexString.Substring(2);
+
+            byte[] bytes = new byte[hexString.Length / 2];
+            for (int i = 0; i < hexString.Length; i += 2)
+            {
+                string hexSubstring = hexString.Substring(i, 2);
+                bytes[i / 2] = Convert.ToByte(hexSubstring, 16);
+            }
+
+            return bytes;
+        }
+
         /// <summary>
         /// Convert byte array to base64 string
         /// </summary>
@@ -416,32 +504,50 @@ public abstract class AuthenticationProvider
         /// <summary>
         /// Get current timestamp including the time sync offset from the api client
         /// </summary>
-    /// <param name="apiClient"></param>
+        protected DateTime GetTimestamp(RestApiClient apiClient, bool includeOneSecondOffset = true)
-    /// <returns></returns>
-    protected DateTime GetTimestamp(RestApiClient apiClient)
         {
-        return TimeProvider.GetTime().Add(apiClient.GetTimeOffset() ?? TimeSpan.Zero)!;
+            var result =  TimeProvider.GetTime().Add(TimeOffsetManager.GetRestOffset(apiClient.ClientName) ?? TimeSpan.Zero)!;
+            if (includeOneSecondOffset)
+                result = result.AddSeconds(-1);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Get current timestamp including the time sync offset from the api client
+        /// </summary>
+        protected DateTime GetTimestamp(SocketApiClient apiClient, bool includeOneSecondOffset = true)
+        {
+            var result = TimeProvider.GetTime().Add(TimeOffsetManager.GetSocketOffset(apiClient.ClientName) ?? TimeSpan.Zero)!;
+            if (includeOneSecondOffset)
+                result = result.AddSeconds(-1);
+
+            return result;
         }
 
         /// <summary>
         /// Get millisecond timestamp as a string including the time sync offset from the api client
         /// </summary>
-    /// <param name="apiClient"></param>
+        protected string GetMillisecondTimestamp(RestApiClient apiClient, bool includeOneSecondOffset = true)
-    /// <returns></returns>
+            => DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient, includeOneSecondOffset)).Value.ToString(CultureInfo.InvariantCulture);
-    protected string GetMillisecondTimestamp(RestApiClient apiClient)
+
-    {
+        /// <summary>
-        return DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient)).Value.ToString(CultureInfo.InvariantCulture);
+        /// Get millisecond timestamp as a string including the time sync offset from the api client
-    }
+        /// </summary>
+        protected string GetMillisecondTimestamp(SocketApiClient apiClient, bool includeOneSecondOffset = true)
+            => DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient, includeOneSecondOffset)).Value.ToString(CultureInfo.InvariantCulture);
 
         /// <summary>
         /// Get millisecond timestamp as a long including the time sync offset from the api client
         /// </summary>
-    /// <param name="apiClient"></param>
+        protected long GetMillisecondTimestampLong(RestApiClient apiClient, bool includeOneSecondOffset = true)
-    /// <returns></returns>
+            => DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient, includeOneSecondOffset)).Value;
-    protected long GetMillisecondTimestampLong(RestApiClient apiClient)
+
-    {
+        /// <summary>
-        return DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient)).Value;
+        /// Get millisecond timestamp as a long including the time sync offset from the api client
-    }
+        /// </summary>
+        protected long GetMillisecondTimestampLong(SocketApiClient apiClient, bool includeOneSecondOffset = true)
+            => DateTimeConverter.ConvertToMilliseconds(GetTimestamp(apiClient, includeOneSecondOffset)).Value;
 
         /// <summary>
         /// Return the serialized request body
@@ -454,7 +560,7 @@ public abstract class AuthenticationProvider
             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))
+            if (parameters?.Count == 1 && parameters.TryGetValue(Constants.BodyPlaceHolderKey, out object? value))
                 return stringSerializer.Serialize(value);
             else
                 return stringSerializer.Serialize(parameters);
@@ -465,11 +571,7 @@ public abstract class AuthenticationProvider
     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
@@ -479,3 +581,4 @@ public abstract class AuthenticationProvider<TApiCredentials> : AuthenticationPr
         {
         }
     }
+}

CryptoExchange.Net/Authentication/SignOutputType.cs

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

CryptoExchange.Net/Caching/MemoryCache.cs

@@ -1,13 +1,18 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Linq;
+using System.Threading;
 
-namespace CryptoExchange.Net.Caching;
+namespace CryptoExchange.Net.Caching
-
+{
     internal class MemoryCache
     {
         private readonly ConcurrentDictionary<string, CacheItem> _cache = new ConcurrentDictionary<string, CacheItem>();
+#if NET9_0_OR_GREATER
+        private readonly Lock _lock = new Lock();
+#else
         private readonly object _lock = new object();
+#endif
 
         /// <summary>
         /// Add a new cache entry. Will override an existing entry if it already exists
@@ -50,3 +55,4 @@ internal class MemoryCache
             }
         }
     }
+}

CryptoExchange.Net/Clients/BaseApiClient.cs

@@ -1,18 +1,20 @@
 using System;
 using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
 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>
     public abstract class BaseApiClient : IDisposable, IBaseApiClient
     {
+        private string? _clientName;
+
         /// <summary>
         /// Logger
         /// </summary>
@@ -23,6 +25,21 @@ public abstract class BaseApiClient : IDisposable, IBaseApiClient
         /// </summary>
         protected bool _disposing;
 
+        /// <summary>
+        /// Name of the client
+        /// </summary>
+        protected internal string ClientName
+        {
+            get
+            {
+                if (_clientName != null)
+                    return _clientName;
+
+                _clientName = GetType().Name;
+                return _clientName;
+            }
+        }
+
         /// <summary>
         /// The authentication provider for this API client. (null if no credentials are set)
         /// </summary>
@@ -124,17 +141,9 @@ public abstract class BaseApiClient : IDisposable, IBaseApiClient
         /// <summary>
         /// Dispose
         /// </summary>
-    public void Dispose()
+        public virtual void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    /// <summary>
-    /// Dispose
-    /// </summary>
-    public virtual void Dispose(bool disposing)
         {
             _disposing = true;
         }
     }
+}

CryptoExchange.Net/Clients/BaseClient.cs

@@ -1,11 +1,12 @@
-using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
+using System.Threading;
 
-namespace CryptoExchange.Net.Clients;
+namespace CryptoExchange.Net.Clients
-
+{
     /// <summary>
     /// The base for all clients, websocket client and rest client
     /// </summary>
@@ -48,7 +49,11 @@ public abstract class BaseClient : IDisposable
         /// </summary>
         protected internal ILogger _logger;
 
+#if NET9_0_OR_GREATER
+        private readonly Lock _versionLock = new Lock();
+#else
         private readonly object _versionLock = new object();
+#endif
         private Version _exchangeVersion;
 
         /// <summary>
@@ -79,7 +84,7 @@ public abstract class BaseClient : IDisposable
                 throw new ArgumentNullException(nameof(options));
 
             ClientOptions = options;
-        _logger.Log(LogLevel.Trace, "Client configuration: {Options}, CryptoExchange.Net: v{CryptoExchangeVersion}, {Exchange}.Net: v{ExchangeVersion}", options, CryptoExchangeLibVersion, Exchange, ExchangeLibVersion);
+            _logger.Log(LogLevel.Trace, $"Client configuration: {options}, CryptoExchange.Net: v{CryptoExchangeLibVersion}, {Exchange}.Net: v{ExchangeLibVersion}");
         }
 
         /// <summary>
@@ -101,7 +106,6 @@ public abstract class BaseClient : IDisposable
             if (ClientOptions == null)
                 throw new InvalidOperationException("Client should have called Initialize before adding API clients");
 
-        _logger.Log(LogLevel.Trace, "  {ApiClient}, base address: {BaseAddress}", apiClient.GetType().Name, apiClient.BaseAddress);
             ApiClients.Add(apiClient);
             return apiClient;
         }
@@ -119,24 +123,10 @@ public abstract class BaseClient : IDisposable
         /// <summary>
         /// Dispose
         /// </summary>
-    public void Dispose()
+        public virtual 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

@@ -1,10 +1,10 @@
 using System.Linq;
-using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 
-namespace CryptoExchange.Net.Clients;
+namespace CryptoExchange.Net.Clients
-
+{
     /// <summary>
     /// Base rest client
     /// </summary>
@@ -21,5 +21,8 @@ public abstract class BaseRestClient : BaseClient, IRestClient
         protected BaseRestClient(ILoggerFactory? loggerFactory, string name) : base(loggerFactory, name)
         {
             _logger = loggerFactory?.CreateLogger(name + ".RestClient") ?? NullLoggerFactory.Instance.CreateLogger(name);
+
+            LibraryHelpers.StaticLogger = loggerFactory?.CreateLogger("CryptoExchange");
+        }
     }
 }

CryptoExchange.Net/Clients/BaseSocketClient.cs

@@ -1,16 +1,17 @@
+using CryptoExchange.Net.Interfaces.Clients;
+using CryptoExchange.Net.Logging.Extensions;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Sockets;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using CryptoExchange.Net.Interfaces;
-using CryptoExchange.Net.Logging.Extensions;
-using CryptoExchange.Net.Objects.Sockets;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-
-namespace CryptoExchange.Net.Clients;
 
+namespace CryptoExchange.Net.Clients
+{
     /// <summary>
     /// Base for socket client implementations
     /// </summary>
@@ -29,6 +30,9 @@ public abstract class BaseSocketClient : BaseClient, ISocketClient
         public int CurrentSubscriptions => ApiClients.OfType<SocketApiClient>().Sum(s => s.CurrentSubscriptions);
         /// <inheritdoc />
         public double IncomingKbps => ApiClients.OfType<SocketApiClient>().Sum(s => s.IncomingKbps);
+
+        /// <inheritdoc />
+        public new SocketExchangeOptions ClientOptions => (SocketExchangeOptions)base.ClientOptions;
         #endregion
 
         /// <summary>
@@ -39,6 +43,8 @@ public abstract class BaseSocketClient : BaseClient, ISocketClient
         protected BaseSocketClient(ILoggerFactory? loggerFactory, string name) : base(loggerFactory, name)
         {
             _logger = loggerFactory?.CreateLogger(name + ".SocketClient") ?? NullLoggerFactory.Instance.CreateLogger(name);
+
+            LibraryHelpers.StaticLogger = loggerFactory?.CreateLogger("CryptoExchange");
         }
 
         /// <summary>
@@ -128,3 +134,4 @@ public abstract class BaseSocketClient : BaseClient, ISocketClient
             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,20 +59,9 @@ public class CryptoBaseClient : IDisposable
         /// <summary>
         /// Dispose
         /// </summary>
-    public void Dispose(bool disposing)
+        public void Dispose()
-    {
-        if (disposing)
         {
             _serviceCache.Clear();
         }
     }
-
-    /// <summary>
-    /// Dispose
-    /// </summary>
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
 }

CryptoExchange.Net/Clients/CryptoRestClient.cs

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

CryptoExchange.Net/Clients/CryptoSocketClient.cs

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

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -1,14 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Threading;
-using System.Threading.Tasks;
 using CryptoExchange.Net.Caching;
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Errors;
@@ -17,9 +10,20 @@ using CryptoExchange.Net.RateLimiting;
 using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.Requests;
 using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 
-namespace CryptoExchange.Net.Clients;
+namespace CryptoExchange.Net.Clients
-
+{
     /// <summary>
     /// Base rest API client for interacting with a REST API
     /// </summary>
@@ -28,12 +32,6 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
         /// <inheritdoc />
         public IRequestFactory RequestFactory { get; set; } = new RequestFactory();
 
-    /// <inheritdoc />
-    public abstract TimeSyncInfo? GetTimeSyncInfo();
-
-    /// <inheritdoc />
-    public abstract TimeSpan? GetTimeOffset();
-
         /// <inheritdoc />
         public int TotalRequestsMade { get; set; }
 
@@ -90,6 +88,11 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
         /// </summary>
         private readonly static MemoryCache _cache = new MemoryCache();
 
+        /// <summary>
+        /// The message handler
+        /// </summary>
+        protected abstract IRestMessageHandler MessageHandler { get; }
+        
         /// <summary>
         /// ctor
         /// </summary>
@@ -106,7 +109,9 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
                   options,
                   apiOptions)
         {
-        RequestFactory.Configure(options.Proxy, options.RequestTimeout, httpClient);
+            TimeOffsetManager.RegisterRestApi(ClientName);
+
+            RequestFactory.Configure(options, httpClient);
         }
 
         /// <summary>
@@ -204,6 +209,13 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
             int? weightSingleLimiter = null,
             string? rateLimitKeySuffix = null)
         {
+            var requestId = ExchangeHelpers.NextId();
+            if (definition.Authenticated && AuthenticationProvider == null)
+            {
+                _logger.RestApiNoApiCredentials(requestId, definition.Path);
+                return new WebCallResult<T>(new NoApiCredentialsError());
+            }
+
             string? cacheKey = null;
             if (ShouldCache(definition))
             {
@@ -224,11 +236,19 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
             while (true)
             {
                 currentTry++;
-            var requestId = ExchangeHelpers.NextId();
 
-            var prepareResult = await PrepareAsync(requestId, baseAddress, definition, cancellationToken, additionalHeaders, weight, weightSingleLimiter, rateLimitKeySuffix).ConfigureAwait(false);
+                await CheckTimeSync(requestId, definition).ConfigureAwait(false);
-            if (!prepareResult)
+
-                return new WebCallResult<T>(prepareResult.Error!);
+                var error = await RateLimitAsync(
+                    baseAddress,
+                    requestId,
+                    definition,
+                    weight ?? definition.Weight,
+                    cancellationToken,
+                    weightSingleLimiter,
+                    rateLimitKeySuffix).ConfigureAwait(false);
+                if (error != null)
+                    return new WebCallResult<T>(error);
 
                 var request = CreateRequest(
                     requestId,
@@ -237,17 +257,25 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
                     uriParameters,
                     bodyParameters,
                     additionalHeaders);
+
+                if (_logger.IsEnabled(LogLevel.Debug))
                     _logger.RestApiSendRequest(request.RequestId, definition, request.Content, string.IsNullOrEmpty(request.Uri.Query) ? "-" : request.Uri.Query, string.Join(", ", request.GetHeaders().Select(h => h.Key + $"=[{string.Join(",", h.Value)}]")));
                 TotalRequestsMade++;
-            var result = await GetResponseAsync<T>(definition, request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
+
+                var result = await GetResponseAsync2<T>(definition, request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
                 if (result.Error is not CancellationRequestedError)
                 {
                     var originalData = OutputOriginalData ? result.OriginalData : "[Data only available when OutputOriginal = true]";
                     if (!result)
+                    {
                         _logger.RestApiErrorReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), result.Error?.ToString(), originalData, result.Error?.Exception);
+                    }
                     else
+                    {
+                        if (_logger.IsEnabled(LogLevel.Debug))
                             _logger.RestApiResponseReceived(result.RequestId, result.ResponseStatusCode, (long)Math.Floor(result.ResponseTime!.Value.TotalMilliseconds), originalData);
                     }
+                }
                 else
                 {
                     _logger.RestApiCancellationRequested(result.RequestId);
@@ -267,54 +295,19 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
         }
 
         /// <summary>
-    /// Prepare before sending a request. Sync time between client and server and check rate limits
+        /// Check rate limits for the request
         /// </summary>
-    /// <param name="requestId">Request id</param>
+        protected virtual async ValueTask<Error?> RateLimitAsync(
-    /// <param name="baseAddress">Host and schema</param>
+            string host,
-    /// <param name="definition">Request definition</param>
-    /// <param name="cancellationToken">Cancellation token</param>
-    /// <param name="additionalHeaders">Additional headers for this request</param>
-    /// <param name="weight">Override the request weight for this request</param>
-    /// <param name="weightSingleLimiter">Specify the weight to apply to the individual rate limit guard for this request</param>
-    /// <param name="rateLimitKeySuffix">An additional optional suffix for the key selector</param>
-    /// <returns></returns>
-    /// <exception cref="Exception"></exception>
-    protected virtual async Task<CallResult> PrepareAsync(
             int requestId,
-        string baseAddress,
             RequestDefinition definition,
+            int weight,
             CancellationToken cancellationToken,
-        Dictionary<string, string>? additionalHeaders = null,
-        int? weight = null,
             int? weightSingleLimiter = null,
             string? rateLimitKeySuffix = null)
         {
-        // Time sync
-        if (definition.Authenticated)
-        {
-            if (AuthenticationProvider == null)
-            {
-                _logger.RestApiNoApiCredentials(requestId, definition.Path);
-                return new CallResult<IRequest>(new NoApiCredentialsError());
-            }
-
-            var syncTask = SyncTimeAsync();
-            var timeSyncInfo = GetTimeSyncInfo();
-
-            if (timeSyncInfo != null && timeSyncInfo.TimeSyncState.LastSyncTime == default)
-            {
-                // Initially with first request we'll need to wait for the time syncing, if it's not the first request we can just continue
-                var syncTimeResult = await syncTask.ConfigureAwait(false);
-                if (!syncTimeResult)
-                {
-                    _logger.RestApiFailedToSyncTime(requestId, syncTimeResult.Error!.ToString());
-                    return syncTimeResult.AsDataless();
-                }
-            }
-        }            
-
             // Rate limiting
-        var requestWeight = weight ?? definition.Weight;
+            var requestWeight = weight;
             if (requestWeight != 0)
             {
                 if (definition.RateLimitGate == null)
@@ -322,9 +315,9 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
 
                 if (ClientOptions.RateLimiterEnabled)
                 {
-                var limitResult = await definition.RateLimitGate.ProcessAsync(_logger, requestId, RateLimitItemType.Request, definition, baseAddress, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
+                    var limitResult = await definition.RateLimitGate.ProcessAsync(_logger, requestId, RateLimitItemType.Request, definition, host, AuthenticationProvider?._credentials.Key, requestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
                     if (!limitResult)
-                    return new CallResult(limitResult.Error!);
+                        return limitResult.Error!;
                 }
             }
 
@@ -337,13 +330,13 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
                 if (ClientOptions.RateLimiterEnabled)
                 {
                     var singleRequestWeight = weightSingleLimiter ?? 1;
-                var limitResult = await definition.RateLimitGate.ProcessSingleAsync(_logger, requestId, definition.LimitGuard, RateLimitItemType.Request, definition, baseAddress, AuthenticationProvider?._credentials.Key, singleRequestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
+                    var limitResult = await definition.RateLimitGate.ProcessSingleAsync(_logger, requestId, definition.LimitGuard, RateLimitItemType.Request, definition, host, AuthenticationProvider?._credentials.Key, singleRequestWeight, ClientOptions.RateLimitingBehaviour, rateLimitKeySuffix, cancellationToken).ConfigureAwait(false);
                     if (!limitResult)
-                    return new CallResult(limitResult.Error!);
+                        return limitResult.Error!;
                 }
             }
 
-        return CallResult.SuccessResult;
+            return null;
         }
 
         /// <summary>
@@ -367,9 +360,9 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
             var requestConfiguration = new RestRequestConfiguration(
                 definition,
                 baseAddress,
-            uriParameters == null ? new Dictionary<string, object>() : CreateParameterDictionary(uriParameters),
+                uriParameters == null ? null : CreateParameterDictionary(uriParameters),
-            bodyParameters == null ? new Dictionary<string, object>() : CreateParameterDictionary(bodyParameters),
+                bodyParameters == null ? null : CreateParameterDictionary(bodyParameters),
-            new Dictionary<string, string>(additionalHeaders ?? []),
+                additionalHeaders,
                 definition.ArraySerialization ?? ArraySerialization,
                 definition.ParameterPosition ?? ParameterPositions[definition.Method],
                 definition.RequestBodyFormat ?? RequestBodyFormat);
@@ -388,15 +381,19 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
                 queryString = $"?{queryString}";
 
             var uri = new Uri(baseAddress.AppendPath(definition.Path) + queryString);
-        var request = RequestFactory.Create(definition.Method, uri, requestId);
+            var request = RequestFactory.Create(ClientOptions.HttpVersion, definition.Method, uri, requestId);
-        request.Accept = Constants.JsonContentHeader;
+            request.Accept = MessageHandler.AcceptHeader;
 
+            if (requestConfiguration.Headers != null) 
+            {
                 foreach (var header in requestConfiguration.Headers)
                     request.AddHeader(header.Key, header.Value);
+            }
 
             foreach (var header in StandardRequestHeaders)
             {
                 // Only add it if it isn't overwritten
+                requestConfiguration.Headers ??= new Dictionary<string, string>();
                 if (!requestConfiguration.Headers.ContainsKey(header.Key))
                     request.AddHeader(header.Key, header.Value);
             }            
@@ -429,7 +426,7 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
         /// <param name="gate">The ratelimit gate used</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <returns></returns>
-    protected virtual async Task<WebCallResult<T>> GetResponseAsync<T>(
+        protected virtual async Task<WebCallResult<T>> GetResponseAsync2<T>(
             RequestDefinition requestDefinition,
             IRequest request,
             IRateLimitGate? gate,
@@ -438,27 +435,48 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
             var sw = Stopwatch.StartNew();
             Stream? responseStream = null;
             IResponse? response = null;
-        IStreamMessageAccessor? accessor = null;
+
             try
             {
                 response = await request.GetResponseAsync(cancellationToken).ConfigureAwait(false);
                 sw.Stop();
-            var statusCode = response.StatusCode;
+                responseStream = await response.GetResponseStreamAsync(cancellationToken).ConfigureAwait(false);
-            var headers = response.ResponseHeaders;
+                string? originalData = null;
-            var responseLength = response.ContentLength;
-            responseStream = await response.GetResponseStreamAsync().ConfigureAwait(false);
                 var outputOriginalData = ApiOptions.OutputOriginalData ?? ClientOptions.OutputOriginalData;
+                if (outputOriginalData || MessageHandler.RequiresSeekableStream)
+                {
+                    // If we want to return the original string data from the stream, but still want to process it
+                    // we'll need to copy it as the stream isn't seekable, and thus we can only read it once
+                    var memoryStream = new MemoryStream();
+                    await responseStream.CopyToAsync(memoryStream).ConfigureAwait(false);
+                    using var reader = new StreamReader(memoryStream, Encoding.UTF8, false, 4096, true);
+                    if (outputOriginalData) 
+                    {
+                        memoryStream.Position = 0;
+                        originalData = await reader.ReadToEndAsync().ConfigureAwait(false);
+
+                        if (_logger.IsEnabled(LogLevel.Trace))
+                            _logger.RestApiReceivedResponse(request.RequestId, originalData);
+                    }
+
+                    // Continue processing from the memory stream since the response stream is already read and we can't seek it
+                    responseStream.Close();
+                    memoryStream.Position = 0;
+                    responseStream = memoryStream;
+                }
 
-            accessor = CreateAccessor();
                 if (!response.IsSuccessStatusCode && !requestDefinition.TryParseOnNonSuccess)
                 {
-                // Error response
+                    // If the response status is not success it is an error by definition
-                var readResult = await accessor.Read(responseStream, true).ConfigureAwait(false);
 
                     Error error;
                     if (response.StatusCode == (HttpStatusCode)418 || response.StatusCode == (HttpStatusCode)429)
                     {
-                    var rateError = ParseRateLimitResponse((int)response.StatusCode, response.ResponseHeaders, accessor);
+                        // Specifically handle rate limit errors
+                        var rateError = await MessageHandler.ParseErrorRateLimitResponse(
+                            (int)response.StatusCode,
+                            response.ResponseHeaders,
+                            responseStream).ConfigureAwait(false);
                         if (rateError.RetryAfter != null && gate != null && ClientOptions.RateLimiterEnabled)
                         {
                             _logger.RestApiRateLimitPauseUntil(request.RequestId, rateError.RetryAfter.Value);
@@ -469,28 +487,35 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
                     }
                     else
                     {
-                    error = ParseErrorResponse((int)response.StatusCode, response.ResponseHeaders, accessor, readResult.Error?.Exception);
+                        // Handle a 'normal' error response. Can still be either a json error message or some random HTML or other string
+
+                        try
+                        {
+                            error = await MessageHandler.ParseErrorResponse(
+                            (int)response.StatusCode,
+                            response.ResponseHeaders,
+                            responseStream).ConfigureAwait(false);
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.LogError(ex, "Unhandled exception when parsing error response: {Message}", ex.Message);
+                            var errorResult = new ServerError(ErrorInfo.Unknown with { Message = ex.Message });
+                            return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, errorResult);
+                        }
                     }
 
-                if (error.Code == null || error.Code == 0)
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
-                    error.Code = (int)response.StatusCode;
-
-                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error!);
                 }
 
-            var valid = await accessor.Read(responseStream, outputOriginalData).ConfigureAwait(false);
                 if (typeof(T) == typeof(object))
                     // Success status code and expected empty response, assume it's correct
-                return new WebCallResult<T>(statusCode, headers, sw.Elapsed, 0, accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Data only available when OutputOriginal = true in client options]", request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, null);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, 0, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, null);
 
-            if (!valid)
+                // Data response received, inspect the message and check if it is an error or not
-            {
+                var parsedError = await MessageHandler.CheckForErrorResponse(
-                // Invalid json
+                    requestDefinition,
-                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);
+                    response.ResponseHeaders,
-            }
+                    responseStream).ConfigureAwait(false);
-
-            // Json response received
-            var parsedError = TryParseError(requestDefinition, response.ResponseHeaders, accessor);
                 if (parsedError != null)
                 {
                     if (parsedError is ServerRateLimitError rateError)
@@ -503,52 +528,84 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
                     }
 
                     // Success status code, but TryParseError determined it was an error response
-                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, parsedError);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, parsedError);
                 }
 
-            var deserializeResult = accessor.Deserialize<T>();
+                if (MessageHandler.RequiresSeekableStream)
-            return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult.Data, deserializeResult.Error);
+                    // Reset stream read position as it might not be at the start if `CheckForErrorResponse` has read from it
+                    responseStream.Position = 0;
+
+                // Try deserialization into the expected type
+                var (deserializeResult, deserializeError) = await MessageHandler.TryDeserializeAsync<T>(responseStream, cancellationToken).ConfigureAwait(false);                              
+                if (deserializeError != null)
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult, deserializeError); ;
+
+                try
+                {
+                    // Check the deserialized response to see if it's an error or not
+                    var responseError = MessageHandler.CheckDeserializedResponse(response.ResponseHeaders, deserializeResult);
+                    if (responseError != null)
+                        return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult, responseError);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Unhandled exception when checking deserialized response: {Message}", ex.Message);
+                    var error = new ServerError(ErrorInfo.Unknown with { Message = ex.Message });
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult, error);
+                }
+
+                return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, originalData, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult, null);
             }
             catch (HttpRequestException requestException)
             {
                 // Request exception, can't reach server for instance
                 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);
+                return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
             }
             catch (OperationCanceledException canceledException)
             {
                 if (cancellationToken != default && canceledException.CancellationToken == cancellationToken)
                 {
                     // Cancellation token canceled by caller
-                return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new CancellationRequestedError(canceledException));
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new CancellationRequestedError(canceledException));
                 }
                 else
                 {
                     // Request timed out
                     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);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
                 }
             }
+            catch (ArgumentException argumentException)
+            {
+                if (argumentException.Message.StartsWith("Only HTTP/"))
+                {
+                    // Unsupported HTTP version error .net framework
+                    var error = ArgumentError.Invalid(nameof(RestExchangeOptions.HttpVersion), $"Invalid HTTP version {request.HttpVersion}: " + argumentException.Message);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                }
+
+                throw;
+            }
+            catch (NotSupportedException notSupportedException)
+            {
+                if (notSupportedException.Message.StartsWith("Request version value must be one of"))
+                {
+                    // Unsupported HTTP version error dotnet code
+                    var error = ArgumentError.Invalid(nameof(RestExchangeOptions.HttpVersion), $"Invalid HTTP version {request.HttpVersion}: " + notSupportedException.Message);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                }
+
+                throw;
+            }
             finally
             {
-            accessor?.Clear();
                 responseStream?.Close();
                 response?.Close();
             }
         }
 
-    /// <summary>
-    /// Can be used to parse an error even though response status indicates success. Some apis always return 200 OK, even though there is an error.
-    /// This method will be called for each response to be able to check if the response is an error or not.
-    /// If the response is an error this method should return the parsed error, else it should return null
-    /// </summary>
-    /// <param name="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(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.
         /// Note that this is always called; even when the request might be successful
@@ -558,7 +615,7 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
         /// <param name="callResult">The result of the call</param>
         /// <param name="tries">The current try number</param>
         /// <returns>True if call should retry, false if the call should return</returns>
-    protected virtual async Task<bool> ShouldRetryRequestAsync<T>(IRateLimitGate? gate, WebCallResult<T> callResult, int tries)
+        protected virtual async ValueTask<bool> ShouldRetryRequestAsync<T>(IRateLimitGate? gate, WebCallResult<T> callResult, int tries)
         {
             if (tries >= 2)
                 // Only retry once
@@ -613,43 +670,6 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
             }
         }
 
-    /// <summary>
-    /// Parse an error response from the server. Only used when server returns a status other than Success(200) or ratelimit error (429 or 418)
-    /// </summary>
-    /// <param name="httpStatusCode">The response status code</param>
-    /// <param name="responseHeaders">The response headers</param>
-    /// <param name="accessor">Data accessor</param>
-    /// <param name="exception">Exception</param>
-    /// <returns></returns>
-    protected virtual Error ParseErrorResponse(int httpStatusCode, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor, Exception? exception)
-    {
-        return new ServerError(ErrorInfo.Unknown, exception);
-    }
-
-    /// <summary>
-    /// Parse a rate limit error response from the server. Only used when server returns http status 429 or 418
-    /// </summary>
-    /// <param name="httpStatusCode">The response status code</param>
-    /// <param name="responseHeaders">The response headers</param>
-    /// <param name="accessor">Data accessor</param>
-    /// <returns></returns>
-    protected virtual ServerRateLimitError ParseRateLimitResponse(int httpStatusCode, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor)
-    {
-        // Handle retry after header
-        var retryAfterHeader = responseHeaders.SingleOrDefault(r => r.Key.Equals("Retry-After", StringComparison.InvariantCultureIgnoreCase));
-        if (!(retryAfterHeader.Value.Length > 0))
-            return new ServerRateLimitError();
-
-        var value = retryAfterHeader.Value.First();
-        if (int.TryParse(value, out var seconds))
-            return new ServerRateLimitError() { RetryAfter = DateTime.UtcNow.AddSeconds(seconds) };
-
-        if (DateTime.TryParse(value, out var datetime))
-            return new ServerRateLimitError() { RetryAfter = datetime };
-
-        return new ServerRateLimitError();
-    }
-
         /// <summary>
         /// Create the parameter IDictionary
         /// </summary>
@@ -674,29 +694,47 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
         {
             base.SetOptions(options);
 
-        RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout);
+            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout, ClientOptions.HttpKeepAliveInterval);
         }
 
-    internal async Task<WebCallResult<bool>> SyncTimeAsync()
+        private async ValueTask CheckTimeSync(int requestId, RequestDefinition definition)
         {
-        var timeSyncParams = GetTimeSyncInfo();
+            if (!definition.Authenticated)
-        if (timeSyncParams == null)
+                return;
-            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
 
-        if (await timeSyncParams.TimeSyncState.Semaphore.WaitAsync(0).ConfigureAwait(false))
+            var lastUpdateTime = TimeOffsetManager.GetRestLastUpdateTime(ClientName);
+            var syncTask = CheckTimeOffsetAsync();
+
+            if (lastUpdateTime == null)
             {
-            if (!timeSyncParams.SyncTime || DateTime.UtcNow - timeSyncParams.TimeSyncState.LastSyncTime < timeSyncParams.RecalculationInterval)
+                // Initially with first request we'll need to wait for the time syncing before making the actual request.
-            {
+                // If it's not the first request we can just continue and let it complete in the background
-                timeSyncParams.TimeSyncState.Semaphore.Release();
+                await syncTask.ConfigureAwait(false);
-                return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
             }
 
+            return;
+        }
+
+        internal async ValueTask CheckTimeOffsetAsync()
+        {
+            if (!(ApiOptions.AutoTimestamp ?? ClientOptions.AutoTimestamp))
+                // Time syncing not enabled
+                return;
+
+            await TimeOffsetManager.EnterAsync(ClientName).ConfigureAwait(false);
+            try
+            {
+                var lastUpdateTime = TimeOffsetManager.GetRestLastUpdateTime(ClientName);
+                if (DateTime.UtcNow - lastUpdateTime < (ApiOptions.TimestampRecalculationInterval ?? ClientOptions.TimestampRecalculationInterval))
+                    // Time syncing was recently done
+                    return;
+
                 var localTime = DateTime.UtcNow;
                 var result = await GetServerTimestampAsync().ConfigureAwait(false);
                 if (!result)
                 {
-                timeSyncParams.TimeSyncState.Semaphore.Release();
+                    _logger.LogWarning("Failed to determine time offset between client and server, timestamping might fail");
-                return result.As(false);
+                    return;
                 }
 
                 if (TotalRequestsMade == 1)
@@ -706,22 +744,35 @@ public abstract class RestApiClient : BaseApiClient, IRestApiClient
                     result = await GetServerTimestampAsync().ConfigureAwait(false);
                     if (!result)
                     {
-                    timeSyncParams.TimeSyncState.Semaphore.Release();
+                        _logger.LogWarning("Failed to determine time offset between client and server, timestamping might fail");
-                    return result.As(false);
+                        return;
                     }
                 }
 
-            // Calculate time offset between local and server
+                // Estimate the offset as the round trip time / 2
                 var offset = result.Data - localTime.AddMilliseconds(result.ResponseTime!.Value.TotalMilliseconds / 2);
-            timeSyncParams.UpdateTimeOffset(offset);
+                if (offset.TotalMilliseconds > 0 && offset.TotalMilliseconds < 500)
-            timeSyncParams.TimeSyncState.Semaphore.Release();
+                {
+                    _logger.LogInformation("{ClientName} Time offset within limits ({Offset}ms), set offset to 0ms", ClientName, Math.Round(offset.TotalMilliseconds));
+                    offset = TimeSpan.Zero;
+                }
+                else
+                {
+                    _logger.LogInformation("{ClientName} Time offset set to {Offset}ms", ClientName, Math.Round(offset.TotalMilliseconds));
                 }
 
-        return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
+                TimeOffsetManager.UpdateRestOffset(ClientName, offset.TotalMilliseconds);
+            }
+            finally
+            {
+                TimeOffsetManager.Release(ClientName);
+            }
         }
 
         private bool ShouldCache(RequestDefinition definition)
             => ClientOptions.CachingEnabled
             && definition.Method == HttpMethod.Get
             && !definition.PreventCaching;
+
+    }
 }

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -1,4 +1,6 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
 using CryptoExchange.Net.Interfaces;
+using CryptoExchange.Net.Interfaces.Clients;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Objects.Errors;
@@ -7,6 +9,11 @@ using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.RateLimiting;
 using CryptoExchange.Net.RateLimiting.Interfaces;
 using CryptoExchange.Net.Sockets;
+using CryptoExchange.Net.Sockets.Default;
+using CryptoExchange.Net.Sockets.Default.Interfaces;
+using CryptoExchange.Net.Sockets.HighPerf;
+using CryptoExchange.Net.Sockets.HighPerf.Interfaces;
+using CryptoExchange.Net.Sockets.Interfaces;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Concurrent;
@@ -17,21 +24,30 @@ 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>
     public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
     {
         #region Fields
+
         /// <inheritdoc/>
         public IWebsocketFactory SocketFactory { get; set; } = new WebsocketFactory();
 
+        /// <inheritdoc/>
+        public IHighPerfConnectionFactory? HighPerfConnectionFactory { get; set; }
+
         /// <summary>
         /// List of socket connections currently connecting/connected
         /// </summary>
-    protected internal ConcurrentDictionary<int, SocketConnection> socketConnections = new();
+        protected internal ConcurrentDictionary<int, SocketConnection> _socketConnections = new();
+
+        /// <summary>
+        /// List of HighPerf socket connections currently connecting/connected
+        /// </summary>
+        protected internal ConcurrentDictionary<int, HighPerfSocketConnection> _highPerfSocketConnections = new();
 
         /// <summary>
         /// Semaphore used while creating sockets
@@ -86,32 +102,32 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <summary>
         /// Whether to continue processing and forward unparsable messages to handlers
         /// </summary>
-    protected internal bool ProcessUnparsableMessages { get; set; }
+        protected internal bool ProcessUnparsableMessages { get; set; } = false;
 
         /// <inheritdoc />
         public double IncomingKbps
         {
             get
             {
-            if (socketConnections.IsEmpty)
+                if (_socketConnections.IsEmpty)
                     return 0;
 
-            return socketConnections.Sum(s => s.Value.IncomingKbps);
+                return _socketConnections.Sum(s => s.Value.IncomingKbps);
             }
         }
 
         /// <inheritdoc />
-    public int CurrentConnections => socketConnections.Count;
+        public int CurrentConnections => _socketConnections.Count;
 
         /// <inheritdoc />
         public int CurrentSubscriptions
         {
             get
             {
-            if (socketConnections.IsEmpty)
+                if (_socketConnections.IsEmpty)
                     return 0;
 
-            return socketConnections.Sum(s => s.Value.UserSubscriptionCount);
+                return _socketConnections.Sum(s => s.Value.UserSubscriptionCount);
             }
         }
 
@@ -121,6 +137,15 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <inheritdoc />
         public new SocketApiOptions ApiOptions => (SocketApiOptions)base.ApiOptions;
 
+        /// <summary>
+        /// The max number of individual subscriptions on a single connection
+        /// </summary>
+        public int? MaxIndividualSubscriptionsPerConnection { get; set; }
+
+        /// <summary>
+        /// Whether or not to enforce that sequence number updates are always (lastSequenceNumber + 1)
+        /// </summary>
+        public bool EnforceSequenceNumbers { get; set; }
         #endregion
 
         /// <summary>
@@ -162,6 +187,24 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             DedicatedConnectionConfigs.Add(new DedicatedConnectionConfig() { SocketAddress = url, Authenticated = auth });
         }
 
+        /// <summary>
+        /// Update the timestamp offset between client and server based on the timestamp
+        /// </summary>
+        /// <param name="timestamp">Timestamp received from the server</param>
+        public virtual void UpdateTimeOffset(DateTime timestamp)
+        {
+            if (timestamp == default)
+                return;
+
+            TimeOffsetManager.UpdateSocketOffset(ClientName, (DateTime.UtcNow - timestamp).TotalMilliseconds);
+        }
+
+        /// <summary>
+        /// Get the time offset between client and server
+        /// </summary>
+        /// <returns></returns>
+        public virtual TimeSpan? GetTimeOffset() => TimeOffsetManager.GetSocketOffset(ClientName);
+
         /// <summary>
         /// Add a query to periodically send on each connection
         /// </summary>
@@ -169,7 +212,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <param name="interval"></param>
         /// <param name="queryDelegate"></param>
         /// <param name="callback"></param>
-    protected virtual void RegisterPeriodicQuery(string identifier, TimeSpan interval, Func<SocketConnection, Query> queryDelegate, Action<SocketConnection, CallResult>? callback)
+        protected virtual void RegisterPeriodicQuery(string identifier, TimeSpan interval, Func<ISocketConnection, Query> queryDelegate, Action<SocketConnection, CallResult>? callback)
         {
             PeriodicTaskRegistrations.Add(new PeriodicTaskRegistration
             {
@@ -209,6 +252,9 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
                 return new CallResult<UpdateSubscription>(new NoApiCredentialsError());
             }
 
+            if (subscription.IndividualSubscriptionCount > MaxIndividualSubscriptionsPerConnection)
+                return new CallResult<UpdateSubscription>(ArgumentError.Invalid("subscriptions", $"Max number of subscriptions in a single call is {MaxIndividualSubscriptionsPerConnection}"));
+
             SocketConnection socketConnection;
             var released = false;
             // Wait for a semaphore here, so we only connect 1 socket at a time.
@@ -227,7 +273,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
                 while (true)
                 {
                     // Get a new or existing socket connection
-                var socketResult = await GetSocketConnection(url, subscription.Authenticated, false, subscription.Topic).ConfigureAwait(false);
+                    var socketResult = await GetSocketConnection(url, subscription.Authenticated, false, ct, subscription.Topic, subscription.IndividualSubscriptionCount).ConfigureAwait(false);
                     if (!socketResult)
                         return socketResult.As<UpdateSubscription>(null);
 
@@ -269,33 +315,13 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
                 return new CallResult<UpdateSubscription>(new ServerError(new ErrorInfo(ErrorType.WebsocketPaused, "Socket is paused")));
             }
 
-        var waitEvent = new AsyncResetEvent(false);
+            void HandleSubscriptionComplete(bool success, object? response)
-        var subQuery = subscription.CreateSubscriptionQuery(socketConnection);
-        if (subQuery != null)
             {
-            // Send the request and wait for answer
+                if (!success)
-            var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, waitEvent, ct).ConfigureAwait(false);
+                    return;
-            if (!subResult)
-            {
-                waitEvent?.Set();
-                var isTimeout = subResult.Error is CancellationRequestedError;
-                if (isTimeout && subscription.Confirmed)
-                {
-                    // No response received, but the subscription did receive updates. We'll assume success
-                }
-                else
-                {
-                    _logger.FailedToSubscribe(socketConnection.SocketId, subResult.Error?.ToString());
-                    // If this was a timeout we still need to send an unsubscribe to prevent messages coming in later
-                    await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
-                    return new CallResult<UpdateSubscription>(subResult.Error!);
-                }
-            }
 
-            subscription.HandleSubQueryResponse(subQuery.Response!);
+                subscription.HandleSubQueryResponse(socketConnection, response);
-        }
+                subscription.Status = SubscriptionStatus.Subscribed;
-
-        subscription.Confirmed = true;
                 if (ct != default)
                 {
                     subscription.CancellationTokenRegistration = ct.Register(async () =>
@@ -304,12 +330,138 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
                         await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
                     }, false);
                 }
+            }
+
+            subscription.Status = SubscriptionStatus.Subscribing;
+            var subQuery = subscription.CreateSubscriptionQuery(socketConnection);
+            if (subQuery != null)
+            {
+                subQuery.OnComplete = () => HandleSubscriptionComplete(subQuery.Result?.Success ?? false, subQuery.Response);
+
+                // Send the request and wait for answer
+                var subResult = await socketConnection.SendAndWaitQueryAsync(subQuery, ct).ConfigureAwait(false);
+                if (!subResult)
+                {
+                    var isTimeout = subResult.Error is CancellationRequestedError;
+                    if (isTimeout && subscription.Status == SubscriptionStatus.Subscribed)
+                    {
+                        // No response received, but the subscription did receive updates. We'll assume success
+                    }
+                    else
+                    {
+                        _logger.FailedToSubscribe(socketConnection.SocketId, subResult.Error?.ToString());
+                        // If this was a server process error we still might need to send an unsubscribe to prevent messages coming in later
+                        subscription.Status = SubscriptionStatus.Pending;
+                        await socketConnection.CloseAsync(subscription).ConfigureAwait(false);
+                        return new CallResult<UpdateSubscription>(subResult.Error!);
+                    }
+                }
+            }
+            else 
+            {
+                HandleSubscriptionComplete(true, null);
+            }
 
-        waitEvent?.Set();
             _logger.SubscriptionCompletedSuccessfully(socketConnection.SocketId, subscription.Id);
             return new CallResult<UpdateSubscription>(new UpdateSubscription(socketConnection, subscription));
         }
 
+        /// <summary>
+        /// Connect to an url and listen for data
+        /// </summary>
+        /// <param name="url">The URL to connect to</param>
+        /// <param name="subscription">The subscription</param>
+        /// <param name="connectionFactory">The factory for creating a socket connection</param>
+        /// <param name="ct">Cancellation token for closing this subscription</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<HighPerfUpdateSubscription>> SubscribeHighPerfAsync<TUpdateType>(
+            string url,
+            HighPerfSubscription<TUpdateType> subscription,
+            IHighPerfConnectionFactory connectionFactory,
+            CancellationToken ct)
+        {
+            if (_disposing)
+                return new CallResult<HighPerfUpdateSubscription>(new InvalidOperationError("Client disposed, can't subscribe"));
+
+            HighPerfSocketConnection<TUpdateType> socketConnection;
+            var released = false;
+            // Wait for a semaphore here, so we only connect 1 socket at a time.
+            // This is necessary for being able to see if connections can be combined
+            try
+            {
+                await semaphoreSlim.WaitAsync(ct).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException tce)
+            {
+                return new CallResult<HighPerfUpdateSubscription>(new CancellationRequestedError(tce));
+            }
+
+            try
+            {
+                while (true)
+                {
+                    // Get a new or existing socket connection
+                    var socketResult = await GetHighPerfSocketConnection<TUpdateType>(url, connectionFactory, ct).ConfigureAwait(false);
+                    if (!socketResult)
+                        return socketResult.As<HighPerfUpdateSubscription>(null);
+
+                    socketConnection = socketResult.Data;
+
+                    // Add a subscription on the socket connection
+                    var success = socketConnection.AddSubscription(subscription);
+                    if (!success)
+                    {
+                        _logger.FailedToAddSubscriptionRetryOnDifferentConnection(socketConnection.SocketId);
+                        continue;
+                    }
+
+                    if (ClientOptions.SocketSubscriptionsCombineTarget == 1)
+                    {
+                        // Only 1 subscription per connection, so no need to wait for connection since a new subscription will create a new connection anyway
+                        semaphoreSlim.Release();
+                        released = true;
+                    }
+
+                    var needsConnecting = !socketConnection.Connected;
+
+                    var connectResult = await ConnectIfNeededAsync(socketConnection, false, ct).ConfigureAwait(false);
+                    if (!connectResult)
+                        return new CallResult<HighPerfUpdateSubscription>(connectResult.Error!);
+
+                    break;
+                }
+            }
+            finally
+            {
+                if (!released)
+                    semaphoreSlim.Release();
+            }
+
+            var subRequest = subscription.CreateSubscriptionQuery(socketConnection);
+            if (subRequest != null)
+            {
+                // Send the request and wait for answer
+                var sendResult = await socketConnection.SendAsync(subRequest).ConfigureAwait(false);
+                if (!sendResult)
+                {
+                    await socketConnection.CloseAsync().ConfigureAwait(false);
+                    return new CallResult<HighPerfUpdateSubscription>(sendResult.Error!);                    
+                }
+            }
+
+            if (ct != default)
+            {
+                subscription.CancellationTokenRegistration = ct.Register(async () =>
+                {
+                    _logger.CancellationTokenSetClosingSubscription(socketConnection.SocketId, subscription.Id);
+                    await socketConnection.CloseAsync().ConfigureAwait(false);
+                }, false);
+            }
+
+            _logger.SubscriptionCompletedSuccessfully(socketConnection.SocketId, subscription.Id);
+            return new CallResult<HighPerfUpdateSubscription>(new HighPerfUpdateSubscription(socketConnection, subscription));
+        }
+
         /// <summary>
         /// Send a query on a socket connection to the BaseAddress and wait for the response
         /// </summary>
@@ -340,16 +492,10 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
 
             SocketConnection socketConnection;
             var released = false;
-
+            await semaphoreSlim.WaitAsync().ConfigureAwait(false);
             try
             {
-            await semaphoreSlim.WaitAsync(ct).ConfigureAwait(false);
+                var socketResult = await GetSocketConnection(url, query.Authenticated, true, ct).ConfigureAwait(false);
-        }
-        catch (OperationCanceledException) { }
-
-        try
-        {
-            var socketResult = await GetSocketConnection(url, query.Authenticated, true).ConfigureAwait(false);
                 if (!socketResult)
                     return socketResult.As<THandlerResponse>(default);
 
@@ -381,7 +527,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             if (ct.IsCancellationRequested)
                 return new CallResult<THandlerResponse>(new CancellationRequestedError());
 
-        return await socketConnection.SendAndWaitQueryAsync(query, null, ct).ConfigureAwait(false);
+            return await socketConnection.SendAndWaitQueryAsync(query, ct).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -391,7 +537,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <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, CancellationToken ct)
+        protected virtual async Task<CallResult> ConnectIfNeededAsync(ISocketConnection socket, bool authenticated, CancellationToken ct)
         {
             if (socket.Connected)
                 return CallResult.SuccessResult;
@@ -401,18 +547,15 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
                 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;
 
-        var result = await AuthenticateSocketAsync(socket).ConfigureAwait(false);
+            if (socket is not SocketConnection sc)
+                throw new InvalidOperationException("HighPerfSocketConnection not supported for authentication");
+
+            var result = await AuthenticateSocketAsync(sc).ConfigureAwait(false);
             if (!result)
                 await socket.CloseAsync().ConfigureAwait(false);
 
@@ -456,7 +599,8 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// Should return the request which can be used to authenticate a socket connection
         /// </summary>
         /// <returns></returns>
-    protected internal virtual Task<Query?> GetAuthenticationRequestAsync(SocketConnection connection) => throw new NotImplementedException();
+        protected internal virtual Task<Query?> GetAuthenticationRequestAsync(SocketConnection connection) => 
+            Task.FromResult(AuthenticationProvider!.GetAuthenticationQuery(this, connection));
 
         /// <summary>
         /// Adds a system subscription. Used for example to reply to ping requests
@@ -465,7 +609,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         protected void AddSystemSubscription(SystemSubscription systemSubscription)
         {
             systemSubscriptions.Add(systemSubscription);
-        foreach (var connection in socketConnections.Values)
+            foreach (var connection in _socketConnections.Values)
                 connection.AddSubscription(systemSubscription);
         }
 
@@ -485,7 +629,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// </summary>
         /// <param name="connection"></param>
         /// <returns></returns>
-    protected internal virtual Task<Uri?> GetReconnectUriAsync(SocketConnection connection)
+        protected internal virtual Task<Uri?> GetReconnectUriAsync(ISocketConnection connection)
         {
             return Task.FromResult<Uri?>(connection.ConnectionUri);
         }
@@ -506,36 +650,94 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <param name="address">The address the socket is for</param>
         /// <param name="authenticated">Whether the socket should be authenticated</param>
         /// <param name="dedicatedRequestConnection">Whether a dedicated request connection should be returned</param>
+        /// <param name="ct">Cancellation token</param>
         /// <param name="topic">The subscription topic, can be provided when multiple of the same topics are not allowed on a connection</param>
+        /// <param name="individualSubscriptionCount">The number of individual subscriptions in this subscribe request</param>
         /// <returns></returns>
-    protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(string address, bool authenticated, bool dedicatedRequestConnection, string? topic = null)
+        protected virtual async Task<CallResult<SocketConnection>> GetSocketConnection(
+            string address,
+            bool authenticated,
+            bool dedicatedRequestConnection, 
+            CancellationToken ct,
+            string? topic = null,
+            int individualSubscriptionCount = 1)
         {
-        var socketQuery = socketConnections.Where(s => (s.Value.Status == SocketConnection.SocketStatus.None || s.Value.Status == SocketConnection.SocketStatus.Connected)
+            var socketQuery = _socketConnections.Where(s => s.Value.Tag.TrimEnd('/') == address.TrimEnd('/')
-                                                  && s.Value.Tag.TrimEnd('/') == address.TrimEnd('/')
                                                       && s.Value.ApiClient.GetType() == GetType()
-                                                  && (s.Value.Authenticated == authenticated || !authenticated)
+                                                      && (AllowTopicsOnTheSameConnection || !s.Value.Topics.Contains(topic)))
-                                                  && (AllowTopicsOnTheSameConnection || !s.Value.Topics.Contains(topic))
+                                                .Select(x => x.Value)
-                                                  && s.Value.Connected);
+                                                .ToList();
 
-        SocketConnection connection;
+            // If all current socket connections are reconnecting or resubscribing wait for that to finish as we can probably use the existing connection
+            var delayStart = DateTime.UtcNow;
+            var delayed = false;
+            while (socketQuery.Count >= 1 && socketQuery.All(x => x.Status == SocketStatus.Reconnecting || x.Status == SocketStatus.Resubscribing))
+            {
+                if (DateTime.UtcNow - delayStart > TimeSpan.FromSeconds(10))
+                {
+                    if (socketQuery.Count >= 1 && socketQuery.All(x => x.Status == SocketStatus.Reconnecting || x.Status == SocketStatus.Resubscribing))
+                    {
+                        // If after this time we still trying to reconnect/reprocess there is some issue in the connection
+                        _logger.TimeoutWaitingForReconnectingSocket();
+                        return new CallResult<SocketConnection>(new CantConnectError());
+                    }
+
+                    break;
+                }
+
+                delayed = true;
+                try { await Task.Delay(50, ct).ConfigureAwait(false); } catch (Exception) { }
+
+                if (ct.IsCancellationRequested)
+                    return new CallResult<SocketConnection>(new CancellationRequestedError());
+            }
+
+            if (delayed)
+                _logger.WaitedForReconnectingSocket((long)(DateTime.UtcNow - delayStart).TotalMilliseconds);
+
+            socketQuery = socketQuery.Where(s => (s.Status == SocketStatus.None || s.Status == SocketStatus.Connected)                                                     
+                                                && (s.Authenticated == authenticated || !authenticated)
+                                                && s.Connected).ToList();
+
+            SocketConnection? connection;
             if (!dedicatedRequestConnection)
             {
-            connection = socketQuery.Where(s => !s.Value.DedicatedRequestConnection.IsDedicatedRequestConnection).OrderBy(s => s.Value.UserSubscriptionCount).FirstOrDefault().Value;
+                connection = socketQuery.Where(s => !s.DedicatedRequestConnection.IsDedicatedRequestConnection).OrderBy(s => s.UserSubscriptionCount).FirstOrDefault();
             }
             else
             {
-            connection = socketQuery.Where(s => s.Value.DedicatedRequestConnection.IsDedicatedRequestConnection).FirstOrDefault().Value;
+                connection = socketQuery.Where(s => s.DedicatedRequestConnection.IsDedicatedRequestConnection).FirstOrDefault();
                 if (connection != null && !connection.DedicatedRequestConnection.Authenticated)
                     // Mark dedicated request connection as authenticated if the request is authenticated
                     connection.DedicatedRequestConnection.Authenticated = authenticated;
+
+                if (connection == null)
+                    // Fall back to an existing connection if there is no dedicated request connection available
+                    connection = socketQuery.OrderBy(s => s.UserSubscriptionCount).FirstOrDefault();
             }
 
+            bool maxConnectionsReached = _socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections);
             if (connection != null)
             {
-            if (connection.UserSubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget || (socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections) && socketConnections.All(s => s.Value.UserSubscriptionCount >= ClientOptions.SocketSubscriptionsCombineTarget)))
+                bool lessThanBatchSubCombineTarget = connection.UserSubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget;
+                bool lessThanIndividualSubCombineTarget = connection.Subscriptions.Sum(x => x.IndividualSubscriptionCount) < ClientOptions.SocketIndividualSubscriptionCombineTarget;
+
+                if ((lessThanBatchSubCombineTarget && lessThanIndividualSubCombineTarget)
+                    || maxConnectionsReached) 
+                {
                     // Use existing socket if it has less than target connections OR it has the least connections and we can't make new
+                    // If there is a max subscriptions per connection limit also only use existing if the new subscription doesn't go over the limit
+                    if (MaxIndividualSubscriptionsPerConnection == null)
+                        return new CallResult<SocketConnection>(connection);
+                                        
+                    var currentCount = connection.Subscriptions.Sum(x => x.IndividualSubscriptionCount);
+                    if (currentCount + individualSubscriptionCount <= MaxIndividualSubscriptionsPerConnection)
                         return new CallResult<SocketConnection>(connection);
                 }
+            }
+
+            if (maxConnectionsReached)
+                return new CallResult<SocketConnection>(new InvalidOperationError("Max amount of socket connections reached"));
 
             var connectionAddress = await GetConnectionUrlAsync(address, authenticated).ConfigureAwait(false);
             if (!connectionAddress)
@@ -547,9 +749,8 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             if (connectionAddress.Data != address)
                 _logger.ConnectionAddressSetTo(connectionAddress.Data!);
 
-        // Create new socket
+            // Create new socket connection
-        var socket = CreateSocket(connectionAddress.Data!);
+            var socketConnection = new SocketConnection(_logger, SocketFactory, GetWebSocketParameters(connectionAddress.Data!), this, address);
-        var socketConnection = new SocketConnection(_logger, this, socket, address);
             socketConnection.UnhandledMessage += HandleUnhandledMessage;
             socketConnection.ConnectRateLimitedAsync += HandleConnectRateLimitedAsync;
             if (dedicatedRequestConnection)
@@ -570,6 +771,38 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             return new CallResult<SocketConnection>(socketConnection);
         }
 
+
+        /// <summary>
+        /// Gets a connection for a new subscription or query. Can be an existing if there are open position or a new one.
+        /// </summary>
+        /// <param name="address">The address the socket is for</param>
+        /// <param name="connectionFactory">The factory for creating a socket connection</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns></returns>
+        protected virtual async Task<CallResult<HighPerfSocketConnection<TUpdateType>>> GetHighPerfSocketConnection<TUpdateType>(
+            string address,
+            IHighPerfConnectionFactory connectionFactory,
+            CancellationToken ct)
+        {
+            var connectionAddress = await GetConnectionUrlAsync(address, false).ConfigureAwait(false);
+            if (!connectionAddress)
+            {
+                _logger.FailedToDetermineConnectionUrl(connectionAddress.Error?.ToString());
+                return connectionAddress.As<HighPerfSocketConnection<TUpdateType>>(null);
+            }
+
+            if (connectionAddress.Data != address)
+                _logger.ConnectionAddressSetTo(connectionAddress.Data!);
+
+            // Create new socket connection
+            var socketConnection = connectionFactory.CreateHighPerfConnection<TUpdateType>(_logger, SocketFactory, GetWebSocketParameters(connectionAddress.Data!), this, address);
+            foreach (var ptg in PeriodicTaskRegistrations)
+                socketConnection.QueryPeriodic(ptg.Identifier, ptg.Interval, (con) => ptg.QueryDelegate(con).Request);
+
+            return new CallResult<HighPerfSocketConnection<TUpdateType>>(socketConnection);
+        }
+
+
         /// <summary>
         /// Process an unhandled message
         /// </summary>
@@ -598,12 +831,15 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <param name="socketConnection">The socket to connect</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns></returns>
-    protected virtual async Task<CallResult> ConnectSocketAsync(SocketConnection socketConnection, CancellationToken ct)
+        protected virtual async Task<CallResult> ConnectSocketAsync(ISocketConnection socketConnection, CancellationToken ct)
         {
             var connectResult = await socketConnection.ConnectAsync(ct).ConfigureAwait(false);
             if (connectResult)
             {
-            socketConnections.TryAdd(socketConnection.SocketId, socketConnection);
+                if (socketConnection is SocketConnection sc)
+                    _socketConnections.TryAdd(socketConnection.SocketId, sc);
+                else if (socketConnection is HighPerfSocketConnection hsc)
+                    _highPerfSocketConnections.TryAdd(socketConnection.SocketId, hsc);
                 return connectResult;
             }
 
@@ -627,20 +863,9 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
                 Proxy = ClientOptions.Proxy,
                 Timeout = ApiOptions.SocketNoDataTimeout ?? ClientOptions.SocketNoDataTimeout,
                 ReceiveBufferSize = ClientOptions.ReceiveBufferSize,
+                UseUpdatedDeserialization = ClientOptions.UseUpdatedDeserialization
             };
 
-    /// <summary>
-    /// Create a socket for an address
-    /// </summary>
-    /// <param name="address">The address the socket should connect to</param>
-    /// <returns></returns>
-    protected virtual IWebsocket CreateSocket(string address)
-    {
-        var socket = SocketFactory.CreateWebsocket(_logger, GetWebSocketParameters(address));
-        _logger.SocketCreatedForAddress(socket.Id, address);
-        return socket;
-    }
-
         /// <summary>
         /// Unsubscribe an update subscription
         /// </summary>
@@ -650,7 +875,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         {
             Subscription? subscription = null;
             SocketConnection? connection = null;
-        foreach (var socket in socketConnections.Values.ToList())
+            foreach (var socket in _socketConnections.Values.ToList())
             {
                 subscription = socket.GetSubscription(subscriptionId);
                 if (subscription != null)
@@ -688,20 +913,24 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <returns></returns>
         public virtual async Task UnsubscribeAllAsync()
         {
-        var sum = socketConnections.Sum(s => s.Value.UserSubscriptionCount);
+            var sum = _socketConnections.Sum(s => s.Value.UserSubscriptionCount) + _highPerfSocketConnections.Sum(s => s.Value.UserSubscriptionCount);
             if (sum == 0)
                 return;
 
-        _logger.UnsubscribingAll(socketConnections.Sum(s => s.Value.UserSubscriptionCount));
+            _logger.UnsubscribingAll(sum);
             var tasks = new List<Task>();
-        {
+            
-            var socketList = socketConnections.Values;
+            var socketList = _socketConnections.Values;
             foreach (var connection in socketList)
             {
                 foreach(var subscription in connection.Subscriptions.Where(x => x.UserSubscription))
                     tasks.Add(connection.CloseAsync(subscription));
             }
-        }
+
+            var highPerfSocketList = _highPerfSocketConnections.Values;
+            foreach (var connection in highPerfSocketList)
+                tasks.Add(connection.CloseAsync());
+            
 
             await Task.WhenAll(tasks.ToArray()).ConfigureAwait(false);
         }
@@ -712,10 +941,10 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <returns></returns>
         public virtual async Task ReconnectAsync()
         {
-        _logger.ReconnectingAllConnections(socketConnections.Count);
+            _logger.ReconnectingAllConnections(_socketConnections.Count);
             var tasks = new List<Task>();
             {
-            var socketList = socketConnections.Values;
+                var socketList = _socketConnections.Values;
                 foreach (var sub in socketList)
                     tasks.Add(sub.TriggerReconnectAsync());
             }
@@ -728,7 +957,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         {
             foreach (var item in DedicatedConnectionConfigs)
             {
-            var socketResult = await GetSocketConnection(item.SocketAddress, item.Authenticated, true).ConfigureAwait(false);
+                var socketResult = await GetSocketConnection(item.SocketAddress, item.Authenticated, true, CancellationToken.None).ConfigureAwait(false);
                 if (!socketResult)
                     return socketResult.AsDataless();
 
@@ -747,7 +976,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             base.SetOptions(options);
 
             if ((!previousProxyIsSet && options.Proxy == null)
-            || socketConnections.IsEmpty)
+                || _socketConnections.IsEmpty)
             {
                 return;
             }
@@ -755,7 +984,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             _logger.LogInformation("Reconnecting websockets to apply proxy");
 
             // Update proxy, also triggers reconnect
-        foreach (var connection in socketConnections)
+            foreach (var connection in _socketConnections)
                 _ = connection.Value.UpdateProxy(options.Proxy);
         }
 
@@ -774,15 +1003,15 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <returns></returns>
         public SocketApiClientState GetState(bool includeSubDetails = true)
         {
-        var connectionStates = new List<SocketConnection.SocketConnectionState>();
+            var connectionStates = new List<SocketConnectionState>();
-        foreach (var socketIdAndConnection in socketConnections)
+            foreach (var socketIdAndConnection in _socketConnections)
             {
                 SocketConnection connection = socketIdAndConnection.Value;
-            SocketConnection.SocketConnectionState connectionState = connection.GetState(includeSubDetails);
+                SocketConnectionState connectionState = connection.GetState(includeSubDetails);
                 connectionStates.Add(connectionState);
             }
 
-        return new SocketApiClientState(socketConnections.Count, CurrentSubscriptions, IncomingKbps, connectionStates);
+            return new SocketApiClientState(_socketConnections.Count, CurrentSubscriptions, IncomingKbps, connectionStates);
         }
 
         /// <summary>
@@ -796,7 +1025,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             int Connections,
             int Subscriptions,
             double DownloadSpeed,
-        List<SocketConnection.SocketConnectionState> ConnectionStates)
+            List<SocketConnectionState> ConnectionStates)
         {
             /// <summary>
             /// Print the state of the client
@@ -825,7 +1054,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
                         cs.SubscriptionStates.ForEach(subState =>
                         {
                             sb.AppendLine($"\t\t\tId: {subState.Id}");
-                        sb.AppendLine($"\t\t\tConfirmed: {subState.Confirmed}");
+                            sb.AppendLine($"\t\t\tStatus: {subState.Status}");
                             sb.AppendLine($"\t\t\tInvocations: {subState.Invocations}");
                             sb.AppendLine($"\t\t\tIdentifiers: [{subState.ListenMatcher.ToString()}]");
                         });
@@ -839,15 +1068,12 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <summary>
         /// Dispose the client
         /// </summary>
-    public override void Dispose(bool disposing)
+        public override void Dispose()
         {
-        if (disposing)
-            return;
-
             _disposing = true;
             var tasks = new List<Task>();
             {
-            var socketList = socketConnections.Values.Where(x => x.UserSubscriptionCount > 0 || x.Connected);
+                var socketList = _socketConnections.Values.Where(x => x.UserSubscriptionCount > 0 || x.Connected);
                 if (socketList.Any())
                     _logger.DisposingSocketClient();
 
@@ -858,7 +1084,7 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
             }
 
             semaphoreSlim?.Dispose();
-        base.Dispose(disposing);
+            base.Dispose();
         }
 
         /// <summary>
@@ -871,9 +1097,16 @@ public abstract class SocketApiClient : BaseApiClient, ISocketApiClient
         /// <summary>
         /// Preprocess a stream message
         /// </summary>
-    /// <param name="connection"></param>
+        public virtual ReadOnlySpan<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlySpan<byte> data) => data;
-    /// <param name="type"></param>
+        /// <summary>
-    /// <param name="data"></param>
+        /// Preprocess a stream message
-    /// <returns></returns>
+        /// </summary>
         public virtual ReadOnlyMemory<byte> PreprocessStreamMessage(SocketConnection connection, WebSocketMessageType type, ReadOnlyMemory<byte> data) => data;
+
+        /// <summary>
+        /// Create a new message converter instance
+        /// </summary>
+        /// <returns></returns>
+        public abstract ISocketMessageHandler CreateMessageConverter(WebSocketMessageType messageType);
+    }
 }

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,3 +22,4 @@ public class ArrayPropertyAttribute : Attribute
             Index = index;
         }
     }
+}

CryptoExchange.Net/Converters/JsonSerializerContextCache.cs

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

CryptoExchange.Net/Converters/MessageParsing/DynamicConverters/IRestMessageHandler.cs

@@ -0,0 +1,64 @@
+using CryptoExchange.Net.Objects;
+using System.IO;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// REST message handler
+    /// </summary>
+    public interface IRestMessageHandler
+    {
+        /// <summary>
+        /// The `accept` HTTP response header for the request
+        /// </summary>
+        MediaTypeWithQualityHeaderValue AcceptHeader { get; }
+
+        /// <summary>
+        /// Whether a seekable stream is required
+        /// </summary>
+        bool RequiresSeekableStream { get; }
+
+        /// <summary>
+        /// Parse the response when the HTTP response status indicated an error
+        /// </summary>
+        ValueTask<Error> ParseErrorResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <summary>
+        /// Parse the response when the HTTP response status indicated a rate limit error
+        /// </summary>
+        ValueTask<ServerRateLimitError> ParseErrorRateLimitResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <summary>
+        /// Check if the response is an error response; if so return the error.<br />
+        /// Note that if the API returns a standard result wrapper, something like this:
+        /// <code>{ "code": 400, "msg": "error", "data": {} }</code> 
+        /// then the `CheckDeserializedResponse` method should be used for checking the result
+        /// </summary>
+        ValueTask<Error?> CheckForErrorResponse(
+            RequestDefinition request,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <summary>
+        /// Deserialize the response stream
+        /// </summary>
+        ValueTask<(T? Result, Error? Error)> TryDeserializeAsync<T>(
+            Stream responseStream,
+            CancellationToken ct);
+
+        /// <summary>
+        /// Check whether the resulting T object indicates an error or not
+        /// </summary>
+        Error? CheckDeserializedResponse<T>(HttpResponseHeaders responseHeaders, T result);
+    }
+
+}

CryptoExchange.Net/Converters/MessageParsing/DynamicConverters/ISocketMessageHandler.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Net.WebSockets;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// WebSocket message handler
+    /// </summary>
+    public interface ISocketMessageHandler
+    {
+        /// <summary>
+        /// Get an identifier for the message which can be used to determine the type of the message
+        /// </summary>
+        string? GetTypeIdentifier(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType);
+
+        /// <summary>
+        /// Get optional topic filter, for example a symbol name
+        /// </summary>
+        string? GetTopicFilter(object deserializedObject);
+
+        /// <summary>
+        /// Deserialize to the provided type
+        /// </summary>
+        object Deserialize(ReadOnlySpan<byte> data, Type type);
+    }
+
+}

CryptoExchange.Net/Converters/MessageParsing/DynamicConverters/MessageConverterTypes.cs

@@ -0,0 +1,46 @@
+using System;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// Message type definition
+    /// </summary>
+    public class MessageTypeDefinition
+    {
+        /// <summary>
+        /// Whether to immediately select the definition when it is matched. Can only be used when the evaluator has a single unique field to look for
+        /// </summary>
+        public bool ForceIfFound { get; set; }
+        /// <summary>
+        /// The fields a message needs to contain for this definition
+        /// </summary>
+        public MessageFieldReference[] Fields { get; set; } = [];
+        /// <summary>
+        /// The callback for getting the identifier string
+        /// </summary>
+        public Func<SearchResult, string>? TypeIdentifierCallback { get; set; }
+        /// <summary>
+        /// The static identifier string to return when this evaluator is matched
+        /// </summary>
+        public string? StaticIdentifier { get; set; }
+        
+        internal string? GetMessageType(SearchResult result)
+        {
+            if (StaticIdentifier != null)
+                return StaticIdentifier;
+
+            return TypeIdentifierCallback!(result);
+        }
+
+        internal bool Satisfied(SearchResult result)
+        {
+            foreach(var field in Fields)
+            {
+                if (!result.Contains(field))
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}

CryptoExchange.Net/Converters/MessageParsing/DynamicConverters/MessageEvalutorFieldReference.cs

@@ -0,0 +1,15 @@
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    internal class MessageEvalutorFieldReference
+    {
+        public bool SkipReading { get; set; }
+        public bool OverlappingField { get; set; }
+        public MessageFieldReference Field { get; set; }
+        public MessageTypeDefinition? ForceEvaluator { get; set; }
+
+        public MessageEvalutorFieldReference(MessageFieldReference field)
+        {
+            Field = field;
+        }
+    }
+}

CryptoExchange.Net/Converters/MessageParsing/DynamicConverters/MessageFieldReference.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// Reference to a message field
+    /// </summary>
+    public abstract class MessageFieldReference
+    {
+        /// <summary>
+        /// The name for this search field
+        /// </summary>
+        public string SearchName { get; set; }
+        /// <summary>
+        /// The depth at which to look for this field
+        /// </summary>
+        public int Depth { get; set; } = 1;
+        /// <summary>
+        /// Callback to check if the field value matches an expected constraint
+        /// </summary>
+        public Func<string?, bool>? Constraint { get; private set; }
+
+        /// <summary>
+        /// Check whether the value is one of the string values in the set
+        /// </summary>
+        public MessageFieldReference WithFilterConstraint(HashSet<string?> set)
+        {
+            Constraint = set.Contains;
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value is equal to a string
+        /// </summary>
+        public MessageFieldReference WithEqualConstraint(string compare)
+        {
+            Constraint = x => x != null && x.Equals(compare, StringComparison.Ordinal);
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value is not equal to a string
+        /// </summary>
+        public MessageFieldReference WithNotEqualConstraint(string compare)
+        {
+            Constraint = x => x == null || !x.Equals(compare, StringComparison.Ordinal);
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value is not null
+        /// </summary>
+        public MessageFieldReference WithNotNullConstraint()
+        {
+            Constraint = x => x != null;
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value starts with a certain string
+        /// </summary>
+        public MessageFieldReference WithStartsWithConstraint(string start)
+        {
+            Constraint = x => x != null && x.StartsWith(start, StringComparison.Ordinal);
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value starts with a certain string
+        /// </summary>
+        public MessageFieldReference WithStartsWithConstraints(params string[] startValues)
+        {
+            Constraint = x =>
+            {
+                if (x == null)
+                    return false;
+
+                foreach (var item in startValues)
+                {
+                    if (x!.StartsWith(item, StringComparison.Ordinal))
+                        return true;
+                }
+
+                return false;
+            };
+            return this;
+        }
+
+        /// <summary>
+        /// Check whether the value starts with a certain string
+        /// </summary>
+        public MessageFieldReference WithCustomConstraint(Func<string?, bool> constraint)
+        {
+            Constraint = constraint;
+            return this;
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public MessageFieldReference(string searchName)
+        {
+            SearchName = searchName;
+        }
+    }
+
+    /// <summary>
+    /// Reference to a property message field
+    /// </summary>
+    public class PropertyFieldReference : MessageFieldReference
+    {
+        /// <summary>
+        /// The property name in the JSON
+        /// </summary>
+        public byte[] PropertyName { get; set; }
+        /// <summary>
+        /// Whether the property value is array values
+        /// </summary>
+        public bool ArrayValues { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public PropertyFieldReference(string propertyName) : base(propertyName)
+        {
+            PropertyName = Encoding.UTF8.GetBytes(propertyName);
+        }
+    }
+
+    /// <summary>
+    /// Reference to an array message field
+    /// </summary>
+    public class ArrayFieldReference : MessageFieldReference
+    {
+        /// <summary>
+        /// The index in the array
+        /// </summary>
+        public int ArrayIndex { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public ArrayFieldReference(string searchName, int depth, int index) : base(searchName)
+        {
+            Depth = depth;
+            ArrayIndex = index;
+        }
+    }
+
+}

CryptoExchange.Net/Converters/MessageParsing/DynamicConverters/SearchResult.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// The results of a search for fields in a JSON message
+    /// </summary>
+    public class SearchResult
+    {
+        private List<SearchResultItem> _items = new List<SearchResultItem>();
+
+        /// <summary>
+        /// Get the value of a field
+        /// </summary>
+        public string? FieldValue(string searchName)
+        {
+            foreach (var item in _items)
+            {
+                if (item.Field.SearchName.Equals(searchName, StringComparison.Ordinal))
+                    return item.Value;
+            }
+
+            throw new Exception($"No field value found for {searchName}");
+        }
+
+        /// <summary>
+        /// The number of found search field values
+        /// </summary>
+        public int Count => _items.Count;
+
+        /// <summary>
+        /// Clear the search result
+        /// </summary>
+        public void Clear() => _items.Clear();
+
+        /// <summary>
+        /// Whether the value for a specific field was found
+        /// </summary>
+        public bool Contains(MessageFieldReference field)
+        {
+            foreach (var item in _items)
+            {
+                if (item.Field == field)
+                    return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Write a value to the result
+        /// </summary>
+        public void Write(MessageFieldReference field, string? value) => _items.Add(new SearchResultItem
+        {
+            Field = field,
+            Value = value
+        });
+    }
+}

CryptoExchange.Net/Converters/MessageParsing/DynamicConverters/SearchResultItem.cs

@@ -0,0 +1,17 @@
+namespace CryptoExchange.Net.Converters.MessageParsing.DynamicConverters
+{
+    /// <summary>
+    /// Search result value
+    /// </summary>
+    public struct SearchResultItem
+    {
+        /// <summary>
+        /// The field the values is for
+        /// </summary>
+        public MessageFieldReference Field { get; set; }
+        /// <summary>
+        /// The value of the field
+        /// </summary>
+        public string? Value { get; set; }
+    }
+}

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,3 +46,4 @@ public readonly struct NodeAccessor
         /// <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,3 +47,4 @@ public readonly struct MessagePath : IEnumerable<NodeAccessor>
             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,3 +40,4 @@ public static class MessagePathExtension
             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,3 +18,4 @@ public enum NodeType
         /// </summary>
         Value
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/ArrayConverter.cs

@@ -1,17 +1,16 @@
+using CryptoExchange.Net.Exceptions;
 using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
-using System.Text.Json.Serialization;
 using System.Text.Json;
-using System.Collections.Generic;
+using System.Text.Json.Serialization;
-#if NET5_0_OR_GREATER
-using System.Diagnostics.CodeAnalysis;
-#endif
 using System.Threading;
 
-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
@@ -22,7 +21,7 @@ public class ArrayConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMembe
     public class ArrayConverter<T> : JsonConverter<T> where T : new()
 #endif
     {
-    private static readonly Lazy<List<ArrayPropertyInfo>> _typePropertyInfo = new Lazy<List<ArrayPropertyInfo>>(CacheTypeAttributes, LazyThreadSafetyMode.PublicationOnly);
+        private static SortedDictionary<int, List<ArrayPropertyInfo>>? _typePropertyInfo;
 
         /// <inheritdoc />
 #if NET5_0_OR_GREATER
@@ -37,13 +36,17 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
                 return;
             }
 
-        writer.WriteStartArray();
+            if (_typePropertyInfo == null)
+                _typePropertyInfo = CacheTypeAttributes();
 
-        var ordered = _typePropertyInfo.Value.Where(x => x.ArrayProperty != null).OrderBy(p => p.ArrayProperty.Index);
+            writer.WriteStartArray();
             var last = -1;
-        foreach (var prop in ordered)
+            foreach (var indexProps in _typePropertyInfo)
+            {
+                foreach (var prop in indexProps.Value)
                 {
                     if (prop.ArrayProperty.Index == last)
+                        // Don't write the same index twice
                         continue;
 
                     while (prop.ArrayProperty.Index != last + 1)
@@ -87,6 +90,7 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
                         JsonSerializer.Serialize(writer, objValue, typeOptions ?? options);
                     }
                 }
+            }
 
             writer.WriteEndArray();
         }
@@ -111,7 +115,11 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
 #endif
         {
             if (reader.TokenType != JsonTokenType.StartArray)
-            throw new Exception("Not an array");
+                throw new CeDeserializationException("Not an array");
+
+
+            if (_typePropertyInfo == null)
+                _typePropertyInfo = CacheTypeAttributes();
 
             int index = 0;
             while (reader.Read())
@@ -119,8 +127,7 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
                 if (reader.TokenType == JsonTokenType.EndArray)
                     break;
 
-            var indexAttributes = _typePropertyInfo.Value.Where(a => a.ArrayProperty.Index == index);
+                if(!_typePropertyInfo.TryGetValue(index, out var indexAttributes))
-            if (!indexAttributes.Any())
                 {
                     index++;
                     continue;
@@ -160,7 +167,7 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
                             JsonTokenType.String => reader.GetString(),
                             JsonTokenType.Number => reader.GetDecimal(),
                             JsonTokenType.StartObject => JsonSerializer.Deserialize(ref reader, attribute.TargetType, options),
-                        _ => throw new NotImplementedException($"Array deserialization of type {reader.TokenType} not supported"),
+                            _ => throw new CeDeserializationException($"Array deserialization of type {reader.TokenType} not supported"),
                         };
                     }
 
@@ -192,12 +199,12 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
 #if NET5_0_OR_GREATER
         [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
         [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
-    private static List<ArrayPropertyInfo> CacheTypeAttributes()
+        private static SortedDictionary<int, List<ArrayPropertyInfo>> CacheTypeAttributes()
 #else
-    private static List<ArrayPropertyInfo> CacheTypeAttributes()
+        private static SortedDictionary<int, List<ArrayPropertyInfo>> CacheTypeAttributes()
 #endif
         {
-        var attributes = new List<ArrayPropertyInfo>();
+            var result = new SortedDictionary<int, List<ArrayPropertyInfo>>();
             var properties = typeof(T).GetProperties();
             foreach (var property in properties)
             {
@@ -207,7 +214,13 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
 
                 var targetType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
                 var converterType = property.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType ?? targetType.GetCustomAttribute<JsonConverterAttribute>()?.ConverterType;
-            attributes.Add(new ArrayPropertyInfo
+                if (!result.TryGetValue(att.Index, out var indexList))
+                {
+                    indexList = new List<ArrayPropertyInfo>();
+                    result[att.Index] = indexList;
+                }
+
+                indexList.Add(new ArrayPropertyInfo
                 {
                     ArrayProperty = att,
                     PropertyInfo = property,
@@ -217,7 +230,7 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
                 });
             }
 
-        return attributes;
+            return result;
         }
 
         private class ArrayPropertyInfo
@@ -227,6 +240,7 @@ public class ArrayConverter<T> : JsonConverter<T> where T : new()
             public JsonConverter? JsonConverter { get; set; }
             public bool DefaultDeserialization { get; set; }
             public Type TargetType { get; set; } = null!;
-        public JsonSerializerOptions? JsonSerializerOptions { get; set; }
+            public JsonSerializerOptions? JsonSerializerOptions { get; set; } = null;
+        }
     }
 }

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,3 +43,4 @@ public class BigDecimalConverter : JsonConverter<decimal>
             writer.WriteNumberValue(value);
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/BoolConverter.cs

@@ -1,11 +1,11 @@
+using Microsoft.Extensions.Logging;
 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>
@@ -20,15 +20,35 @@ public class BoolConverter : JsonConverterFactory
         /// <inheritdoc />
         public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
         {
-        return typeToConvert == typeof(bool) ? new BoolConverterInner<bool>() : new BoolConverterInner<bool?>();
+            return typeToConvert == typeof(bool) ? new BoolConverterInner() : new BoolConverterInnerNullable();
         }
 
-    private class BoolConverterInner<T> : JsonConverter<T>
+        private class BoolConverterInnerNullable : JsonConverter<bool?>
         {
-        public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            public override bool? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-            => (T)((object?)ReadBool(ref reader, typeToConvert, options) ?? default(T))!;
+                => ReadBool(ref reader, typeToConvert, options);
             
-        public static bool? ReadBool(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            public override void Write(Utf8JsonWriter writer, bool? value, JsonSerializerOptions options)
+            {
+                if (value is bool boolVal)
+                    writer.WriteBooleanValue(boolVal);
+                else
+                    writer.WriteNullValue();
+            }
+        }
+
+        private class BoolConverterInner : JsonConverter<bool>
+        {
+            public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+                => ReadBool(ref reader, typeToConvert, options) ?? false;
+
+            public override void Write(Utf8JsonWriter writer, bool value, JsonSerializerOptions options)
+            {
+                writer.WriteBooleanValue(value);
+            }
+        }
+
+        private static bool? ReadBool(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             if (reader.TokenType == JsonTokenType.True)
                 return true;
@@ -47,7 +67,7 @@ public class BoolConverter : JsonConverterFactory
             if (string.IsNullOrEmpty(value))
             {
                 if (typeToConvert == typeof(bool))
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received null bool value, but property type is not a nullable bool");
+                    LibraryHelpers.StaticLogger?.LogWarning("Received null or empty bool value, but property type is not a nullable bool. Resolver: {Resolver}", options.TypeInfoResolver?.GetType()?.Name);
                 return default;
             }
 
@@ -71,13 +91,5 @@ public class BoolConverter : JsonConverterFactory
             throw new SerializationException($"Can't convert bool value {value}");
         }
 
-        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
-        {
-            if (value is bool boolVal)
-                writer.WriteBooleanValue(boolVal);
-            else
-                writer.WriteNullValue();
     }
 }
-
-}

CryptoExchange.Net/Converters/SystemTextJson/CommaSplitEnumConverter.cs

@@ -1,13 +1,11 @@
-using System;
+using System;
-#if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
-#endif
 using System.Linq;
 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,3 +32,4 @@ public class CommaSplitEnumConverter<T> : JsonConverter<T[]> where T : struct, E
             writer.WriteStringValue(string.Join(",", value.Select(x => EnumConverter.GetString(x))));
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/DateTimeConverter.cs

@@ -1,12 +1,12 @@
+using Microsoft.Extensions.Logging;
 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>
@@ -14,8 +14,8 @@ public class DateTimeConverter : JsonConverterFactory
     {
         private static readonly DateTime _epoch = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
         private const long _ticksPerSecond = TimeSpan.TicksPerMillisecond * 1000;
-    private const double _ticksPerMicrosecond = TimeSpan.TicksPerMillisecond / 1000d;
+        private const decimal _ticksPerMicrosecond = TimeSpan.TicksPerMillisecond / 1000m;
-    private const double _ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000d / 1000;
+        private const decimal _ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000m / 1000;
 
         /// <inheritdoc />
         public override bool CanConvert(Type typeToConvert)
@@ -26,43 +26,73 @@ public class DateTimeConverter : JsonConverterFactory
         /// <inheritdoc />
         public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
         {
-        return typeToConvert == typeof(DateTime) ? new DateTimeConverterInner<DateTime>() : new DateTimeConverterInner<DateTime?>();
+            return typeToConvert == typeof(DateTime) ? new DateTimeConverterInner() : new NullableDateTimeConverterInner();
         }
 
-    private class DateTimeConverterInner<T> : JsonConverter<T>
+        private class NullableDateTimeConverterInner : JsonConverter<DateTime?>
         {
-        public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            public override DateTime? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-            => (T)((object?)ReadDateTime(ref reader, typeToConvert, options) ?? default(T))!;
+                => ReadDateTime(ref reader, typeToConvert, options);
+
+            public override void Write(Utf8JsonWriter writer, DateTime? value, JsonSerializerOptions options)
+            {
+                if (value == null)
+                {
+                    writer.WriteNullValue();
+                    return;
+                }
+
+                if (value.Value == default)
+                    writer.WriteStringValue(default(DateTime));
+                else
+                    writer.WriteNumberValue((long)Math.Round((value.Value - new DateTime(1970, 1, 1)).TotalMilliseconds));
+            }
+        }
+
+        private class DateTimeConverterInner : JsonConverter<DateTime>
+        {
+            public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+                => ReadDateTime(ref reader, typeToConvert, options) ?? default;            
+
+            public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
+            {
+                var dtValue = value;
+                if (dtValue == default)
+                    writer.WriteStringValue(default(DateTime));
+                else
+                    writer.WriteNumberValue((long)Math.Round((dtValue - new DateTime(1970, 1, 1)).TotalMilliseconds));
+            }
+        }
 
         private static DateTime? ReadDateTime(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             if (reader.TokenType == JsonTokenType.Null)
             {
                 if (typeToConvert == typeof(DateTime))
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | DateTime value of null, but property is not nullable");
+                    LibraryHelpers.StaticLogger?.LogWarning("DateTime value of null, but property is not nullable. Resolver: {Resolver}", options.TypeInfoResolver?.GetType()?.Name);
                 return default;
             }
 
             if (reader.TokenType is JsonTokenType.Number)
             {
-                var longValue = reader.GetDouble();
+                var decValue = reader.GetDecimal();
-                if (longValue == 0 || longValue < 0)
+                if (decValue == 0 || decValue < 0)
                     return default;
 
-                return ParseFromDouble(longValue);
+                return ParseFromDecimal(decValue);
             }
             else if (reader.TokenType is JsonTokenType.String)
             {
                 var stringValue = reader.GetString();
                 if (string.IsNullOrWhiteSpace(stringValue)
-                    || stringValue == "-1"
+                    || stringValue!.Equals("-1", StringComparison.Ordinal)
-                    || stringValue == "0001-01-01T00:00:00Z"
+                    || stringValue!.Equals("0001-01-01T00:00:00Z", StringComparison.OrdinalIgnoreCase)
-                    || double.TryParse(stringValue, out var doubleVal) && doubleVal == 0)
+                    || decimal.TryParse(stringValue, out var decVal) && decVal == 0)
                 {
                     return default;
                 }
 
-                return ParseFromString(stringValue!);
+                return ParseFromString(stringValue!, options.TypeInfoResolver?.GetType()?.Name);
             }
             else
             {
@@ -70,48 +100,33 @@ public class DateTimeConverter : JsonConverterFactory
             }
         }
 
-        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+        /// <summary>
-        {
+        /// Parse a double value to datetime
-            if (value == null)
+        /// </summary>
-            {
+        public static DateTime ParseFromDouble(double value)
-                writer.WriteNullValue();
+            => ParseFromDecimal((decimal)value);
-            }
-            else
-            {
-                var dtValue = (DateTime)(object)value;
-                if (dtValue == default)
-                    writer.WriteStringValue(default(DateTime));
-                else
-                    writer.WriteNumberValue((long)Math.Round((dtValue - new DateTime(1970, 1, 1)).TotalMilliseconds));
-            }
-        }
-    }
 
         /// <summary>
-    /// Parse a long value to datetime
+        /// Parse a decimal value to datetime
         /// </summary>
-    /// <param name="longValue"></param>
+        public static DateTime ParseFromDecimal(decimal value)
-    /// <returns></returns>
-    public static DateTime ParseFromDouble(double longValue)
         {
-        if (longValue < 19999999999)
+            if (value < 19999999999)
-            return ConvertFromSeconds(longValue);
+                return ConvertFromSeconds(value);
-        if (longValue < 19999999999999)
+            if (value < 19999999999999)
-            return ConvertFromMilliseconds(longValue);
+                return ConvertFromMilliseconds(value);
-        if (longValue < 19999999999999999)
+            if (value < 19999999999999999)
-            return ConvertFromMicroseconds(longValue);
+                return ConvertFromMicroseconds(value);
 
-        return ConvertFromNanoseconds(longValue);
+            return ConvertFromNanoseconds(value);
         }
 
         /// <summary>
         /// Parse a string value to datetime
         /// </summary>
-    /// <param name="stringValue"></param>
+        public static DateTime ParseFromString(string stringValue, string? resolverName)
-    /// <returns></returns>
-    public static DateTime ParseFromString(string stringValue)
         {
-        if (stringValue!.Length == 12 && stringValue.StartsWith("202"))
+            if (stringValue!.Length == 12 && stringValue.StartsWith("202", StringComparison.OrdinalIgnoreCase))
             {
                 // Parse 202303261200 format
                 if (!int.TryParse(stringValue.Substring(0, 4), out var year)
@@ -120,7 +135,7 @@ public class DateTimeConverter : JsonConverterFactory
                     || !int.TryParse(stringValue.Substring(8, 2), out var hour)
                     || !int.TryParse(stringValue.Substring(10, 2), out var minute))
                 {
-                Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                     return default;
                 }
                 return new DateTime(year, month, day, hour, minute, 0, DateTimeKind.Utc);
@@ -133,7 +148,7 @@ public class DateTimeConverter : JsonConverterFactory
                     || !int.TryParse(stringValue.Substring(4, 2), out var month)
                     || !int.TryParse(stringValue.Substring(6, 2), out var day))
                 {
-                Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                     return default;
                 }
                 return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
@@ -146,25 +161,25 @@ public class DateTimeConverter : JsonConverterFactory
                     || !int.TryParse(stringValue.Substring(2, 2), out var month)
                     || !int.TryParse(stringValue.Substring(4, 2), out var day))
                 {
-                Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                     return default;
                 }
                 return new DateTime(year + 2000, month, day, 0, 0, 0, DateTimeKind.Utc);
             }
 
-        if (double.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
+            if (decimal.TryParse(stringValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var decimalValue))
             {
                 // Parse 1637745563.000 format
-            if (doubleValue <= 0)
+                if (decimalValue <= 0)
                     return default;
-            if (doubleValue < 19999999999)
+                if (decimalValue < 19999999999)
-                return ConvertFromSeconds(doubleValue);
+                    return ConvertFromSeconds(decimalValue);
-            if (doubleValue < 19999999999999)
+                if (decimalValue < 19999999999999)
-                return ConvertFromMilliseconds((long)doubleValue);
+                    return ConvertFromMilliseconds(decimalValue);
-            if (doubleValue < 19999999999999999)
+                if (decimalValue < 19999999999999999)
-                return ConvertFromMicroseconds((long)doubleValue);
+                    return ConvertFromMicroseconds(decimalValue);
 
-            return ConvertFromNanoseconds((long)doubleValue);
+                return ConvertFromNanoseconds(decimalValue);
             }
 
             if (stringValue.Length == 10)
@@ -175,7 +190,7 @@ public class DateTimeConverter : JsonConverterFactory
                     || !int.TryParse(values[1], out var month)
                     || !int.TryParse(values[2], out var day))
                 {
-                Trace.WriteLine("{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Unknown DateTime format: " + stringValue);
+                    LibraryHelpers.StaticLogger?.LogWarning("Unknown DateTime format: {Value}. Resolver: {Resolver}", stringValue, resolverName);
                     return default;
                 }
 
@@ -188,54 +203,71 @@ public class DateTimeConverter : JsonConverterFactory
         /// <summary>
         /// Convert a seconds since epoch (01-01-1970) value to DateTime
         /// </summary>
-    /// <param name="seconds"></param>
+        public static DateTime ConvertFromSeconds(decimal seconds) => _epoch.AddTicks((long)Math.Round(seconds * _ticksPerSecond));
-    /// <returns></returns>
-    public static DateTime ConvertFromSeconds(double seconds) => _epoch.AddTicks((long)Math.Round(seconds * _ticksPerSecond));
-    /// <summary>
-    /// Convert a milliseconds since epoch (01-01-1970) value to DateTime
-    /// </summary>
-    /// <param name="milliseconds"></param>
-    /// <returns></returns>
-    public static DateTime ConvertFromMilliseconds(double milliseconds) => _epoch.AddTicks((long)Math.Round(milliseconds * TimeSpan.TicksPerMillisecond));
-    /// <summary>
-    /// Convert a microseconds since epoch (01-01-1970) value to DateTime
-    /// </summary>
-    /// <param name="microseconds"></param>
-    /// <returns></returns>
-    public static DateTime ConvertFromMicroseconds(double microseconds) => _epoch.AddTicks((long)Math.Round(microseconds * _ticksPerMicrosecond));
         /// <summary>
         /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
         /// </summary>
-    /// <param name="nanoseconds"></param>
+        public static DateTime ConvertFromSeconds(double seconds) => ConvertFromSeconds((decimal)seconds);
-    /// <returns></returns>
+        /// <summary>
-    public static DateTime ConvertFromNanoseconds(double nanoseconds) => _epoch.AddTicks((long)Math.Round(nanoseconds * _ticksPerNanosecond));
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromSeconds(long seconds) => ConvertFromSeconds((decimal)seconds);
+        /// <summary>
+        /// Convert a milliseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMilliseconds(decimal milliseconds) => _epoch.AddTicks((long)Math.Round(milliseconds * TimeSpan.TicksPerMillisecond));
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMilliseconds(double milliseconds) => ConvertFromMilliseconds((decimal)milliseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMilliseconds(long milliseconds) => ConvertFromMilliseconds((decimal)milliseconds);
+        /// <summary>
+        /// Convert a microseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMicroseconds(decimal microseconds) => _epoch.AddTicks((long)Math.Round(microseconds * _ticksPerMicrosecond));
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMicroseconds(double microseconds) => ConvertFromMicroseconds((decimal)microseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromMicroseconds(long microseconds) => ConvertFromMicroseconds((decimal)microseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromNanoseconds(decimal nanoseconds) => _epoch.AddTicks((long)Math.Round(nanoseconds * _ticksPerNanosecond));
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromNanoseconds(double nanoseconds) => ConvertFromNanoseconds((decimal)nanoseconds);
+        /// <summary>
+        /// Convert a nanoseconds since epoch (01-01-1970) value to DateTime
+        /// </summary>
+        public static DateTime ConvertFromNanoseconds(long nanoseconds) => ConvertFromNanoseconds((decimal)nanoseconds);
 
         /// <summary>
         /// Convert a DateTime value to seconds since epoch (01-01-1970) value
         /// </summary>
-    /// <param name="time"></param>
-    /// <returns></returns>
         [return: NotNullIfNotNull("time")]
         public static long? ConvertToSeconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).TotalSeconds);
         /// <summary>
         /// Convert a DateTime value to milliseconds since epoch (01-01-1970) value
         /// </summary>
-    /// <param name="time"></param>
-    /// <returns></returns>
         [return: NotNullIfNotNull("time")]
         public static long? ConvertToMilliseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).TotalMilliseconds);
         /// <summary>
         /// Convert a DateTime value to microseconds since epoch (01-01-1970) value
         /// </summary>
-    /// <param name="time"></param>
-    /// <returns></returns>
         [return: NotNullIfNotNull("time")]
         public static long? ConvertToMicroseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).Ticks / _ticksPerMicrosecond);
         /// <summary>
         /// Convert a DateTime value to nanoseconds since epoch (01-01-1970) value
         /// </summary>
-    /// <param name="time"></param>
-    /// <returns></returns>
         [return: NotNullIfNotNull("time")]
         public static long? ConvertToNanoseconds(DateTime? time) => time == null ? null : (long)Math.Round((time.Value - _epoch).Ticks / _ticksPerNanosecond);
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/DecimalConverter.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>
     /// Decimal converter
     /// </summary>
@@ -41,3 +41,4 @@ public class DecimalConverter : JsonConverter<decimal?>
                 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,3 +20,4 @@ public class DecimalStringWriterConverter : JsonConverter<decimal>
         public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
             => writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture) ?? null);
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/EnumConverter.cs

@@ -1,16 +1,19 @@
-using CryptoExchange.Net.Attributes;
+using CryptoExchange.Net.Attributes;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Concurrent;
+#if NET8_0_OR_GREATER
+using System.Collections.Frozen;
+#endif
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
 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 +67,26 @@ public class EnumConverter<T>
 #endif
          : JsonConverter<T>, INullableConverterFactory where T : struct, Enum
     {
-    private static List<KeyValuePair<T, string>>? _mapping;
+        class EnumMapping
-    private NullableEnumConverter? _nullableEnumConverter;
+        {
+            public T Value { get; set; }
+            public string StringValue { get; set; }
+
+            public EnumMapping(T value, string stringValue)
+            {
+                Value = value;
+                StringValue = stringValue;
+            }
+        }
+
+#if NET8_0_OR_GREATER
+        private static FrozenSet<EnumMapping>? _mappingToEnum = null;
+        private static FrozenDictionary<T, string>? _mappingToString = null;
+#else
+        private static List<EnumMapping>? _mappingToEnum = null;
+        private static Dictionary<T, string>? _mappingToString = null;
+#endif
+        private NullableEnumConverter? _nullableEnumConverter = null;
 
         private static ConcurrentBag<string> _unknownValuesWarned = new ConcurrentBag<string>();
 
@@ -79,7 +100,7 @@ public class EnumConverter<T>
             }
             public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
             {
-            return EnumConverter<T>.ReadNullable(ref reader, typeToConvert, options, out var isEmptyString, out var warn);
+                return _enumConverter.ReadNullable(ref reader, typeToConvert, options, out var isEmptyString);
             }
 
             public override void Write(Utf8JsonWriter writer, T? value, JsonSerializerOptions options)
@@ -98,20 +119,13 @@ public class EnumConverter<T>
         /// <inheritdoc />
         public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-        var t = ReadNullable(ref reader, typeToConvert, options, out var isEmptyString, out var warn);
+            var t = ReadNullable(ref reader, typeToConvert, options, out var isEmptyString);
             if (t == null)
             {
-            if (warn)
+                if (isEmptyString && !_unknownValuesWarned.Contains(null))
-            {
-                if (isEmptyString)
                 {
                     // We received an empty string and have no mapping for it, and the property isn't nullable
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received empty string as enum value, but property type is not a nullable enum. EnumType: {typeof(T).Name}. If you think {typeof(T).Name} should be nullable please open an issue on the Github repo");
+                    LibraryHelpers.StaticLogger?.LogWarning($"Received null or empty enum value, but property type is not a nullable enum. EnumType: {typeof(T).FullName}. If you think {typeof(T).FullName} should be nullable please open an issue on the Github repo");
-                }
-                else
-                {
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Received null enum value, but property type is not a nullable enum. EnumType: {typeof(T).Name}. If you think {typeof(T).Name} should be nullable please open an issue on the Github repo");
-                }
                 }
 
                 return new T(); // return default value
@@ -122,13 +136,12 @@ public class EnumConverter<T>
             }
         }
 
-    private static T? ReadNullable(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, out bool isEmptyString, out bool warn)
+        private T? ReadNullable(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, out bool isEmptyString)
         {
             isEmptyString = false;
-        warn = false;
             var enumType = typeof(T);
-        if (_mapping == null)
+            if (_mappingToEnum == null)
-            _mapping = AddMapping();
+                CreateMapping();
 
             var stringValue = reader.TokenType switch
             {
@@ -140,10 +153,10 @@ public class EnumConverter<T>
                 _ => throw new Exception("Invalid token type for enum deserialization: " + reader.TokenType)
             };
 
-        if (string.IsNullOrEmpty(stringValue))
+            if (stringValue is null)
                 return null;
 
-        if (!GetValue(enumType, stringValue!, out var result))
+            if (!GetValue(enumType, stringValue, out var result))
             {
                 if (string.IsNullOrWhiteSpace(stringValue))
                 {
@@ -154,9 +167,8 @@ public class EnumConverter<T>
                     // We received an enum value but weren't able to parse it.
                     if (!_unknownValuesWarned.Contains(stringValue))
                     {
-                    warn = true;
                         _unknownValuesWarned.Add(stringValue!);
-                    Trace.WriteLine($"{DateTime.Now:yyyy/MM/dd HH:mm:ss:fff} | Warning | Cannot map enum value. EnumType: {enumType.Name}, Value: {stringValue}, Known values: {string.Join(", ", _mapping.Select(m => m.Value))}. If you think {stringValue} should added please open an issue on the Github repo");
+                        LibraryHelpers.StaticLogger?.LogWarning($"Cannot map enum value. EnumType: {enumType.FullName}, Value: {stringValue}, Known values: {string.Join(", ", _mappingToEnum!.Select(m => m.Value))}. If you think {stringValue} should added please open an issue on the Github repo");
                     }
                 }
 
@@ -175,16 +187,35 @@ public class EnumConverter<T>
 
         private static bool GetValue(Type objectType, string value, out T? result)
         {
-        if (_mapping != null)
+            if (_mappingToEnum != null)
             {
-            // Check for exact match first, then if not found fallback to a case insensitive match 
+                EnumMapping? mapping = null;
-            var mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
+                // Try match on full equals
-            if (mapping.Equals(default(KeyValuePair<T, string>)))
+                foreach (var item in _mappingToEnum)
-                mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+                {
+                    if (item.StringValue.Equals(value, StringComparison.Ordinal))
+                    {
+                        mapping = item;
+                        break;
+                    }
+                }
 
-            if (!mapping.Equals(default(KeyValuePair<T, string>)))
+                // If not found, try matching ignoring case
+                if (mapping == null)
                 {
-                result = mapping.Key;
+                    foreach (var item in _mappingToEnum)
+                    {
+                        if (item.StringValue.Equals(value, StringComparison.OrdinalIgnoreCase))
+                        {
+                            mapping = item;
+                            break;
+                        }
+                    }
+                }
+
+                if (mapping != null)
+                {
+                    result = mapping.Value;
                     return true;
                 }
             }
@@ -204,6 +235,13 @@ public class EnumConverter<T>
                 return false;
             }
 
+            if (String.IsNullOrEmpty(value))
+            {
+                // An empty/null value will always fail when parsing, so just return here
+                result = default;
+                return false;
+            }
+
             try
             {
                 // If no explicit mapping is found try to parse string
@@ -217,9 +255,11 @@ public class EnumConverter<T>
             }
         }
 
-    private static List<KeyValuePair<T, string>> AddMapping()
+        private static void CreateMapping()
         {
-        var mapping = new List<KeyValuePair<T, string>>();
+            var mappingToEnum = new List<EnumMapping>();
+            var mappingToString = new Dictionary<T, string>();
+
             var enumType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
             var enumMembers = enumType.GetFields();
             foreach (var member in enumMembers)
@@ -228,12 +268,22 @@ public class EnumConverter<T>
                 foreach (MapAttribute attribute in maps)
                 {
                     foreach (var value in attribute.Values)
-                    mapping.Add(new KeyValuePair<T, string>((T)Enum.Parse(enumType, member.Name), value));
+                    {
+                        var enumVal = (T)Enum.Parse(enumType, member.Name);
+                        mappingToEnum.Add(new EnumMapping(enumVal, value));
+                        if (!mappingToString.ContainsKey(enumVal))
+                            mappingToString.Add(enumVal, value);
+                    }
                 }
             }
 
-        _mapping = mapping;
+#if NET8_0_OR_GREATER
-        return mapping;
+            _mappingToEnum = mappingToEnum.ToFrozenSet();
+            _mappingToString = mappingToString.ToFrozenDictionary();
+#else
+            _mappingToEnum = mappingToEnum;
+            _mappingToString = mappingToString;
+#endif
         }
 
         /// <summary>
@@ -244,10 +294,10 @@ public class EnumConverter<T>
         [return: NotNullIfNotNull("enumValue")]
         public static string? GetString(T? enumValue)
         {
-        if (_mapping == null)
+            if (_mappingToString == null)
-            _mapping = AddMapping();
+                CreateMapping();
 
-        return enumValue == null ? null : (_mapping.FirstOrDefault(v => v.Key.Equals(enumValue)).Value ?? enumValue.ToString());
+            return enumValue == null ? null : (_mappingToString!.TryGetValue(enumValue.Value, out var str) ? str : enumValue.ToString());
         }
 
         /// <summary>
@@ -258,15 +308,35 @@ public class EnumConverter<T>
         public static T? ParseString(string value)
         {
             var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
-        if (_mapping == null)
+            if (_mappingToEnum == null)
-            _mapping = AddMapping();
+                CreateMapping();
 
-        var mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCulture));
+            EnumMapping? mapping = null;
-        if (mapping.Equals(default(KeyValuePair<T, string>)))
+            // Try match on full equals
-            mapping = _mapping.FirstOrDefault(kv => kv.Value.Equals(value, StringComparison.InvariantCultureIgnoreCase));
+            foreach(var item in _mappingToEnum!)
+            {
+                if (item.StringValue.Equals(value, StringComparison.Ordinal))
+                {
+                    mapping = item;
+                    break;
+                }
+            }
 
-        if (!mapping.Equals(default(KeyValuePair<T, string>)))
+            // If not found, try matching ignoring case
-            return mapping.Key;
+            if (mapping == null)
+            {
+                foreach (var item in _mappingToEnum)
+                {
+                    if (item.StringValue.Equals(value, StringComparison.OrdinalIgnoreCase))
+                    {
+                        mapping = item;
+                        break;
+                    }
+                }
+            }
+
+            if (mapping != null)
+                return mapping.Value;
 
             try
             {
@@ -286,3 +356,4 @@ public class EnumConverter<T>
             return _nullableEnumConverter;
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/EnumIntWriterConverter.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>
     /// Converter for serializing enum values as int
     /// </summary>
@@ -19,3 +19,4 @@ public class EnumIntWriterConverter<T> : JsonConverter<T> where T: struct, Enum
         public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
             => writer.WriteNumberValue((int)(object)value);
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/INullableConverterFactory.cs

@@ -1,8 +1,9 @@
-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/IntBoolConverter.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Bool converter
+    /// </summary>
+    public class IntBoolConverter : JsonConverter<bool>
+    {
+        private readonly int _trueValue;
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="trueValue">The int value representing the true value</param>
+        public IntBoolConverter(int trueValue)
+        {
+            _trueValue = trueValue;
+        }
+
+        /// <inheritdoc />
+        public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType != JsonTokenType.Number)
+                return false;
+
+            return reader.GetDecimal() == _trueValue;              
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, bool value, JsonSerializerOptions options)
+        {
+            writer.WriteNumberValue(_trueValue);
+        }
+    }
+}

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,3 +37,4 @@ public class IntConverter : JsonConverter<int?>
                 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,3 +37,4 @@ public class LongConverter : JsonConverter<long?>
                 writer.WriteNumberValue(value.Value);
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/MessageHandlers/JsonRestMessageHandler.cs

@@ -0,0 +1,117 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
+{
+    /// <summary>
+    /// JSON REST message handler
+    /// </summary>
+    public abstract class JsonRestMessageHandler : IRestMessageHandler
+    {
+        private static MediaTypeWithQualityHeaderValue _acceptJsonContent = new MediaTypeWithQualityHeaderValue(Constants.JsonContentHeader);
+
+        /// <summary>
+        /// Empty rate limit error
+        /// </summary>
+        protected static readonly ServerRateLimitError _emptyRateLimitError = new ServerRateLimitError();
+
+        /// <inheritdoc />
+        public virtual bool RequiresSeekableStream => false;
+
+        /// <summary>
+        /// The serializer options to use
+        /// </summary>
+        public abstract JsonSerializerOptions Options { get; }
+
+        /// <inheritdoc />
+        public MediaTypeWithQualityHeaderValue AcceptHeader => _acceptJsonContent;
+
+        /// <inheritdoc />
+        public virtual ValueTask<ServerRateLimitError> ParseErrorRateLimitResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream)
+        {
+            // Handle retry after header
+            var retryAfterHeader = responseHeaders.SingleOrDefault(r => r.Key.Equals("Retry-After", StringComparison.InvariantCultureIgnoreCase));
+            if (retryAfterHeader.Value?.Any() != true)
+                return new ValueTask<ServerRateLimitError>(_emptyRateLimitError);
+
+            var value = retryAfterHeader.Value.First();
+            if (int.TryParse(value, out var seconds))
+                return new ValueTask<ServerRateLimitError>(new ServerRateLimitError() { RetryAfter = DateTime.UtcNow.AddSeconds(seconds) });
+
+            if (DateTime.TryParse(value, out var datetime))
+                return new ValueTask<ServerRateLimitError>(new ServerRateLimitError() { RetryAfter = datetime });
+
+            return new ValueTask<ServerRateLimitError>(_emptyRateLimitError);
+        }
+
+        /// <inheritdoc />
+        public abstract ValueTask<Error> ParseErrorResponse(
+            int httpStatusCode,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream);
+
+        /// <inheritdoc />
+        public virtual ValueTask<Error?> CheckForErrorResponse(
+            RequestDefinition request,
+            HttpResponseHeaders responseHeaders,
+            Stream responseStream) => new ValueTask<Error?>((Error?)null);
+
+        /// <summary>
+        /// Read the response into a JsonDocument object
+        /// </summary>
+        protected virtual async ValueTask<(Error?, JsonDocument?)> GetJsonDocument(Stream stream)
+        {
+            try
+            {
+                var document = await JsonDocument.ParseAsync(stream).ConfigureAwait(false);
+                return (null, document);
+            }
+            catch (Exception ex)
+            {
+                return (new ServerError(new ErrorInfo(ErrorType.DeserializationFailed, false, "Deserialization failed, invalid JSON"), ex), null);
+            }
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public async ValueTask<(T? Result, Error? Error)> TryDeserializeAsync<T>(Stream responseStream, CancellationToken cancellationToken)
+        {
+            try
+            {
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+                var result = await JsonSerializer.DeserializeAsync<T>(responseStream, Options)!.ConfigureAwait(false)!;
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+                return (result, null);
+            }            
+            catch (JsonException ex)
+            {
+                var info = $"Json deserialization failed: {ex.Message}, Path: {ex.Path}, LineNumber: {ex.LineNumber}, LinePosition: {ex.BytePositionInLine}";
+                return (default, new DeserializeError(info, ex));
+            }
+            catch (Exception ex)
+            {
+                return (default, new DeserializeError($"Json deserialization failed: {ex.Message}", ex));
+            }
+        }
+
+        /// <inheritdoc />
+        public virtual Error? CheckDeserializedResponse<T>(HttpResponseHeaders responseHeaders, T result) => null;
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/MessageHandlers/JsonSocketMessageHandler.cs

@@ -0,0 +1,348 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
+{
+    /// <summary>
+    /// JSON WebSocket message handler, sequentially read the JSON and looks for specific predefined fields to identify the message
+    /// </summary>
+    public abstract class JsonSocketMessageHandler : ISocketMessageHandler
+    {
+        /// <summary>
+        /// The serializer options to use
+        /// </summary>
+        public abstract JsonSerializerOptions Options { get; }
+
+        /// <summary>
+        /// Message evaluators
+        /// </summary>
+        protected abstract MessageTypeDefinition[] TypeEvaluators { get; }
+
+        private readonly SearchResult _searchResult = new();
+
+        private bool _hasArraySearches;
+        private bool _initialized;
+        private int _maxSearchDepth;
+        private MessageTypeDefinition? _topEvaluator;
+        private List<MessageEvalutorFieldReference>? _searchFields;
+        private Dictionary<Type, Func<object, string?>>? _baseTypeMapping;
+        private Dictionary<Type, Func<object, string?>>? _mapping;
+
+        /// <summary>
+        /// Add a mapping of a specific object of a type to a specific topic
+        /// </summary>
+        /// <typeparam name="T">Type to get topic for</typeparam>
+        /// <param name="mapping">The topic retrieve delegate</param>
+        protected void AddTopicMapping<T>(Func<T, string?> mapping)
+        {
+            _mapping ??= new Dictionary<Type, Func<object, string?>>();
+            _mapping.Add(typeof(T), x => mapping((T)x));
+        }
+
+        private void InitializeConverter()
+        {
+            if (_initialized)
+                return;
+
+            _maxSearchDepth = int.MinValue;
+            _searchFields = new List<MessageEvalutorFieldReference>();
+            foreach (var evaluator in TypeEvaluators)
+            {
+                _topEvaluator ??= evaluator;
+                foreach (var field in evaluator.Fields)
+                {
+                    var overlapping = _searchFields.Where(otherField =>
+                    {
+                        if (field is PropertyFieldReference propRef
+                            && otherField.Field is PropertyFieldReference otherPropRef)
+                        {
+                            return field.Depth == otherPropRef.Depth && propRef.PropertyName.SequenceEqual(otherPropRef.PropertyName);
+                        }
+                        else if (field is ArrayFieldReference arrayRef
+                            && otherField.Field is ArrayFieldReference otherArrayPropRef)
+                        {
+                            return field.Depth == otherArrayPropRef.Depth && arrayRef.ArrayIndex == otherArrayPropRef.ArrayIndex;
+                        }
+
+                        return false;
+                    }).ToList();
+
+                    if (overlapping.Any())
+                    {
+                        foreach (var overlap in overlapping)
+                            overlap.OverlappingField = true;
+                    }
+
+                    List<MessageEvalutorFieldReference>? existingSameSearchField = new();
+                    if (field is ArrayFieldReference arrayField)
+                    {
+                        _hasArraySearches = true;
+                        existingSameSearchField = _searchFields.Where(x =>
+                            x.Field is ArrayFieldReference arrayFieldRef
+                            && arrayFieldRef.ArrayIndex == arrayField.ArrayIndex
+                            && arrayFieldRef.Depth == arrayField.Depth
+                            && arrayFieldRef.Constraint == null && arrayField.Constraint == null).ToList();
+                    }
+                    else if (field is PropertyFieldReference propField)
+                    {
+                        existingSameSearchField = _searchFields.Where(x =>
+                            x.Field is PropertyFieldReference propFieldRef
+                            && propFieldRef.PropertyName.SequenceEqual(propField.PropertyName)
+                            && propFieldRef.Depth == propField.Depth
+                            && propFieldRef.Constraint == null && propFieldRef.Constraint == null).ToList();
+                    }
+
+                    foreach(var sameSearchField in existingSameSearchField)
+                    {
+                        if (sameSearchField.SkipReading == true
+                            && (evaluator.TypeIdentifierCallback != null || field.Constraint != null))
+                        {
+                            sameSearchField.SkipReading = false;
+                        }
+
+                        if (evaluator.ForceIfFound)
+                        {
+                            if (evaluator.Fields.Length > 1 || sameSearchField.ForceEvaluator != null)
+                                throw new Exception("Invalid config");
+
+                            //sameSearchField.ForceEvaluator = evaluator;
+                        }
+                    }
+
+                    _searchFields.Add(new MessageEvalutorFieldReference(field)
+                    {
+                        SkipReading = evaluator.TypeIdentifierCallback == null && field.Constraint == null,
+                        ForceEvaluator = !existingSameSearchField.Any() ? evaluator.ForceIfFound ? evaluator : null : null,
+                        OverlappingField = overlapping.Any()
+                    });
+
+                    if (field.Depth > _maxSearchDepth)
+                        _maxSearchDepth = field.Depth;
+                }
+            }
+
+            _initialized = true;
+        }
+
+        /// <inheritdoc />
+        public virtual string? GetTopicFilter(object deserializedObject)
+        {
+            if (_mapping == null)
+                return null;
+
+            // Cache the found type for future 
+            var currentType = deserializedObject.GetType();
+            if (_baseTypeMapping != null)
+            {
+                if (_baseTypeMapping.TryGetValue(currentType, out var typeMapping))
+                    return typeMapping(deserializedObject);
+            }
+
+            var mappedBase = false;
+            while (currentType != null)
+            {
+                if (_mapping.TryGetValue(currentType, out var mapping))
+                {
+                    if (mappedBase) 
+                    {
+                        _baseTypeMapping ??= new Dictionary<Type, Func<object, string?>>();
+                        _baseTypeMapping.Add(deserializedObject.GetType(), mapping);
+                    }
+
+                    return mapping(deserializedObject);
+                }
+
+                mappedBase = true;
+                currentType = currentType.BaseType;
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc />
+        public virtual string? GetTypeIdentifier(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType)
+        {
+            InitializeConverter();
+
+            int? arrayIndex = null;
+
+            _searchResult.Clear();
+            var reader = new Utf8JsonReader(data);
+            while (reader.Read())
+            {
+                if ((reader.TokenType == JsonTokenType.StartArray
+                    || reader.TokenType == JsonTokenType.StartObject)
+                    && reader.CurrentDepth == _maxSearchDepth)
+                {
+                    // There is no field we need to search for on a depth deeper than this, skip
+                    reader.Skip();
+                    continue;
+                }
+
+                if (reader.TokenType == JsonTokenType.StartArray)
+                    arrayIndex = -1;
+                else if (reader.TokenType == JsonTokenType.EndArray)
+                    arrayIndex = null;
+                else if (arrayIndex != null)
+                    arrayIndex++;
+
+                if (reader.TokenType == JsonTokenType.PropertyName
+                    || arrayIndex != null && _hasArraySearches)
+                {
+                    bool written = false;
+
+                    string? value = null;
+                    byte[]? propName = null;
+                    foreach (var field in _searchFields!)
+                    {
+                        if (field.Field.Depth != reader.CurrentDepth)
+                            continue;
+
+                        bool readArrayValues = false;
+                        if (field.Field is PropertyFieldReference propFieldRef)
+                        {
+                            if (propName == null)
+                            {
+                                if (reader.TokenType != JsonTokenType.PropertyName)
+                                    continue;
+
+                                if (!reader.ValueTextEquals(propFieldRef.PropertyName))
+                                    continue;
+
+                                propName = propFieldRef.PropertyName;
+                                readArrayValues = propFieldRef.ArrayValues;
+                                reader.Read();
+                            }
+                            else if (!propFieldRef.PropertyName.SequenceEqual(propName))
+                            {
+                                continue;
+                            }
+                        }
+                        else if (field.Field is ArrayFieldReference arrayFieldRef)
+                        {
+                            if (propName != null)
+                                continue;
+
+                            if (reader.TokenType == JsonTokenType.PropertyName)
+                                continue;
+
+                            if (arrayFieldRef.ArrayIndex != arrayIndex)
+                                continue;
+                        }
+
+                        if (!field.SkipReading)
+                        {
+                            if (value == null)
+                            {
+                                if (readArrayValues)
+                                {
+                                    if (reader.TokenType != JsonTokenType.StartArray)
+                                        // error
+                                        return null;
+
+                                    var sb = new StringBuilder();
+                                    reader.Read();// Read start array
+                                    bool first = true;
+                                    while(reader.TokenType != JsonTokenType.EndArray)
+                                    {
+                                        if (!first)
+                                            sb.Append(",");
+
+                                        first = false;
+                                        sb.Append(reader.GetString());
+                                        reader.Read();
+                                    }
+
+                                    value = first ? null : sb.ToString();
+                                }
+                                else
+                                {
+                                    switch (reader.TokenType)
+                                    {
+                                        case JsonTokenType.Number:
+                                            value = reader.GetDecimal().ToString();
+                                            break;
+                                        case JsonTokenType.String:
+                                            value = reader.GetString()!;
+                                            break;
+                                        case JsonTokenType.True:
+                                        case JsonTokenType.False:
+                                            value = reader.GetBoolean().ToString()!;
+                                            break;
+                                        case JsonTokenType.Null:
+                                            value = null;
+                                            break;
+                                        case JsonTokenType.StartObject:
+                                        case JsonTokenType.StartArray:
+                                            value = null;
+                                            break;
+                                        default:
+                                            continue;
+                                    }
+                                }
+                            }
+
+                            if (field.Field.Constraint != null
+                                && !field.Field.Constraint(value))
+                            {
+                                continue;
+                            }
+                        }
+
+                        _searchResult.Write(field.Field, value);
+
+                        if (field.ForceEvaluator != null)
+                        {
+                            if (field.ForceEvaluator.StaticIdentifier != null)
+                                return field.ForceEvaluator.StaticIdentifier;
+
+                            // Force the immediate return upon encountering this field
+                            return field.ForceEvaluator.GetMessageType(_searchResult);
+                        }
+
+                        written = true;
+                        if (!field.OverlappingField)
+                            break;
+                    }
+
+                    if (!written)
+                        continue;
+
+                    if (_topEvaluator!.Satisfied(_searchResult))
+                        return _topEvaluator.GetMessageType(_searchResult);
+
+                    if (_searchFields.Count == _searchResult.Count)
+                        break;
+                }
+            }
+
+            foreach (var evaluator in TypeEvaluators)
+            {
+                if (evaluator.Satisfied(_searchResult))
+                    return evaluator.GetMessageType(_searchResult);
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc />
+#if NET5_0_OR_GREATER
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL3050:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "JsonSerializerOptions provided here has TypeInfoResolver set")]
+#endif
+        public virtual object Deserialize(ReadOnlySpan<byte> data, Type type)
+        {
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            return JsonSerializer.Deserialize(data, type, Options)!;
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/MessageHandlers/JsonSocketPreloadMessageHandler.cs

@@ -0,0 +1,63 @@
+using CryptoExchange.Net.Converters.MessageParsing.DynamicConverters;
+using System;
+using System.Net.WebSockets;
+using System.Text.Json;
+
+namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
+{
+    /// <summary>
+    /// JSON WebSocket message handler, reads the json data info a JsonDocument after which the data can be inspected to identify the message
+    /// </summary>
+    public abstract class JsonSocketPreloadMessageHandler : ISocketMessageHandler
+    {
+        /// <summary>
+        /// The serializer options to use
+        /// </summary>
+        public abstract JsonSerializerOptions Options { get; }
+
+        /// <inheritdoc />
+        public virtual string? GetTypeIdentifier(ReadOnlySpan<byte> data, WebSocketMessageType? webSocketMessageType)
+        {
+            var reader = new Utf8JsonReader(data);
+            var jsonDocument = JsonDocument.ParseValue(ref reader);
+
+            return GetTypeIdentifier(jsonDocument);
+        }
+
+        /// <summary>
+        /// Get the message identifier for this document
+        /// </summary>
+        protected abstract string? GetTypeIdentifier(JsonDocument document);
+
+        /// <summary>
+        /// Get optional topic filter, for example a symbol name
+        /// </summary>
+        public virtual string? GetTopicFilter(object deserializedObject) => null;
+
+        /// <inheritdoc />
+        public virtual object Deserialize(ReadOnlySpan<byte> data, Type type)
+        {
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            return JsonSerializer.Deserialize(data, type, Options)!;
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+        }
+
+        /// <summary>
+        /// Get the string value for a path, or an emtpy string if not found
+        /// </summary>
+        protected string StringOrEmpty(JsonDocument document, string path)
+        {
+            if (!document.RootElement.TryGetProperty(path, out var element))
+                return string.Empty;
+
+            if (element.ValueKind == JsonValueKind.String)
+                return element.GetString() ?? string.Empty;
+            else if (element.ValueKind == JsonValueKind.Number)
+                return element.GetDecimal().ToString();
+
+            return string.Empty;
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/NullableEnumConverterFactory.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 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;
@@ -38,3 +38,4 @@ internal class NullableEnumConverterFactory : JsonConverterFactory
             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,3 +39,4 @@ public class NumberStringConverter : JsonConverter<string?>
             writer.WriteStringValue(value);
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/ObjectOrArrayConverter.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+#pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
+    /// <summary>
+    /// Converter for parsing object or array responses
+    /// </summary>
+    public class ObjectOrArrayConverter : JsonConverterFactory
+    {
+        /// <inheritdoc />
+        public override bool CanConvert(Type typeToConvert) => true;
+        /// <inheritdoc />
+        public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+        {
+            var type = typeof(InternalObjectOrArrayConverter<>).MakeGenericType(typeToConvert);
+            return (JsonConverter)Activator.CreateInstance(type)!;
+        }
+
+        private class InternalObjectOrArrayConverter<T> : JsonConverter<T>
+        {
+            public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                if (reader.TokenType == JsonTokenType.StartObject && !typeToConvert.IsArray)
+                {
+                    // Object to object
+                    return JsonDocument.ParseValue(ref reader).Deserialize<T>(options);
+                }
+                else if (reader.TokenType == JsonTokenType.StartArray && typeToConvert.IsArray)
+                {
+                    // Array to array
+                    return JsonDocument.ParseValue(ref reader).Deserialize<T>(options);
+                }
+                else if (reader.TokenType == JsonTokenType.StartArray)
+                {
+                    // Array to object
+                    JsonDocument.ParseValue(ref reader).Deserialize<T[]>(options);
+                    return default;
+                }
+                else
+                {
+                    // Object to array
+                    JsonDocument.ParseValue(ref reader);
+                    return default;
+                }
+            }
+
+            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+            {
+                JsonSerializer.Serialize(writer, value, options);
+            }
+        }
+    }
+}

CryptoExchange.Net/Converters/SystemTextJson/ObjectStringConverter.cs

@@ -1,12 +1,10 @@
-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>
@@ -26,7 +24,7 @@ public class ObjectStringConverter<T> : JsonConverter<T>
             if (string.IsNullOrEmpty(value))
                 return default;
 
-        return JsonDocument.Parse(value!).Deserialize<T>(options);
+            return (T?)JsonDocument.Parse(value!).Deserialize(typeof(T), options);
         }
 
         /// <inheritdoc />
@@ -42,3 +40,4 @@ public class ObjectStringConverter<T> : JsonConverter<T>
             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 @@ public abstract class ReplaceConverter : JsonConverter<string>
         {
             _replacementSets = replaceSets.Select(x =>
             {
-            var split = x.Split(["->"], StringSplitOptions.None);
+                var split = x.Split(new string[] { "->" }, StringSplitOptions.None);
                 if (split.Length != 2)
                     throw new ArgumentException("Invalid replacement config");
                 return (split[0], split[1]);
@@ -38,3 +38,4 @@ public abstract class ReplaceConverter : JsonConverter<string>
         /// <inheritdoc />
         public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) => writer.WriteStringValue(value);
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/SerializationModel.cs

@@ -1,7 +1,7 @@
-using System;
+using System;
-
-namespace CryptoExchange.Net.Converters.SystemTextJson;
 
+namespace CryptoExchange.Net.Converters.SystemTextJson
+{
     /// <summary>
     /// Attribute to mark a model as json serializable. Used for AOT compilation.
     /// </summary>
@@ -18,3 +18,4 @@ public class SerializationModelAttribute : Attribute
         /// <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,3 +44,4 @@ public static class SerializerOptions
             return options;
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/SharedQuantityConverter.cs

@@ -1,10 +1,10 @@
-using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.SharedApis;
 using System;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson;
+namespace CryptoExchange.Net.Converters.SystemTextJson
-
+{
     internal class SharedQuantityConverter : SharedQuantityReferenceConverter<SharedQuantity> { }
     internal class SharedOrderQuantityConverter : SharedQuantityReferenceConverter<SharedOrderQuantity> { }
 
@@ -55,3 +55,4 @@ internal class SharedQuantityReferenceConverter<T> : JsonConverter<T> where T: S
             writer.WriteEndArray();
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/SharedSymbolConverter.cs

@@ -1,10 +1,10 @@
-using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.SharedApis;
 using System;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace CryptoExchange.Net.Converters.SystemTextJson;
+namespace CryptoExchange.Net.Converters.SystemTextJson
-
+{
     internal class SharedSymbolConverter : JsonConverter<SharedSymbol>
     {
         public override SharedSymbol? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
@@ -41,3 +41,4 @@ internal class SharedSymbolConverter : JsonConverter<SharedSymbol>
             writer.WriteEndArray();
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageAccessor.cs

@@ -1,17 +1,15 @@
-using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Converters.MessageParsing;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using System;
-#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>
@@ -241,9 +239,7 @@ public abstract class SystemTextJsonMessageAccessor : IMessageAccessor
     /// <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;
 
@@ -374,3 +370,4 @@ public class SystemTextJsonByteMessageAccessor : SystemTextJsonMessageAccessor,
             _document = null;
         }
     }
+}

CryptoExchange.Net/Converters/SystemTextJson/SystemTextJsonMessageSerializer.cs

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

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net8.0;net9.0;net10.0</TargetFrameworks>
   </PropertyGroup>
   <PropertyGroup>
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
     <Description>CryptoExchange.Net is a base library which is used to implement different cryptocurrency (exchange) API's. It provides a standardized way of implementing different API's, which results in a very similar experience for users of the API implementations.</Description>
-    <PackageVersion>9.6.0</PackageVersion>
+    <PackageVersion>10.2.0</PackageVersion>
-    <AssemblyVersion>9.6.0</AssemblyVersion>
+    <AssemblyVersion>10.2.0</AssemblyVersion>
-    <FileVersion>9.6.0</FileVersion>
+    <FileVersion>10.2.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;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>
@@ -20,11 +20,10 @@
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageReleaseNotes>https://github.com/JKorf/CryptoExchange.Net?tab=readme-ov-file#release-notes</PackageReleaseNotes>
     <Nullable>enable</Nullable>
-    <LangVersion>12.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
   <ItemGroup>
-    <None Include="C:\Projects\CryptoExchange.Net\CryptoExchange.Net\.editorconfig" />
     <None Include="Icon\icon.png" Pack="true" PackagePath="\" />
     <None Include="..\README.md" Pack="true" PackagePath="\" />
   </ItemGroup>
@@ -41,31 +40,24 @@
   <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>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="9.0.0">
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="10.0.101">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.6" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.1" />
-    <PackageReference Include="System.Text.Json" Version="9.0.6" />
+    <PackageReference Include="System.Text.Json" Version="10.0.1" />
+    <PackageReference Include="NSec.Cryptography" Version="25.4.0" Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))" />
   </ItemGroup>
   <ItemGroup Label="Transitive Client Packages">
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.6" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.1" />
-    <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.6" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.1" />
-  </ItemGroup>
+    <PackageReference Include="System.Threading.Channels" Version="10.0.1" />
-  <ItemGroup>
-    <EditorConfigFiles Remove="C:\Projects\CryptoExchange.Net\CryptoExchange.Net\.editorconfig" />
   </ItemGroup>
 </Project>

CryptoExchange.Net/Exceptions/CeDeserializationException.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace CryptoExchange.Net.Exceptions
+{
+    /// <summary>
+    /// Exception during deserialization
+    /// </summary>
+    public class CeDeserializationException : Exception
+    {
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CeDeserializationException(string message) : base(message)
+        {
+        }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public CeDeserializationException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

CryptoExchange.Net/ExchangeHelpers.cs

@@ -1,17 +1,16 @@
-using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Runtime.CompilerServices;
-#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>
@@ -91,8 +90,6 @@ public static class ExchangeHelpers
                 else value += (step.Value - offset);
             }
                 
-        value = RoundDown(value, 8);
-            
             return value.Normalize();
         }
 
@@ -245,8 +242,7 @@ public static class ExchangeHelpers
         /// <summary>
         /// Generate a long value
         /// </summary>
-    /// <param name="maxLength">Max character length</param>
+        /// <param name="maxLength">Max number of digits</param>
-    /// <returns></returns>
         public static long RandomLong(int maxLength)
         {
 #if NETSTANDARD2_1_OR_GREATER || NET9_0_OR_GREATER
@@ -262,6 +258,25 @@ public static class ExchangeHelpers
                 return value;
         }
 
+        /// <summary>
+        /// Generate a long value between two values
+        /// </summary>
+        /// <param name="minValue">Min value</param>
+        /// <param name="maxValue">Max value</param>
+        /// <returns></returns>
+        public static long RandomLong(long minValue, long maxValue)
+        {
+#if NET8_0_OR_GREATER
+            var buf = RandomNumberGenerator.GetBytes(8);
+#else
+            byte[] buf = new byte[8];
+            var random = new Random();
+            random.NextBytes(buf);
+#endif
+            long longRand = BitConverter.ToInt64(buf, 0);
+            return (Math.Abs(longRand % (maxValue - minValue)) + minValue);
+        }
+
         /// <summary>
         /// Generate a random string of specified length
         /// </summary>
@@ -289,16 +304,16 @@ public static class ExchangeHelpers
         /// <summary>
         /// Execute multiple requests to retrieve multiple pages of the result set
         /// </summary>
-    /// <typeparam name="TResult">Type of the client</typeparam>
+        /// <typeparam name="T">Type of the client</typeparam>
-    /// <typeparam name="TRequest">Type of the request</typeparam>
+        /// <typeparam name="U">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<TResult[]>> ExecutePages<TResult, TRequest>(Func<TRequest, INextPageToken?, CancellationToken, Task<ExchangeWebResult<TResult[]>>> paginatedFunc, TRequest request, [EnumeratorCancellation]CancellationToken ct = default)
+        public static async IAsyncEnumerable<ExchangeWebResult<T[]>> ExecutePages<T, U>(Func<U, INextPageToken?, CancellationToken, Task<ExchangeWebResult<T[]>>> paginatedFunc, U request, [EnumeratorCancellation]CancellationToken ct = default)
         {
-        var result = new List<TResult>();
+            var result = new List<T>();
-        ExchangeWebResult<TResult[]> batch;
+            ExchangeWebResult<T[]> batch;
             INextPageToken? nextPageToken = null;
             while (true)
             {
@@ -345,6 +360,104 @@ public static class ExchangeHelpers
 
         }
 
+        /// <summary>
+        /// Queue updates received from a websocket subscriptions and process them async
+        /// </summary>
+        /// <typeparam name="T">The queued update type</typeparam>
+        /// <param name="subscribeCall">The subscribe call</param>
+        /// <param name="asyncHandler">The async update handler</param>
+        /// <param name="maxQueuedItems">The max number of updates to be queued up. When happens when the queue is full and a new write is attempted can be specified with <see>fullMode</see></param>
+        /// <param name="fullBehavior">What should happen if the queue contains <see>maxQueuedItems</see> pending updates. If no max is set this setting is ignored</param>
+        public static async Task<CallResult<UpdateSubscription>> ProcessQueuedAsync<T>(
+            Func<Action<DataEvent<T>>, Task<CallResult<UpdateSubscription>>> subscribeCall,
+            Func<DataEvent<T>, Task> asyncHandler,
+            int? maxQueuedItems = null,
+            QueueFullBehavior? fullBehavior = null)
+        {
+            var processor = new ProcessQueue<DataEvent<T>>(asyncHandler, maxQueuedItems, fullBehavior);
+            await processor.StartAsync().ConfigureAwait(false);
+            var result = await subscribeCall(upd => processor.Write(upd)).ConfigureAwait(false);
+            if (!result)
+            {
+                await processor.StopAsync().ConfigureAwait(false);
+                return result;
+            }
+
+            processor.Exception += result.Data._subscription.InvokeExceptionHandler;
+            result.Data.SubscriptionStatusChanged += (upd) =>
+            {
+                if (upd == CryptoExchange.Net.Objects.SubscriptionStatus.Closed)
+                    _ = processor.StopAsync(true);
+            };
+
+            return result;
+        }
+
+        /// <summary>
+        /// Queue updates and process them async
+        /// </summary>
+        /// <typeparam name="T">The queued update type</typeparam>
+        /// <param name="subscribeCall">The subscribe call</param>
+        /// <param name="asyncHandler">The async update handler</param>
+        /// <param name="maxQueuedItems">The max number of updates to be queued up. When happens when the queue is full and a new write is attempted can be specified with <see>fullMode</see></param>
+        /// <param name="fullBehavior">What should happen if the queue contains <see>maxQueuedItems</see> pending updates. If no max is set this setting is ignored</param>
+        /// <param name="ct">Cancellation token to stop the processing</param>
+        public static async Task ProcessQueuedAsync<T>(
+            Func<Action<T>, Task> subscribeCall,
+            Func<T, Task> asyncHandler,
+            CancellationToken ct,
+            int? maxQueuedItems = null,
+            QueueFullBehavior? fullBehavior = null)
+        {
+            var processor = new ProcessQueue<T>(asyncHandler, maxQueuedItems, fullBehavior);
+            await processor.StartAsync().ConfigureAwait(false);
+            ct.Register(async () =>
+            {
+                await processor.StopAsync().ConfigureAwait(false);
+            });
+
+            await subscribeCall(upd => processor.Write(upd)).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Queue updates received from a websocket subscriptions and process them async
+        /// </summary>
+        /// <typeparam name="TEventType">The type of the queued item</typeparam>
+        /// <typeparam name="TOutputType">The type of the item to pass to the processor</typeparam>
+        /// <param name="subscribeCall">The subscribe call</param>
+        /// <param name="mapper">The mapper function to go from <see>TEventType</see> to <see>TOutputType</see></param>
+        /// <param name="asyncHandler">The async update handler</param>
+        /// <param name="maxQueuedItems">The max number of updates to be queued up. When happens when the queue is full and a new write is attempted can be specified with <see>fullMode</see></param>
+        /// <param name="fullBehavior">What should happen if the queue contains <see>maxQueuedItems</see> pending updates. If no max is set this setting is ignored</param>
+        public static async Task<CallResult<UpdateSubscription>> ProcessQueuedAsync<TEventType, TOutputType>(
+            Func<ProcessQueue<DataEvent<TEventType>>, Task<CallResult<UpdateSubscription>>> subscribeCall,
+            Func<DataEvent<TEventType>, DataEvent<TOutputType>> mapper,
+            Func<DataEvent<TOutputType>, Task> asyncHandler,
+            int? maxQueuedItems = null,
+            QueueFullBehavior? fullBehavior = null
+            )
+        {
+            var processor = new ProcessQueue<DataEvent<TEventType>>((update) => {
+                return asyncHandler.Invoke(mapper.Invoke(update));
+            }, maxQueuedItems, fullBehavior);
+            await processor.StartAsync().ConfigureAwait(false);
+            var result = await subscribeCall(processor).ConfigureAwait(false);
+            if (!result)
+            {
+                await processor.StopAsync().ConfigureAwait(false);
+                return result;
+            }
+
+            processor.Exception += result.Data._subscription.InvokeExceptionHandler;
+            result.Data.SubscriptionStatusChanged += (upd) =>
+            {
+                if (upd == SubscriptionStatus.Closed)
+                    _ = processor.StopAsync(true);
+            };
+
+            return result;
+        }
+
         /// <summary>
         /// Parse a decimal value from a string
         /// </summary>
@@ -388,3 +501,4 @@ public static class ExchangeHelpers
             return null;
         }
     }
+}

CryptoExchange.Net/ExchangeSymbolCache.cs

@@ -1,11 +1,11 @@
-using CryptoExchange.Net.SharedApis;
+using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace CryptoExchange.Net;
+namespace CryptoExchange.Net
-
+{
     /// <summary>
     /// Cache for symbol parsing
     /// </summary>
@@ -66,3 +66,4 @@ public static class ExchangeSymbolCache
             }
         }
     }
+}

CryptoExchange.Net/ExtensionMethods.cs

@@ -1,18 +1,18 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.SharedApis;
+using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
-using System.IO.Compression;
+using System.Globalization;
 using System.IO;
+using System.IO.Compression;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Web;
-using CryptoExchange.Net.Objects;
-using System.Globalization;
-using Microsoft.Extensions.DependencyInjection;
-using CryptoExchange.Net.SharedApis;
-
-namespace CryptoExchange.Net;
 
+namespace CryptoExchange.Net
+{
     /// <summary>
     /// Helper methods
     /// </summary>
@@ -61,30 +61,71 @@ public static class ExtensionMethods
         /// <returns></returns>
         public static string CreateParamString(this IDictionary<string, object> parameters, bool urlEncodeValues, ArrayParametersSerialization serializationType)
         {
-        var uriString = string.Empty;
+            var uriString = new StringBuilder();
-        var arraysParameters = parameters.Where(p => p.Value.GetType().IsArray).ToList();
+            bool first = true;
-        foreach (var arrayEntry in arraysParameters)
+            foreach(var parameter in parameters)
+            {
+                if (!first)
+                    uriString.Append("&");
+
+                first = false;
+
+                if (parameter.Value.GetType().IsArray)
                 {
                     if (serializationType == ArrayParametersSerialization.Array)
                     {
-                uriString += $"{string.Join("&", ((object[])(urlEncodeValues ? Uri.EscapeDataString(arrayEntry.Value.ToString()!) : arrayEntry.Value)).Select(v => $"{arrayEntry.Key}[]={string.Format(CultureInfo.InvariantCulture, "{0}", v)}"))}&";
+                        foreach(var entry in (object[])parameter.Value)
+                        {
+                            uriString.Append(parameter.Key);
+                            uriString.Append("[]=");
+                            if (urlEncodeValues)
+                                uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", entry)));
+                            else
+                                uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", entry));
+                        }
                     }
                     else if (serializationType == ArrayParametersSerialization.MultipleValues)
                     {
-                var array = (Array)arrayEntry.Value;
+                        foreach (var entry in (object[])parameter.Value)
-                uriString += string.Join("&", array.OfType<object>().Select(a => $"{arrayEntry.Key}={Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", a))}"));
+                        {
-                uriString += "&";
+                            uriString.Append(parameter.Key);
+                            uriString.Append("=");
+                            if (urlEncodeValues)
+                                uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", entry)));
+                            else
+                                uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", entry));
+                        }
                     }
                     else
                     {
-                var array = (Array)arrayEntry.Value;
+                        uriString.Append('[');
-                uriString += $"{arrayEntry.Key}=[{string.Join(",", array.OfType<object>().Select(a => string.Format(CultureInfo.InvariantCulture, "{0}", a)))}]&";
+                        var firstArrayEntry = true;
+                        foreach (var entry in (object[])parameter.Value)
+                        {
+                            if (!firstArrayEntry)
+                                uriString.Append(',');                            
+
+                            firstArrayEntry = false;
+                            if (urlEncodeValues)
+                                uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", entry)));
+                            else
+                                uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", entry));
+                        }
+                        uriString.Append(']');
+                    }
+                }
+                else 
+                {
+                    uriString.Append(parameter.Key);
+                    uriString.Append('=');
+                    if (urlEncodeValues)
+                        uriString.Append(Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", parameter.Value)));
+                    else
+                        uriString.Append(string.Format(CultureInfo.InvariantCulture, "{0}", parameter.Value));
                 }
             }
 
-        uriString += $"{string.Join("&", parameters.Where(p => !p.Value.GetType().IsArray).Select(s => $"{s.Key}={(urlEncodeValues ? Uri.EscapeDataString(string.Format(CultureInfo.InvariantCulture, "{0}", s.Value)) : string.Format(CultureInfo.InvariantCulture, "{0}", s.Value))}"))}";
+            return uriString.ToString();
-        uriString = uriString.TrimEnd('&');
-        return uriString;
         }
 
         /// <summary>
@@ -230,18 +271,16 @@ public static class ExtensionMethods
         /// <summary>
         /// Append a base url with provided path
         /// </summary>
-    /// <param name="url"></param>
-    /// <param name="path"></param>
-    /// <returns></returns>
         public static string AppendPath(this string url, params string[] path)
         {
-        if (!url.EndsWith("/"))
+            var sb = new StringBuilder(url.TrimEnd('/'));
-            url += "/";
+            foreach (var subPath in path)
+            {
+                sb.Append('/');
+                sb.Append(subPath.Trim('/'));
+            }
 
-        foreach (var item in path)
+            return sb.ToString();
-            url += item.Trim('/') + "/";
-
-        return url.TrimEnd('/');
         }
 
         /// <summary>
@@ -363,19 +402,40 @@ public static class ExtensionMethods
         /// <summary>
         /// Decompress using GzipStream
         /// </summary>
-    /// <param name="data"></param>
+        public static ReadOnlySpan<byte> DecompressGzip(this ReadOnlySpan<byte> data)
-    /// <returns></returns>
+        {
+            using var decompressedStream = new MemoryStream();
+            using var deflateStream = new GZipStream(new MemoryStream(data.ToArray()), CompressionMode.Decompress);
+            deflateStream.CopyTo(decompressedStream);
+            return new ReadOnlySpan<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
+        }
+
+        /// <summary>
+        /// Decompress using GzipStream
+        /// </summary>
         public static ReadOnlyMemory<byte> DecompressGzip(this ReadOnlyMemory<byte> data)
         {
             using var decompressedStream = new MemoryStream();
             using var dataStream = MemoryMarshal.TryGetArray(data, out var arraySegment)
                 ? new MemoryStream(arraySegment.Array!, arraySegment.Offset, arraySegment.Count)
                 : new MemoryStream(data.ToArray());
-        using var deflateStream = new GZipStream(new MemoryStream(data.ToArray()), CompressionMode.Decompress);
+            using var deflateStream = new GZipStream(dataStream, CompressionMode.Decompress);
             deflateStream.CopyTo(decompressedStream);
             return new ReadOnlyMemory<byte>(decompressedStream.GetBuffer(), 0, (int)decompressedStream.Length);
         }
 
+        /// <summary>
+        /// Decompress using GzipStream
+        /// </summary>
+        public static ReadOnlySpan<byte> Decompress(this ReadOnlySpan<byte> input)
+        {
+            using var output = new MemoryStream();
+            using var compressStream = new MemoryStream(input.ToArray());
+            using var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress);
+            decompressor.CopyTo(output);
+            return new ReadOnlySpan<byte>(output.GetBuffer(), 0, (int)output.Length);
+        }
+
         /// <summary>
         /// Decompress using DeflateStream
         /// </summary>
@@ -385,10 +445,9 @@ public static class ExtensionMethods
         {
             var output = new MemoryStream();
 
-        using (var compressStream = new MemoryStream(input.ToArray()))
+            using var compressStream = new MemoryStream(input.ToArray());
-        using (var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress))
+            using var decompressor = new DeflateStream(compressStream, CompressionMode.Decompress);
             decompressor.CopyTo(output);
-
             output.Position = 0;
             return new ReadOnlyMemory<byte>(output.GetBuffer(), 0, (int)output.Length);
         }
@@ -413,6 +472,36 @@ public static class ExtensionMethods
         /// </summary>
         public static bool IsDelivery(this TradingMode type) => type == TradingMode.DeliveryInverse || type == TradingMode.DeliveryLinear;
 
+        /// <summary>
+        /// Whether the account type is a futures account
+        /// </summary>
+        public static bool IsFuturesAccount(this SharedAccountType type) =>
+            type == SharedAccountType.PerpetualLinearFutures
+            || type == SharedAccountType.DeliveryLinearFutures
+            || type == SharedAccountType.PerpetualInverseFutures
+            || type == SharedAccountType.DeliveryInverseFutures;
+
+        /// <summary>
+        /// Whether the account type is a margin account
+        /// </summary>
+        public static bool IsMarginAccount(this SharedAccountType type) =>
+            type == SharedAccountType.CrossMargin
+            || type == SharedAccountType.IsolatedMargin;
+
+        /// <summary>
+        /// Map a TradingMode value to a SharedAccountType enum value
+        /// </summary>
+        public static SharedAccountType ToAccountType(this TradingMode mode)
+        {
+            if (mode == TradingMode.Spot) return SharedAccountType.Spot;
+            if (mode == TradingMode.PerpetualLinear) return SharedAccountType.PerpetualLinearFutures;
+            if (mode == TradingMode.PerpetualInverse) return SharedAccountType.PerpetualInverseFutures;
+            if (mode == TradingMode.DeliveryInverse) return SharedAccountType.DeliveryInverseFutures;
+            if (mode == TradingMode.DeliveryLinear) return SharedAccountType.DeliveryLinearFutures;
+
+            throw new ArgumentException(nameof(mode), "Unmapped trading mode");
+        }
+
         /// <summary>
         /// Register rest client interfaces
         /// </summary>
@@ -442,6 +531,8 @@ public static class ExtensionMethods
                 services.AddTransient(x => (IFeeRestClient)client(x)!);
             if (typeof(IBookTickerRestClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (IBookTickerRestClient)client(x)!);
+            if (typeof(ITransferRestClient).IsAssignableFrom(typeof(T)))
+                services.AddTransient(x => (ITransferRestClient)client(x)!);
 
             if (typeof(ISpotOrderRestClient).IsAssignableFrom(typeof(T)))
                 services.AddTransient(x => (ISpotOrderRestClient)client(x)!);
@@ -517,4 +608,5 @@ public static class ExtensionMethods
             return services;
         }
     }
+}
 

CryptoExchange.Net/Interfaces/Clients/IBaseApiClient.cs

@@ -0,0 +1,47 @@
+using CryptoExchange.Net.Authentication;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.SharedApis;
+using System;
+
+namespace CryptoExchange.Net.Interfaces.Clients
+{
+    /// <summary>
+    /// Base api client
+    /// </summary>
+    public interface IBaseApiClient
+    {
+        /// <summary>
+        /// Base address
+        /// </summary>
+        string BaseAddress { get; }
+
+        /// <summary>
+        /// Whether or not API credentials have been configured for this client. Does not check the credentials are actually valid.
+        /// </summary>
+        bool Authenticated { get; }
+
+        /// <summary>
+        /// Format a base and quote asset to an exchange accepted symbol 
+        /// </summary>
+        /// <param name="baseAsset">The base asset</param>
+        /// <param name="quoteAsset">The quote asset</param>
+        /// <param name="tradingMode">The trading mode</param>
+        /// <param name="deliverDate">The deliver date for a delivery futures symbol</param>
+        /// <returns></returns>
+        string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
+
+        /// <summary>
+        /// Set the API credentials for this API client
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="credentials"></param>
+        void SetApiCredentials<T>(T credentials) where T : ApiCredentials;
+
+        /// <summary>
+        /// Set new options. Note that when using a proxy this should be provided in the options even when already set before or it will be reset.
+        /// </summary>
+        /// <typeparam name="T">Api credentials type</typeparam>
+        /// <param name="options">Options to set</param>
+        void SetOptions<T>(UpdateOptions<T> options) where T : ApiCredentials;
+    }
+}

CryptoExchange.Net/Interfaces/Clients/ICryptoRestClient.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace CryptoExchange.Net.Interfaces.Clients
+{
+    /// <summary>
+    /// Client for accessing REST API's for different exchanges
+    /// </summary>
+    public interface ICryptoRestClient
+    {
+        /// <summary>
+        /// Try get 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        T TryGet<T>(Func<T> createFunc);
+    }
+}

CryptoExchange.Net/Interfaces/Clients/ICryptoSocketClient.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace CryptoExchange.Net.Interfaces.Clients
+{
+    /// <summary>
+    /// Client for accessing Websocket API's for different exchanges
+    /// </summary>
+    public interface ICryptoSocketClient
+    {
+        /// <summary>
+        /// Try get a client by type for the service collection
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        T TryGet<T>(Func<T> createFunc);
+    }
+}

CryptoExchange.Net/Interfaces/Clients/IRestApiClient.cs

@@ -0,0 +1,18 @@
+namespace CryptoExchange.Net.Interfaces.Clients
+{
+    /// <summary>
+    /// Base rest API client
+    /// </summary>
+    public interface IRestApiClient : IBaseApiClient
+    {
+        /// <summary>
+        /// The factory for creating requests. Used for unit testing
+        /// </summary>
+        IRequestFactory RequestFactory { get; set; }
+
+        /// <summary>
+        /// Total amount of requests made with this API client
+        /// </summary>
+        int TotalRequestsMade { get; set; }
+    }
+}

CryptoExchange.Net/Interfaces/Clients/IRestClient.cs

@@ -0,0 +1,26 @@
+using System;
+using CryptoExchange.Net.Objects.Options;
+
+namespace CryptoExchange.Net.Interfaces.Clients
+{
+    /// <summary>
+    /// Base class for rest API implementations
+    /// </summary>
+    public interface IRestClient: IDisposable
+    {
+        /// <summary>
+        /// The options provided for this client
+        /// </summary>
+        ExchangeOptions ClientOptions { get; }
+
+        /// <summary>
+        /// The total amount of requests made with this client
+        /// </summary>
+        int TotalRequestsMade { get; }
+
+        /// <summary>
+        /// The exchange name
+        /// </summary>
+        string Exchange { get; }
+    }
+}

CryptoExchange.Net/Interfaces/Clients/ISocketApiClient.cs

@@ -0,0 +1,76 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Sockets.Default.Interfaces;
+using CryptoExchange.Net.Sockets.HighPerf.Interfaces;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Interfaces.Clients
+{
+    /// <summary>
+    /// Socket API client
+    /// </summary>
+    public interface ISocketApiClient: IBaseApiClient
+    {
+        /// <summary>
+        /// The current amount of socket connections on the API client
+        /// </summary>
+        int CurrentConnections { get; }
+        /// <summary>
+        /// The current amount of subscriptions over all connections
+        /// </summary>
+        int CurrentSubscriptions { get; }
+        /// <summary>
+        /// Incoming data Kbps
+        /// </summary>
+        double IncomingKbps { get; }
+        /// <summary>
+        /// The factory for creating sockets. Used for unit testing
+        /// </summary>
+        IWebsocketFactory SocketFactory { get; set; }
+        /// <summary>
+        /// High performance websocket factory
+        /// </summary>
+        IHighPerfConnectionFactory? HighPerfConnectionFactory { get; set; }
+        /// <summary>
+        /// Current client options
+        /// </summary>
+        SocketExchangeOptions ClientOptions { get; }
+        /// <summary>
+        /// Current API options
+        /// </summary>
+        SocketApiOptions ApiOptions { get; }
+        /// <summary>
+        /// Log the current state of connections and subscriptions
+        /// </summary>
+        string GetSubscriptionsState(bool includeSubDetails = true);
+        /// <summary>
+        /// Reconnect all connections
+        /// </summary>
+        /// <returns></returns>
+        Task ReconnectAsync();
+        /// <summary>
+        /// Unsubscribe all subscriptions
+        /// </summary>
+        /// <returns></returns>
+        Task UnsubscribeAllAsync();
+        /// <summary>
+        /// Unsubscribe an update subscription
+        /// </summary>
+        /// <param name="subscriptionId">The id of the subscription to unsubscribe</param>
+        /// <returns></returns>
+        Task<bool> UnsubscribeAsync(int subscriptionId);
+        /// <summary>
+        /// Unsubscribe an update subscription
+        /// </summary>
+        /// <param name="subscription">The subscription to unsubscribe</param>
+        /// <returns></returns>
+        Task UnsubscribeAsync(UpdateSubscription subscription);
+
+        /// <summary>
+        /// Prepare connections which can subsequently be used for sending websocket requests. Note that this is not required. If not prepared it will be initialized at the first websocket request.
+        /// </summary>
+        /// <returns></returns>
+        Task<CallResult> PrepareConnectionsAsync();
+    }
+}

CryptoExchange.Net/Interfaces/Clients/ISocketClient.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Threading.Tasks;
+using CryptoExchange.Net.Objects.Options;
+using CryptoExchange.Net.Objects.Sockets;
+
+namespace CryptoExchange.Net.Interfaces.Clients
+{
+    /// <summary>
+    /// Base class for socket API implementations
+    /// </summary>
+    public interface ISocketClient: IDisposable
+    {
+        /// <summary>
+        /// The exchange name
+        /// </summary>
+        string Exchange { get; }
+
+        /// <summary>
+        /// The options provided for this client
+        /// </summary>
+        ExchangeOptions ClientOptions { get; }
+
+        /// <summary>
+        /// Incoming kilobytes per second of data
+        /// </summary>
+        public double IncomingKbps { get; }
+
+        /// <summary>
+        /// The current amount of connections to the API from this client. A connection can have multiple subscriptions.
+        /// </summary>
+        public int CurrentConnections { get; }
+        
+        /// <summary>
+        /// The current amount of subscriptions running from the client
+        /// </summary>
+        public int CurrentSubscriptions { get; }
+
+        /// <summary>
+        /// Unsubscribe from a stream using the subscription id received when starting the subscription
+        /// </summary>
+        /// <param name="subscriptionId">The id of the subscription to unsubscribe</param>
+        /// <returns></returns>
+        Task UnsubscribeAsync(int subscriptionId);
+
+        /// <summary>
+        /// Unsubscribe from a stream
+        /// </summary>
+        /// <param name="subscription">The subscription to unsubscribe</param>
+        /// <returns></returns>
+        Task UnsubscribeAsync(UpdateSubscription subscription);
+
+        /// <summary>
+        /// Unsubscribe all subscriptions
+        /// </summary>
+        /// <returns></returns>
+        Task UnsubscribeAllAsync();
+    }
+}

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,3 +13,4 @@ internal interface IAuthTimeProvider
         /// <returns></returns>
         DateTime GetTime();
     }
+}

CryptoExchange.Net/Interfaces/IBaseApiClient.cs

@@ -1,46 +0,0 @@
-using CryptoExchange.Net.Authentication;
-using CryptoExchange.Net.Objects.Options;
-using CryptoExchange.Net.SharedApis;
-using System;
-
-namespace CryptoExchange.Net.Interfaces;
-
-/// <summary>
-/// Base api client
-/// </summary>
-public interface IBaseApiClient
-{
-    /// <summary>
-    /// Base address
-    /// </summary>
-    string BaseAddress { get; }
-
-    /// <summary>
-    /// Whether or not API credentials have been configured for this client. Does not check the credentials are actually valid.
-    /// </summary>
-    bool Authenticated { get; }
-
-    /// <summary>
-    /// Format a base and quote asset to an exchange accepted symbol 
-    /// </summary>
-    /// <param name="baseAsset">The base asset</param>
-    /// <param name="quoteAsset">The quote asset</param>
-    /// <param name="tradingMode">The trading mode</param>
-    /// <param name="deliverDate">The deliver date for a delivery futures symbol</param>
-    /// <returns></returns>
-    string FormatSymbol(string baseAsset, string quoteAsset, TradingMode tradingMode, DateTime? deliverDate = null);
-
-    /// <summary>
-    /// Set the API credentials for this API client
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="credentials"></param>
-    void SetApiCredentials<T>(T credentials) where T : ApiCredentials;
-
-    /// <summary>
-    /// Set new options. Note that when using a proxy this should be provided in the options even when already set before or it will be reset.
-    /// </summary>
-    /// <typeparam name="T">Api credentials type</typeparam>
-    /// <param name="options">Options to set</param>
-    void SetOptions<T>(UpdateOptions<T> options) where T : ApiCredentials;
-}

CryptoExchange.Net/Interfaces/ICryptoRestClient.cs

@@ -1,16 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.Interfaces;
-
-/// <summary>
-/// Client for accessing REST API's for different exchanges
-/// </summary>
-public interface ICryptoRestClient
-{
-    /// <summary>
-    /// Try get 
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <returns></returns>
-    T TryGet<T>(Func<T> createFunc);
-}

CryptoExchange.Net/Interfaces/ICryptoSocketClient.cs

@@ -1,16 +0,0 @@
-using System;
-
-namespace CryptoExchange.Net.Interfaces;
-
-/// <summary>
-/// Client for accessing Websocket API's for different exchanges
-/// </summary>
-public interface ICryptoSocketClient
-{
-    /// <summary>
-    /// Try get a client by type for the service collection
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <returns></returns>
-    T TryGet<T>(Func<T> createFunc);
-}

CryptoExchange.Net/Interfaces/IExchangeService.cs

@@ -0,0 +1,13 @@
+namespace CryptoExchange.Net.Interfaces
+{
+    /// <summary>
+    /// Service for an exchange
+    /// </summary>
+    public interface IExchangeService
+    {
+        /// <summary>
+        /// The exchange the service is for
+        /// </summary>
+        public string ExchangeName { get; }
+    }
+}

CryptoExchange.Net/Interfaces/IMessageAccessor.cs

@@ -1,14 +1,12 @@
-using CryptoExchange.Net.Converters.MessageParsing;
+using CryptoExchange.Net.Converters.MessageParsing;
 using CryptoExchange.Net.Objects;
 using System;
-#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>
@@ -108,3 +106,4 @@ public interface IByteMessageAccessor : IMessageAccessor
         /// <param name="data"></param>
         CallResult Read(ReadOnlyMemory<byte> data);
     }
+}

CryptoExchange.Net/Interfaces/IMessageProcessor.cs

@@ -1,33 +0,0 @@
-using CryptoExchange.Net.Objects;
-using CryptoExchange.Net.Objects.Sockets;
-using CryptoExchange.Net.Sockets;
-using System;
-using System.Threading.Tasks;
-
-namespace CryptoExchange.Net.Interfaces;
-
-/// <summary>
-/// Message processor
-/// </summary>
-public interface IMessageProcessor
-{
-    /// <summary>
-    /// Id of the processor
-    /// </summary>
-    public int Id { get; }
-    /// <summary>
-    /// The matcher for this listener
-    /// </summary>
-    public MessageMatcher MessageMatcher { get; }
-    /// <summary>
-    /// Handle a message
-    /// </summary>
-    Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message, MessageHandlerLink matchedHandler);
-    /// <summary>
-    /// Deserialize a message into object of type
-    /// </summary>
-    /// <param name="accessor"></param>
-    /// <param name="type"></param>
-    /// <returns></returns>
-    CallResult<object> Deserialize(IMessageAccessor accessor, Type type);
-}

CryptoExchange.Net/Interfaces/IMessageSerializer.cs

@@ -1,5 +1,5 @@
-namespace CryptoExchange.Net.Interfaces;
+namespace CryptoExchange.Net.Interfaces
-
+{
     /// <summary>
     /// Serializer interface
     /// </summary>
@@ -32,3 +32,4 @@ public interface IStringMessageSerializer: IMessageSerializer
         /// <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,3 +11,4 @@ public interface INonceProvider
         /// <returns>Nonce value</returns>
         long GetNonce();
     }
+}